Seu Primeiro Módulo Move

O blockchain Aptos permite que desenvolvedores escrevam contratos inteligentes Turing completos (chamados “módulos”) com a linguagem Move segura por design. Contratos inteligentes permitem que usuários enviem dinheiro com o blockchain, mas também escrevam código arbitrário, até mesmo jogos! Tudo começa com o CLI Aptos criando uma conta que armazenará o módulo Move implantado (“publicado”).

Este tutorial irá ajudá-lo a entender Módulos Move guiando você através da configuração de um ambiente Aptos mínimo, depois como compilar, testar, publicar e interagir com módulos Move no Blockchain Aptos. Você aprenderá como:

1. Configurar seu ambiente, instalar o CLI
2. Criar uma conta devnet e financiá-la
3. Compilar e testar um módulo Move
4. Publicar (ou “implantar”) um módulo Move no blockchain Aptos
5. Interagir com o módulo
6. Continuar construindo com Aptos (próximos passos)

Mudanças no blockchain são chamadas “transações”, e elas requerem uma conta para pagar a taxa de rede (“taxa de gas”). Precisaremos criar uma conta com algum APT para pagar essa taxa e possuir o contrato publicado. Para fazer isso, precisaremos usar o CLI Aptos.

1. Instalar o CLI Aptos

   Instale o CLI Aptos (se ainda não tiver).

2. Abrir um novo terminal

   Abra uma nova janela ou aba de terminal.

3. Verificar a instalação

   Execute aptos --version para verificar se você tem instalado.

   aptos --version

   Você deve ver uma resposta como aptos 4.6.1.

4. Criar uma pasta de projeto

   Crie uma nova pasta para este tutorial executando:

   mkdir meu-primeiro-modulo

5. Navegar para a pasta do projeto

   Execute cd meu-primeiro-modulo para entrar na sua nova pasta.

6. Inicializar sua conta

   Execute aptos init e pressione ‘enter’ para cada etapa da configuração para criar uma conta de teste no devnet.

   Você deve ver uma mensagem de sucesso como esta:

   ---
   CLI Aptos está agora configurado para a conta 0x9ec1cfa30b885a5c9d595f32f3381ec16d208734913b587be9e210f60be9f9ba como perfil padrão!
   {
     "Result": "Success"
   }

1. Copiar seu endereço de conta

   Copie o endereço da linha de comando para sua nova conta.

   O endereço se parece com isso 0x9ec1cfa30b885a5c9d595f32f3381ec16d208734913b587be9e210f60be9f9ba e você pode encontrá-lo na linha:

   CLI Aptos está agora configurado para a conta 0x9ec1cfa30b885a5c9d595f32f3381ec16d208734913b587be9e210f60be9f9ba como perfil padrão!

2. Abrir o Explorador Aptos

   Vá para o Explorador Aptos.

   Esta é a maneira principal de verificar rapidamente o que está acontecendo no devnet, testnet ou mainnet. Usaremos mais tarde para visualizar nossos contratos implantados.

3. Garantir que você está na rede Devnet

   Procure por “Devnet” no canto superior direito, ou mude redes clicando no dropdown “Mainnet” e selecionando Devnet.

4. Procurar sua conta

   Cole seu endereço recém-criado na barra de busca.

5. Visualizar os resultados da busca

   Aguarde os resultados aparecerem, então clique no resultado do topo.

6. Verificar a transação

   Você deve ver sua conta recém-criada e uma transação com a função faucet, financiando-a com tokens devnet.

7. Verificar seu saldo

   Clique na aba “Coins” para ver que você tem 1 APT do Aptos Coin. Isso permitirá que você publique e interaja com contratos inteligentes no devnet aptos.

Agora que temos nosso ambiente configurado e uma conta criada, vamos escrever e compilar nosso primeiro módulo Move. Diferente do Ethereum onde contratos existem independentemente, Move conecta tudo a contas - tanto módulos quanto seus recursos. Vamos começar com um exemplo simples para entender os conceitos centrais.

Módulos Move são similares a contratos inteligentes em outros blockchains, com algumas diferenças principais:

• Recursos: Diferente do Solidity onde estado é armazenado em variáveis de contrato, Move usa “recursos” - tipos de dados especiais que só podem existir em um lugar por vez e estão sempre ligados a uma conta
• Baseado em módulos: Em vez de implantar contratos inteiros como unidades independentes como no Solidity, código Move é organizado em módulos reutilizáveis que podem compartilhar e manipular recursos através de fronteiras. Módulos são mais como pacotes de biblioteca padrão que podem ser publicados juntos ou separadamente, oferecendo controle mais refinado sobre organização de código.
• Segurança por design: O sistema de tipos do Move e semântica de recursos ajudam a prevenir vulnerabilidades comuns de contratos inteligentes

Nosso primeiro módulo será um sistema simples de armazenamento de mensagens que permite contas armazenar e recuperar mensagens. Vamos criar um novo projeto move dentro da nossa pasta meu-primeiro-modulo:

1. Inicializar o projeto

   Inicialize um novo projeto move com aptos move init --name meu_primeiro_modulo

   Isso cria uma estrutura de projeto com um diretório sources e um arquivo Move.toml.

2. Criar o arquivo do módulo

   Crie um novo arquivo sources/mensagem.move com nosso código do módulo:

   module meu_primeiro_modulo::mensagem {
       use std::string;
       use std::signer;
   
       struct GuardadorMensagem has key, store, drop {
           mensagem: string::String,
       }
   
       public entry fun definir_mensagem(conta: &signer, mensagem: string::String) acquires GuardadorMensagem {
           let endereco_conta = signer::address_of(conta);
   
           if (exists<GuardadorMensagem>(endereco_conta)) {
               move_from<GuardadorMensagem>(endereco_conta);
           };
   
           move_to(conta, GuardadorMensagem { mensagem });
       }
   
       public fun obter_mensagem(endereco_conta: address): string::String acquires GuardadorMensagem {
           assert!(exists<GuardadorMensagem>(endereco_conta), 0);
           let guardador_mensagem = borrow_global<GuardadorMensagem>(endereco_conta);
           guardador_mensagem.mensagem
       }
   }

3. Entender o código

   Este módulo simples faz o seguinte:

   • Definição de struct: GuardadorMensagem é um recurso com capacidades has key, store, drop
     • key: pode ser armazenado em armazenamento global
     • store: pode ser armazenado dentro de outras structs
     • drop: pode ser deletado
   • Função definir_mensagem: armazena uma mensagem em uma conta (substitui se existir)
   • Função obter_mensagem: lê uma mensagem de uma conta

4. Compilar o módulo

   No diretório do projeto, execute:

   aptos move compile

   Se bem-sucedido, você verá os resultados da compilação:

   Compilando, pode demorar um pouco para baixar dependências git...
   INCLUINDO DEPENDÊNCIA AptosFramework
   INCLUINDO DEPENDÊNCIA AptosStdlib
   INCLUINDO DEPENDÊNCIA MoveStdlib
   CONSTRUINDO meu_primeiro_modulo
   {
     "Result": [
       "9ec1cfa30b885a5c9d595f32f3381ec16d208734913b587be9e210f60be9f9ba::mensagem"
     ]
   }

Move tem suporte integrado para escrever testes. Vamos testar nosso módulo antes de implantá-lo:

1. Criar arquivo de teste

   Crie sources/teste_mensagem.move:

   #[test_only]
   module meu_primeiro_modulo::testes_mensagem {
       use std::string;
       use meu_primeiro_modulo::mensagem;
   
       #[test(conta = @0x1)]
       public fun testar_definir_e_obter_mensagem(conta: &signer) {
           let texto_mensagem = string::utf8(b"Olá, Aptos!");
           mensagem::definir_mensagem(conta, texto_mensagem);
   
           let mensagem_armazenada = mensagem::obter_mensagem(@0x1);
           assert!(mensagem_armazenada == string::utf8(b"Olá, Aptos!"), 0);
       }
   }

2. Executar testes

   aptos move test

   Se os testes passarem, você verá saída como esta:

   Executando testes unitários Move
   [ PASSOU ] 0x9ec1cfa30b885a5c9d595f32f3381ec16d208734913b587be9e210f60be9f9ba::testes_mensagem::testar_definir_e_obter_mensagem
   Resultado do teste: OK. Total de testes: 1; passou: 1; falhou: 0

Com os testes passando, vamos publicar nosso módulo no devnet:

1. Publicar o módulo

   aptos move publish

2. Confirmar a publicação

   Digite “yes” no prompt para confirmar a publicação.

   Se bem-sucedido, você verá um hash de transação:

   tamanho do pacote 1755 bytes
   Você quer enviar uma transação para um intervalo de [600 - 900] Octas a um preço unitário de gas de 100 Octas? [yes/no] >
   yes
   {
     "Result": {
       "transaction_hash": "0x64b9e3bd21c5b3ca1cab0e1b10dc06c0add1d2f7bfcf0b4ce1de3c1b7c3e8dc8",
       "gas_used": 721,
       "gas_unit_price": 100,
       "sender": "9ec1cfa30b885a5c9d595f32f3381ec16d208734913b587be9e210f60be9f9ba",
       "success": true,
       "version": 502312001,
       "vm_status": "Executado com sucesso"
     }
   }

Com o módulo publicado, vamos interagir com ele:

1. Definir uma mensagem

   aptos move run --function-id default::mensagem::definir_mensagem --args string:"Olá do meu primeiro módulo!"

2. Obter a mensagem

   aptos move view --function-id default::mensagem::obter_mensagem --args address:seu_endereco_de_conta

   Substitua seu_endereco_de_conta pelo seu endereço real.

3. Verificar no Explorador

   Você pode pesquisar seu endereço de conta no Explorador Aptos e ver o recurso GuardadorMensagem na aba “Resources”.

Parabéns! Você criou, testou, publicou e interagiu com sucesso com seu primeiro módulo Move. A seguir, experimente:

• Livro Move - Aprenda mais sobre a linguagem de programação Move
• Construindo um dApp Completo - Integre módulos com um frontend
• Padrões Aptos - Explore padrões Move mais avançados e melhores práticas

Aproveite sua jornada de desenvolvimento Move!