Este artigo faz parte da série Construindo uma DAO na Moonbeam. Se você ainda não leu a outra parte, eu recomendo que primeiro você consulte os links acima.
Anteriormente, já apresentamos as funcionalidades e mergulhamos profundamente no código. Espero que vocês já conheçam o conceito de DAO simples e como ela é implementada.
Neste capítulo, tentaremos implantá-la no moonbeam e também tentaremos usar uma habilidade que o moonbeam nos fornece, o XCM. Algumas pessoas podem perguntar o que é exatamente o moonbeam e também o que é XCM? Não se preocupe, explicarei a você muito em breve por meio de um tutorial e de um código.
O que é Polkadot & moonbeam ?
Para não tornar este artigo muito longo, vou explicar apenas um breve conceito, para que vocês possam entender o que é.
Polkadot é outra rede blockchain que tem como filosofia se concentrar na Especialização e Conectividade. A Polkadot acreditava que pudéssemos fazer uma blockchain melhor em todos os aspectos. Deveríamos ter algum ecossistema de cadeias especializadas e fazer suas conexões sem problemas. Então a Polkadot introduziu o conceito de RelayChain (Camada 0), que é a rede principal que garante a segurança e a finalidade das cadeias especializadas e chamou de Parachains (Camada 1) as cadeias especializadas conectadas à RelayChain (N.T. As parachains são como blockchains construídas “em cima” da rede Polkadot, que compartilham seus níveis de segurança e podem interagir e compartilhar informações entre si.). A Polkadot também fornece o SDK (kit de desenvolvimento de software) para permitir que todos criem a parachain para plugin do Relaychain central. O Moonbeam é uma das parachains populares e muito especializadas para dapps e contratos inteligentes. O Moonbeam permite ao usuário migrar o aplicativo da ethereum e também aumenta a capacidade da dapp fornecida pela cadeia polkadot, como a transferência cross-chain etc.
Se você precisa ir mais fundo em mais detalhes sobre o moonbeam, por favor consulte aqui. É um grande recurso para começar e aprender sobre o moonbeam e o polkadot.
Como implantar Dapps?
Para implantar os dapps, é preciso se preparar para implantar 2 partes; a primeira é um contrato inteligente e a segunda é um cliente web frontend. Vamos nos concentrar apenas na primeira parte do contrato inteligente aqui, já que a parte do frontend é apenas a implantação normal na web. Não tem nada de especial lá. Então, vamos começar.
No template do nosso dapp, já está preparado o script para implantação. Vamos consultar o arquivo 00_deploy_your_contract.js. O script de implantação todo será criado aqui.
notas: o nome do script de implantação deve começar com o número ou data para nos ajudar a descobrir a sequência de implantação e nos deixar navegar para o último script de implantação mais facilmente.
// packages/hardhat/deploy/00_deploy_your_contract.js
module.exports = async ({ getNamedAccounts, deployments }) => {
const { deploy } = deployments;
const { deployer } = await getNamedAccounts();
const members = [
"<add-your-address-here>",
]; // carteira temporária do navegador e endereços powvt.eth.
PowDAO = await deploy("PowDAO", {
// Aprenda mais sobre args aqui: https://www.npmjs.com/package/hardhat-deploy#deploymentsdeploy
from: deployer,
args: [members],
log: true,
});
....
}
O template escolhe o hardhat como ferramenta para construir um ambiente de desenvolvimento e também ajuda a implantar o contrato. Se você não tem conhecimento sobre o hardhat, por favor, consulte aqui antes. O hardhat chamará a função padrão neste arquivo de script de implantação e passará as variáveis essenciais, como deployments e getNameAccounts. A deployments é o objeto que incluiu tudo sobre a implantação e também a função deploy que será utilizada para a implantação. A getNameAccounts também é um endereço de implantação que será explicada mais tarde.
Vamos verificar que o script é bem pequeno. Basicamente, ele apenas chama a função deploy com um parâmetro específico que indica o que iremos implantar. O primeiro parâmetro é o nome do seu contrato inteligente que será implantado. O segundo parâmetro é uma informação de configuração extra. Você deve definir from, que é o endereço do implantador, que nós obtivemos da getNameAccounts que foi retornada do hardhat. O segundo é args que é o valor do argumento que precisamos passar para o constructor do contrato inteligente. Normalmente, esse argumento será qualquer variável que precisamos configurar uma vez que o contrato seja implantado e que não poderá ser mudado nunca. Nesse exemplo, esse endereço é o membro inicial da DAO, pois precisamos que alguns dos primeiros membros tenham um subsídio para adicionar outro. O último é apenas um registro. Basta ativá-lo para ajudar a verificar mais facilmente o processo de implantação.
Configuração da rede para implantação
Este template também já preparou uma configuração do hardhat sobre a rede da blockchain a ser implantada. Vamos verificar o arquivo ackages/hardhat/hardhat.config.js. Este arquivo incluiu todas as configurações de declaração para redes e também algum código de script.
const defaultNetwork = "localMoonbeam"
...
module.exports = {
defaultNetwork,
networks: {
localhost: {
url: "http://localhost:8545",
},
....
localMoonbeam: {
url: "http://127.0.0.1:9933",
gasPrice: 1000000000,
chainId: 1281,
accounts: {
mnemonic: mnemonic(),
},
},
}
}
const DEBUG = true;
Este arquivo de configuração do hardhat exigiu que retornássemos a configuração da rede de hardhat. Como você pode ver, precisamos configurar o defaultNetwork como a rede para a qual precisamos fazer o deploy e também networks como a informação de cada configuração da rede.
E não se esqueça de mudar o sinalizador para true
const DEBUG = true;
Para que possamos visualizar todo o mecanismo da implantação.
Vamos acrescentar a configuração localMoonbeam a essa configuração.
localMoonbeam: {
url: "http://127.0.0.1:9933",
gasPrice: 1000000000,
chainId: 1281,
accounts: {
mnemonic: mnemonic(),
},
},
url é o url da RPC usado para a ligação do hardhat com a rede.
gasPrice é o gás que você precisa gastar quando faz o deploy.
chainId precisa ser 1281 para o nó local do moonbeam. (Sim, nós o implantaremos primeiro para o nó local autônomo. Eu mostrarei a você como executá-lo em breve)
accounts é a conta para implantação. Você pode ficar curioso por saber por que ainda precisamos definir o endereço do implantador aqui novamente, se já o adicionamos anteriormente no script. Vamos usar HDWallet para guardar as chaves privadas e a mnemonic (mnemônica), a chave legível que nos deu acesso a todos os endereços internos. Se você não estiver familiarizado com o conceito de HDWallet, sugiro fortemente que verifique este Link primeiro.
Muito bem, então vamos gerar primeiro o endereço da carteira do implantador. O template também já preparou o script para nós 🤩
Basta executar:
yarn generate
Você deverá ter o seguinte retorno:
$ yarn workspace @scaffold-eth/hardhat generate
$ hardhat generate
mnemonic <your-mnemonic>
privateKey <private-address>
🔐 Account Generated as <address> and set as mnemonic in packages/hardhat (Conta gerada como <address> e definida como mnemonic nos pacotes/hardhat
💬 Use 'yarn run account' to get more information about the deployment account. (Use 'yarn account' para obter mais informações sobre a conta de implantação.
✨ Done in 4.59s. (Concluído em 4,59s)
Por favor, guarde bem a privateKey e address. Precisaremos usá-las no próximo passo.
(Se você não pode ver o privado, por favor, cheque novamente para verificar se você já mudou o sinalizador DEBUG no script de implantação)
Executar o nó local autônomo do Moonbeam & conectar à polkadot.js
Honestamente, para não tornar este artigo muito longo, poderíamos seguir este Roteiro Moonbeam para executar o nó e conectar à polkadot.js. Assim, basicamente, precisamos girar um docker (é uma tecnologia de conteinerização open source projetada para desenvolvedores e usada para empacotar, entregar e executar aplicações) para o nó de desenvolvimento moonbeam e conectar a polkadot.js para seu nó local.
polkadot.js é um aplicativo saas (software como serviço) fornecido pelo time polkadot que possui muitas ferramentas úteis para conectar e explorar a rede de ecossistemas Polkadot. Você pode consultá-lo aqui https://polkadot.js.org/apps
Então, suponha que você já tenha configurado tudo. Siga o documento da Moonbeam e depois vamos usá-lo para transferir dinheiro para nossa carteira local.
Primeiro de tudo, clique na página da conta a partir da barra de navegação acima.
A seguir, verifique a lista.
Aqui está a lista de endereços de usuários pré-criados neste nó local. Cada um tem 1 milhão de moedas para que possamos nos divertir. Portanto, clique no botão "Send" (Enviar) para enviar algum ativo para nosso endereço gerado.
A seguir, preencha com o endereço que você obteve da etapa acima yarn generate como endereço de destino para transferir. Preencha a quantia que deve ser pelo menos 100 para ter mais liquidez e depois clique em send e “sign & submit” (assinar e submeter).
O polkadot.js exibirá uma notificação para garantir que sua transação já esteja escrita no bloco.
Para confirmar, você pode verificar o resultado da transação em Network > Explorer., essa página irá mostrar o último evento ocorrido on chain. Assim, você deverá ver que essa transação de transferência ocorreu com sucesso.
E como antes, o template já preparou um script de compilação para nós.
yarn compile
Você deverá ter o seguinte retorno:
$ yarn workspace @scaffold-eth/hardhat compile
$ hardhat compile
Compiling 3 files with 0.6.7 (Compilando 3 arquivos com 0.6.7)
Compilation finished successfully (Compilação finalizada com sucesso)
✨ Done in 5.35s. (Concluído em 5,35s)
Este resultado indica que o compilador já compilou 3 contratos inteligentes (incluindo outros contratos no template) com uma versão do Solidity 0.6.7. Se você precisa configurar o compilador, por favor verifique esta configuração no arquivo hardhat.config.js.
solidity: {
compilers: [
{
version: "0.6.7",
settings: {
optimizer: {
enabled: true,
runs: 200,
},
},
},
],
},
Estamos prontos para fazer o deploy agora. Vamos executar:
yarn deploy
Após a execução do script de implantação, o resultado deve ficar assim:
yarn run v1.22.10
$ yarn workspace @scaffold-eth/hardhat deploy
$ hardhat deploy --export-all ../react-app/src/contracts/hardhat_contracts.json
Nothing to compile
deploying "PowDAO" (tx: <tx-hash>)...: deployed at <contract-address> with 2083695 gas
$ hardhat run scripts/publish.js
✅ Published contracts to the subgraph package. Contratos publicados para o pacote subgraph.
✨ Done in 4.79s. (Concluído em 4,79s)
O contrato será implantado para sua cadeia moonbeam e também o endereço será exibido no contrato e o hash exclusivo da transação. Certifique-se de ver esta mensagem em seu nó moonbeam local do docker.
2022-04-14 05:37:54 🙌 Starting consensus session on top of parent <adderess>
2022-04-14 05:37:54 🎁 Prepared block for proposing at 11 (35 ms) [hash: <hash>; parent_hash: 0x410c…2783; extrinsics (4): [0xeeac…02d8, 0xb6c1…e2c7, 0xef12…0427, 0x5b23…63d1]]
2022-04-14 05:37:54 ✨ Imported #11 (0xcb13…5c3f)
2022-04-14 05:37:54 Instant Seal success: CreatedBlock { hash: <hash>, aux: ImportedAux { header_only: false, clear_justification_requests: false, needs_justification: false, bad_justification: false, is_new_best: true } }
2022-04-14 05:37:55 💤 Idle (0 peers), best: #11 (0xcb13…5c3f), finalized #0 (0x6103…acbe), ⬇ 0 ⬆ 0
Uhuuu 🎉 🎉 🎉 seu contrato já está implantado no seu nó local moonbeam agora.
Para verificar as funcionalidades, você pode executar o aplicativo React com:
yarn start
Mas não se esqueça de mudar a cadeia alvo no código do react para apontar para sua rede local Moonbeam.
Primeiro, você tem que adicionar a configuração de rede para a rede local Moonbeam no aplicativo React.
// packages/react-app/src/constants.js
export const NETWORKS = {
localhost: {
name: "localhost",
color: "#666666",
chainId: 31337,
blockExplorer: "",
rpcUrl: "http://" + window.location.hostname + ":8545",
},
...
localMoonbeam: {
name: "Local Moonbeam",
gasPrice: 1000000000,
chainId: 1281,
color: "#00b0ef",
rpcUrl: "http://127.0.0.1:9933",
},
}
Adicione o name que você quiser. O gasPrice pode ser copiado da primeira configuração acima (existem alguns truques para definição do preço do gás. Vou fazer um artigo sobre o preço do gás e estratégias para reduzi-lo muito em breve). A chainId é a mesma que você configura no hardhat e também a rpcUrl deve apontar para seu nó Moonbeam em execução no container Docker, em sua máquina local.
Então, vá para o React no arquivo App.jsx para mudar o aplicativo para apontar para a rede moonbeam em vez da cadeia local padrão hardhat.
// packages/react-app/src/App.jsx
/// 📡 What chain are your contracts deployed to? (Seus contratos são implantados em que cadeia?)
const targetNetwork = NETWORKS.localMoonbeam;
Então atualize sua IU (interface do usuário) novamente. Agora você deve ver "Local Moonbeam" ou qualquer nome que você definir no react à sua direita.
Assim, agora, você já implantou com sucesso o contrato para o nó moonbeam em sua máquina. Se você precisar implantá-lo para o nó oficial moonbeam, basta mudar chainId e rpcUrl para apontar para o oficial em vez do local. Todos os outros passos devem ser os mesmos.
E mais uma vez nosso artigo é muito longo 🤣, então vamos dividi-lo na próxima parte.
No próximo episódio, tentaremos algumas funcionalidades interessantes no moonbeam, como XCM. Usaremos polkadot.js para transferir ativos através da parachain e também escreveremos algum contrato para transferir ativos.
Obrigado por seu interesse, e até a próxima.
Esse artigo foi escrito por Drnutsu e traduzido por Fátima Lima. O original pode ser lido aqui.
Oldest comments (0)