Interpretación del contrato de fábrica de Sputnik DAO

1. Contrato de fábrica Sputnik-DAO

Sputnik-DAO utiliza un patrón de diseño de fábrica de creación para lograr la creación y gestión unificada de la organización autónoma descentralizada (DAO) en esta plataforma.

Este artículo presentará en detalle la implementación del diseño del modelo de fábrica del plataforma Sputnik-DAO (sputnikdao-factory).

El repositorio de código fuente del contrato correspondiente se encuentra en:

2. Introducción a las funciones del módulo DAPP

La página DAPP de la plataforma Sputnik DAO ya tiene varios organizaciones autónomas descentralizadas que han creado y personalizado sus propios objetos de instancia DAO ( contrato Sputnikdaov2 ).

Hasta marzo de 2022, el DAO más activo creado en la plataforma es news.sputnik-dao.near, que tiene 3051 propuestas (proposals) en votación pública o con estado cerrado.

A través de NEAR Explorer se puede descubrir que los contratos de instancia DAO de la plataforma están desplegados de manera uniforme por la cuenta NEAR sputnik-dao.near( y el contrato sputnikdao-factory ).

Es decir, todos los contratos de instancia DAO creados en la plataforma Sputnik DAO se despliegan por separado en las subcuentas de esa cuenta NEAR, por ejemplo:

• pcp.sputnik-dao.near
• test-dao-bro.sputnik-dao.near
• blaqkstereo.sputnik-dao.near
• octopode-dao.sputnik-dao.near

Las organizaciones descentralizadas pueden iniciar transacciones públicamente en la red principal de NEAR, creando nuevas instancias de DAO al invocar el método create() proporcionado por el contrato sputnikdao-factory.

3. Interpretación del código del contrato sputnikdao-factory

3.1 Crear DAO

El estado del contrato sputnikdao-factory se compone principalmente de las siguientes dos partes:

óxido pub struct SputnikDAOFactory { factory_manager: FactoryManager, daos: UnorderedSet\u003caccountid\u003e, }

• factory_manager: Implementación de la lógica funcional interna principal del contrato, que proporciona una serie de métodos para crear/eliminar/actualizar instancias de DAO.

• daos: utiliza una estructura de datos de conjunto, que registra las direcciones de cuenta NEAR de todas las instancias de DAO creadas en la historia de la plataforma.

El método create() del contrato sputnikdao-factory utilizado para crear instancias de DAO se define de la siguiente manera:

óxido #[payable] pub fn create(&mut self, name: AccountId, args: Base64VecU8) { let account_id: AccountId = format!('{}.{}', name, env::current_account_id()) .parse() .unwrap(); let callback_args = serde_json::to_vec(\u0026json!({ 'account_id': account_id, 'attached_deposit': U128(env::attached_deposit()), 'predecessor_account_id': env::predecessor_account_id() })) .expect('Error al serializar'); self.factory_manager.create_contract( self.get_default_code_hash(), account_id, 'nuevo', &args.0, 'on_create', &callback_args, ); }

implementación específica de factory_manager.create_contract:

óxido pub fn create_contract( &self, code_hash: Base58CryptoHash, account_id: AccountId, new_method: &str, args: [u8], callback_method: &str, callback_args: [u8], ) { let code_hash: CryptoHash = code_hash.into(); let attached_deposit = env::attached_deposit(); let factory_account_id = env::current_account_id().as_bytes().to_vec(); let account_id = account_id.as_bytes().to_vec(); unsafe { // Verifica que exista dicho contrato. assert_eq!( sys::storage_has_key(code_hash.len() como _, code_hash.as_ptr() como _), 1, 'El contrato no existe' ); // Cargar el código wasm de entrada ( en el registro 0. sys::storage_read)code_hash.len(( as _, code_hash.as_ptr)( as _, 0); // programar un tx de Promise a account_id let promise_id = sys::promise_batch_create)account_id.len(( as _, account_id.as_ptr)( as _); // crea una cuenta primero. sys::promise_batch_action_create_account)promise_id(; // transfer attached deposit. sys::promise_batch_action_transfer)promise_id, &attached_deposit as *const u128 as _(; // desplegar contrato )el código se toma del registro 0(. sys::promise_batch_action_deploy_contract)promise_id, u64::MAX as _, 0(; // llamar nuevo con los argumentos dados. sys::promise_batch_action_function_call) promise_id, new_method.len(( as _, new_method.as_ptr)( as _, args.len)( as _, args.as_ptr)( as _, &NO_DEPOSIT como *const u128 como _, CREATE_CALL_GAS.0, ); // adjuntar callback a la fábrica. let _ = sys::promise_then) promise_id, factory_account_id.len(( as _, factory_account_id.as_ptr)( as _, callback_method.len)( como _, callback_method.as_ptr)( as _, callback_args.len)( como _, callback_args.as_ptr)( as _, &NO_DEPOSIT como *const u128 como _, ON_CREATE_CALL_GAS.0, ); sys::promise_return)promise_id(; } }

![])https://img-cdn.gateio.im/webp-social/moments-373080ddb66a4cb83e0722b387056be0.webp(

Implementación del código interno de la función de retorno on_create:

óxido #) pub fn on_create[private] &mut self, account_id: AccountId, attached_deposit: U128, predecessor_account_id: AccountId, bool { if near_sdk::is_promise_success() { self.daos.insert(&account_id); verdadero } else { Promise::new(predecessor_account_id).transfer(attached_deposit.0); falso } }

( 3.2 actualización DAO

La interfaz de contrato proporcionada por el contrato de fábrica update)###:

óxido /// Intenta actualizar la cuenta dada creada por esta fábrica al código especificado. pub fn update(&self, account_id: AccountId, code_hash: Base58CryptoHash) { let caller_id = env::predecessor_account_id(); assert!( caller_id == self.get_owner)( || caller_id == account_id, 'Debe ser actualizado por el propietario de la fábrica o el DAO en sí mismo' (; assert!) self.daos.contains)&account_id(, 'Debe ser un contrato creado por la fábrica' (; self.factory_manager .actualizar_contrato)id_cuenta, hash_codigo, 'actualizar'); }

factory_manager.update_contract() detalles de procesamiento:

óxido /// Fuerza la actualización del contrato dado. /// El contrato debe admitir actualizaciones por parte de la fábrica para esto mediante una verificación de permisos. pub fn update_contract( &self, account_id: AccountId, code_hash: Base58CryptoHash, method_name: &str, ) { let code_hash: CryptoHash = code_hash.into(); let account_id = account_id.as_bytes().to_vec(); inseguro { // Verifica que dicho contrato exista. assert!(env::storage_has_key)&code_hash(, 'El contrato no existe'(; // Cargar el hash del almacenamiento. sys::storage_read)code_hash.len)( as _, code_hash.as_ptr() as _, 0(; // Crear una promesa hacia la cuenta dada. let promise_id = sys::promise_batch_create)account_id.len)( as _, account_id.as_ptr() as _(; // Llamar al método de actualización, que también debería manejar migraciones. sys::promise_batch_action_function_call) promise_id, method_name.len)( como _, method_name.as_ptr() as _, u64::MAX como _, 0, &NO_DEPOSIT como *const u128 como _, (env::prepaid_gas)( - env::used_gas() - GAS_UPDATE_LEFTOVER(.0,); sys::promise_return)promise_id); } }

4. Análisis de seguridad del contrato Sputnik-DAO Factory

La seguridad del contrato de la fábrica Sputnik-DAO se garantiza principalmente desde los siguientes aspectos:

• Control de permisos: Los métodos de tipo view que están abiertos en el contrato no deben modificar las variables de estado del contrato, es decir, el primer parámetro en la definición del método debe establecerse como &self, y no &mut self.

• Control de permisos: funciones privilegiadas abiertas del contrato, estas funciones solo pueden ser ejecutadas por el propietario del contrato ( o la cuenta del contrato DAO ), y existen las correspondientes afirmaciones en el método.

• Manejo de errores: El contrato de la fábrica Sputnik-DAO ha implementado mecanismos de manejo de errores razonables para las posibles situaciones excepcionales. Por ejemplo, al utilizar el contrato de la fábrica para crear un nuevo contrato de instancia DAO, se verificará al final que todos los pasos de creación se hayan ejecutado de manera normal y completa; de lo contrario, no se debería causar pérdidas al usuario.