Problema e Motivação
Eu adoro jogos japoneses dos anos 1980. Felizmente, esses jogos ainda são jogáveis. Isso ocorre porque as empresas continuam lançando seus jogos em diferentes plataformas. É por isso que não consigo me sentir seguro. Se a empresa operadora falir sem uma herança adequada dos direitos de propriedade intelectual, o jogo pode ser perdido para sempre.
Além disso, escrevo um blog técnico para a Astar Network no Medium, e presumo que este artigo também possa ser perdido repentinamente. Não pesquisei a respeito, mas acredito que os dados deste artigo estejam armazenados em um servidor gerenciado pela empresa Medium. Não importa quantos leitores existam e quão úteis sejam meus artigos, há o risco de que o mecanismo de aplicação atual seja desativado, independentemente de sua utilidade ou natureza pública.
Não sou especialista em direitos autorais de programas de jogos, então não acredito que nenhum jogo lançado comercialmente poderá adotar imediatamente esse protocolo.
No entanto, quanto mais pública for a aplicação, mais importante é considerar a sustentabilidade. Além disso, no processo de decidir atualizar a aplicação, acredito que seja importante ter um processo no qual todas as partes interessadas possam decidir, em vez de ser uma decisão unilateral do Administrador ou Proprietário.
Esta é a única razão pela qual decidi implementar esse protocolo.
Desafios
Eu sempre acreditei no futuro das DAOs e implementei aplicativos descentralizados autônomos (DAO dApps) que rodam em contratos EVM (Máquina Virtual Ethereum) e WASM (WebAssembly).
https://github.com/realtakahashi/dao4.commons.shiden
https://github.com/realtakahashi/dao4commons.wasm
Mas minha crença não é tão forte. Para ser um pouco mais educado, eu não acredito nas seguintes afirmações: "as DAOs vão atualizar a nação", "as DAOs vão trazer paz ao mundo", "as DAOs vão eliminar a desigualdade no mundo", etc.
Acredito que somos nós que vamos melhorar nossas nações e trazer a paz ao mundo, reduzindo a desigualdade.
No entanto, não acredito que nós, com nossas habilidades limitadas, possamos resolver um problema tão grande de repente.
Há um provérbio japonês que diz: "Deus está nos detalhes" (em inglês, parece dizer "O diabo está nos detalhes"). Como diz o ditado, acredito que as pequenas ações das pessoas se acumulam e eventualmente se transformam em um grande poder. A "DAO" é apenas uma das ferramentas que podemos usar. Acredito que o importante não é ser uma DAO, mas sim o que fazer com a ferramenta DAO.
A partir de agora, gostaria de assumir o desafio de resolver várias questões sociais usando o "DAO Oriented Protocol" (Protocolo Orientado a DAO), um protocolo que permite a implementação fácil de DAOs. Abordarei casos de uso específicos mais adiante neste artigo.
Visão geral do "Protocolo Orientado a DAO"
Design Básico
Vou descrever primeiro as camadas mais inferiores deste protocolo.
- Ao instalar os contratos que implementam cada função ("Contrato A" e "Contrato B" neste exemplo) em "application_core" (núcleo da aplicação), é possível unificar a interface a partir do frontend. O "application_core" é projetado para que a aplicação frontend possa acessar cada função por meio da ABI (Interface Binária de Aplicação) do "application_core".
- Os contratos que implementam cada recurso ("Contrato A" e "Contrato B" neste exemplo) são projetados para poder executar transações e consultar dados entre si, implementando o trait "contract_base" (contrato base).
- A interface de execução de transações de cada contrato consiste em "Contrato de Destino", "Função de Destino" e "Parâmetro". Observação: No momento, todas as interfaces são tratadas como strings, mas é provável que esta interface precise ser aprimorada.
Ao observar essa aplicação na camada mais baixa, não existem elementos de DAO. Ao mesmo tempo em que unifica as interfaces entre vários contratos, é projetada como um "Sistema Operacional" que fornece uma interface unificada para aplicações externas, como o frontend.
Design Orientado a DAO
O movimento de todo o dApp depende das decisões tomadas na DAO. Cada transação de contrato é uma estrutura controlada por "Proposta" e "Eleição". O "Protocolo Orientado a DAO" executa o processamento de acordo com o seguinte fluxo básico:
- Criação de uma proposta para a funcionalidade do contrato que se deseja implementar. Além dos itens básicos, como "propósito e conteúdo", os itens necessários para a proposta são: "endereço do contrato de destino", "função de destino" e "parâmetros a serem passados para a função".
- A proposta será discutida pelos membros e, finalmente, decidida por votação.
- Propostas que são "aprovadas" por votação executarão a "Função de Destino" contra o "Contrato de Destino" informado no momento da submissão.
Detalhes do "Protocolo Orientado a DAO"
Software Pré-Instalado (contrato)
O "Protocolo Orientado a DAO" possui 3 softwares pré-instalados. Eles são necessários para que este dApp funcione como uma DAO mínima.
Gerenciador de Membros (Member Manager)
O "gerenciador de membros" gerencia os membros da DAO. Apenas os membros registrados aqui são considerados membros da DAO e podem executar ações como executar cada função, enviar propostas e votar.
Gerenciador de Propostas (Proposal Manager)
O "gerenciador de propostas" gerencia as propostas na DAO. Todas as propostas são votadas e avaliadas usando o recurso de "gerenciador de eleições". Propostas que forem aprovadas serão implementadas conforme originalmente proposto.
Gerenciador de Eleições (Election Manager)
O "gerenciador de eleições" gerencia as votações. A eleição é realizada de acordo com o resultado da votação e o resultado é salvo.
Alteração e Atualização
O "gerenciador de membros", o "gerenciador de propostas" e o "gerenciador de eleições" são todos alteráveis. Não é necessário usar a versão pré-instalada que preparei.
Além disso, o software (contrato) instalado no "núcleo da aplicação" é projetado para ser atualizável. Implante o contrato atualizado e migre os dados da funcionalidade existente. Em seguida, use o "gerenciador de propostas" para propor uma atualização e, se aprovada dentro da DAO, o software será atualizado.
Acredito que o "modelo de proxy", famoso por seu método de atualização de contrato, tenha a autoridade de atualização para o proprietário do contrato. No "Protocolo Orientado a DAO", apenas os resultados das votações entre os membros têm autoridade de atualização.
Instalação e Desinstalação de Software (contrato)
O software aprovado pela DAO usando o "gerenciador de propostas" pode ser instalado no "núcleo da aplicação". Uma vez instalado, ele poderá invocar transações por meio do "núcleo da aplicação". Da mesma forma, o software que não é mais necessário pode ser desinstalado.
Visão Futura do "Protocolo Orientado a DAO"
Mais uma vez, quero que este protocolo seja como um sistema operacional de dApp. A intenção não é ganhar dinheiro ou vencer a concorrência na indústria, mas aumentar a probabilidade de reutilização de contratos úteis.
O escopo de reutilização não se limita à palete de contratos da Astar Network. Ao usar a XCM (Cross-Consensus Message), é possível acessar outras funcionalidades de parachain na Polkadot a partir do "núcleo da aplicação" por meio de uma interface transparente. E com a XVM (Cross-Virtual Machine), é possível acessar funções na EVM (Máquina Virtual Ethereum) da Astar Network. Além disso, no futuro, quando as funções de nós da Astar forem estendidas e puderem ser sincronizadas com outras EVMs, sua reutilização poderá ser dramaticamente expandida.
Caso de Uso Assumido
Registro de dApps em "dApp Staking"
Se eu entendi corretamente, o processo de registro de dApps em "dApp Staking" atualmente é feito de forma manual. A ideia é implementar essa aplicação com o "Protocolo Orientado a DAO". As pessoas que desejam indicar um dApp enviam uma proposta. Os dApps aprovados por votação entre os membros serão registrados no "dApp Staking" por meio da extensão de cadeia.
Jogos sustentáveis geridos pela comunidade
É um método para implementar a lógica de um jogo como um dApp e operá-lo com uma DAO. Na verdade, acredito que seria difícil para um jogo comercial recém-lançado adotar esse método. No entanto, assumindo um jogo inventado pela comunidade e desenvolvido sob a iniciativa da comunidade, esse método pode ser proposto como uma forma de desfrutar do jogo por um longo tempo com sustentabilidade.
Vários dApps baseados em DAO
Acredito que as DAOs podem capacitar pequenas comunidades que não estão indo muito bem devido a razões como não conseguir estabelecer um valor monetário no momento. E acredito que uma pequena comunidade assim pode lidar com várias questões sociais. Presumo que vários dApps destinados ao uso da comunidade serão necessários no futuro, e acredito que este "Protocolo Orientado a DAO" será útil nesse momento.
Outros dApps baseados na sustentabilidade e comunidade
Espero que o mundo da web3 continue a implementar muitos dApps com uma filosofia que valoriza a descentralização e a comunidade. Nesse momento, ficarei extremamente feliz se houver pessoas que adotem esse protocolo que eu projetei.
Exemplo de uso do "Protocolo Orientado a DAO"
DAO Flipper
Escolhi este dApp como primeiro exemplo para demonstrar como usar o protocolo. A estrutura deste dApp é muito simples.
A implementação do contrato DAO Flipper é a seguinte: A parte característica é que a chamada de “flip” (inverter) é restrita apenas ao "gerenciador de propostas". Como o "gerenciador de propostas" é implementado para executar apenas o conteúdo da proposta que foi aprovada, essa proposta deve ser aprovada por uma votação dentro da DAO para que o valor seja invertido.
impl DaoOrientedFlipper {
#[ink(constructor)]
pub fn new(init_value: bool, proposal_manager_address:AccountId) -> Self {
Self {
proposal_manager_address,
command_list: [
"dao_flip".to_string(),
"set_application_core_address".to_string(),
].to_vec(),
application_core_address: None,
value: init_value,
}
}
#[ink(message)]
pub fn extarnal_get_data_interface(&self,target_function:String) -> Vec<Vec<u8>> {
self.get_data(target_function)
}
#[ink(message)]
pub fn extarnal_execute_interface(&mut self, command:String, parameters_csv:String, caller_eoa: AccountId) -> core::result::Result<(), ContractBaseError>{
self._execute_interface(command, parameters_csv, caller_eoa)
}
#[ink(message)]
pub fn get(&self) -> bool {
self.value
}
fn _dao_flip(&mut self, vec_of_parameters: Vec<String>, caller_eoa: AccountId) -> core::result::Result<(), ContractBaseError> {
if self._modifier_only_call_from_proposal() == false {
return Err(ContractBaseError::InvalidCallingFromOrigin);
}
self.value = !self.value;
return Ok(())
}
fn _modifier_only_call_from_proposal(&self) -> bool {
self.proposal_manager_address == self.env().caller()
}
}
Execute os seguintes passos para inverter o valor:
- Crie uma proposta que inverta o valor.
- A proposta deve ser votada e aprovada pelos membros da DAO.
- A execução de uma proposta aprovada irá inverter esse valor.
Tela superior do dApp de exemplo
Tela da listagem de softwares instalados
Tela de informações para inversão de valores de propostas
Tela dos resultados da Votação
Conclusão
Este protocolo é um dApp projetado e implementado para ser submetido ao "Hackadot 2023 East-Asia". O primeiro protótipo de dApp "dao flipper" finalmente está funcionando. Ao longo do caminho, muitas melhorias no design e implementação foram descobertas. Agora, tenho que começar a corrigir essas questões e implementar o dApp que eu queria construir com base nesse protocolo. As DAOs, que ainda não possuem uma rede baseada em DeFi ou NFT, não são um campo que desperta a atenção das pessoas. No entanto, acredito nas possibilidades das DAOs como uma ferramenta e gostaria de continuar implementando dApps baseados em DAO por enquanto.
Repositório: https://github.com/realtakahashi/dao_oriented_protocol
Artigo original publicado por Realtakahashi Work. Traduzido por Paulinho Giovannini.
Oldest comments (1)