Primeiros passos no desenvolvimento da Blockchain EOS [ATUALIZAÇÃO 2021]

Você está procurando começar a se desenvolver na blockchain EOS e se tornar um desenvolvedor EOS? Parabéns, você aterrissou no lugar certo. Criamos este guia para iniciantes e ele o ajudará a dar seus primeiros passos no desenvolvimento da blockchain EOS antes de passar para uma programação mais avançada mais tarde na série.

Recentemente reformulamos completamente este guia para atender aos mais altos padrões, melhores práticas e para usar a última versão do protocolo EOSIO. Para o guia atualizado, verifique "Primeiros passos no desenvolvimento da blockchain EOS" Edição 2021.

O ano passado foi realmente épico para as startups da blockchain. Graças ao Ethereum Blockchain e as oportunidades que ele deu aos desenvolvedores para criar aplicações descentralizadas, muitas empresas de blockchain nasceram.

O Ethereum iniciou o desenvolvimento da blockchain quando introduziu a linguagem Solidity e os Contratos Inteligentes - os blocos de construção para aplicações descentralizadas. Entretanto, o Ethereum foi apenas o começo. A tecnologia da blockchain está se desenvolvendo em um ritmo acelerado e agora uma nova e mais poderosa está a caminho. Está na hora de introduzir a blockchain EOS.

O objetivo do EOS é tornar-se o primeiro sistema operacional descentralizado que pode suportar aplicações descentralizadas em escala industrial. Ele introduz uma nova arquitetura de Blockchain projetada para permitir o dimensionamento vertical e horizontal dos dApps. É alcançado através da criação de uma construção semelhante a um sistema operacional sobre o qual as aplicações podem ser construídas.

O software EOSIO fornece contas, autenticação, bancos de dados, comunicação assíncrona e o agendamento de aplicações em muitos núcleos ou clusters de CPU. A tecnologia resultante é uma arquitetura de blockchain que pode, em última instância, ser dimensionada para milhões de transações por segundo, elimina as taxas de usuários e permite a implantação e manutenção rápida e fácil de aplicações descentralizadas, no contexto de uma blockchain governada.

Certamente, o EOS estabelece um nível muito alto em comparação com seus irmãos!

Desenvolvimento da blockchain EOS

A fim de ajudar a comunidade de desenvolvimento da blockchain EOS, nossa equipe de desenvolvimento na Infinite X Labs decidiu executar uma série de tutoriais dedicados ao desenvolvimento EOS. Neste tutorial, vamos explorar as etapas que o ajudarão a configurar seu ambiente e executar seu primeiro nó de testnet. Criaremos uma conta e implantaremos um modelo de contrato inteligente para a Blockchain EOS para que possamos interagir com ela.

*Observe que o EOSIO ainda está em desenvolvimento e algumas das etapas podem mudar no futuro. Entretanto, nossa equipe tentará manter o tutorial sempre atualizado.

Última atualização - 29 de julho de 2018 - O tutorial foi atualizado com a última versão do EOSIO - v1.1.1

Então, vamos começar!*

1. Criando um ambiente de construção/desenvolvimento

Para construir os dApps EOS, precisamos primeiro configurar nosso ambiente. Quando você estiver construindo seus dApps na maior parte do tempo, você usará o testnet. O EOS nos dá a escolha entre construir para um testnet local ou para o testnet público. Аté o momento de escrever este tutorial o testnet público está atualmente indisponível, portanto, usaremos o testnet local.

Para o propósito do tutorial, vamos utilizar o macOS High Sierra versão 10.13.6

A configuração do ambiente é realmente fácil graças ao script de construção automatizada do EOSIO. Ele instala todas as dependências e constrói o EOSIO. Antes de executar o script, como primeiro passo, clone o EOS repo recorrente com o seguinte comando:

git clone https://github.com/eosio/eos --recursive

Uma vez feito isso, vá para a pasta eos e execute o script eosio_build.sh com o seguinte comando:

sh ./eosio_build.sh darwin

Pode levar algum tempo até que todas as dependências sejam instaladas e depois construídas.

Se você finalmente ver esta tela, então parabéns! Você instalou com sucesso todas as dependências e construiu o EOSIO. É bom verificar sua instalação, mas faremos isso dentro de algum tempo. Antes disso, vamos verificar o que a instalação gerou.

Quando o EOSIO foi construído, ele criou muitos arquivos e pastas. Vamos dar uma olhada em alguns deles.

A pasta de programas - /eos/programs

A pasta do programa contém alguns programas muito úteis do EOSIO

• nodeos - componente do nó da blockchain do lado do servidor. O daemon central EOSIO que pode ser configurado com plugins para executar um nó. Exemplos de usos são a produção de blocos, pontos finais API dedicados e desenvolvimento local.
• cleos - interface de linha de comando para interagir com a blockchain
• keosd - um daemon de carteira EOSIO que carrega plugins relacionados à carteira, tais como a interface HTTP e RPC API
• eosio-launcher - aplicação para auxiliar na implantação de uma blockchain de múltiplos nós

A pasta de construção - /eos/build

A pasta de construção é para onde vai todo o conteúdo construído. Você pode encontrar os executáveis da pasta eos/programs em subpastas dentro da pasta eos/build/programs.

A pasta build é para onde vamos fazer nossa validação de construção. É um conjunto de testes que podem ser executados contra sua construção para realizar alguma validação básica. Para executar o conjunto de testes após a construção, precisamos iniciar o mongo daemon e depois executar o comando de teste.

/usr/local/bin/mongod -f /usr/local/etc/mongod.conf &

cd build
make test

Nota: Para executar o comando você deve estar dentro da pasta de construção

Se tudo tiver corrido bem, todos os testes devem ser aprovados. Se você ver mais de 24 testes, não se surpreenda. O EOSIO acrescenta constantemente novos testes a cada lançamento :)

Agora é a hora de instalar os executáveis. Para facilitar o desenvolvimento do contrato, o conteúdo pode ser instalado na pasta /urs/local usando o comando make install. Esta etapa é executada a partir da pasta build. É necessária a permissão adequada para a instalação.

cd construir 
sudo make install

2. Criação e lançamento de um de nó de testnet único

Finalmente chega a hora de lançar nosso primeiro nó de testnet.

Com a última versão do EOSIO, você pode iniciar sua própria blockchain de nó único com o seguinte comando:

# Para imprimir a saída do contrato para console por padrão, adicionar:
# --contratos-console

nodeos -e -p eosio --plugin eosio::wallet_api_plugin --plugin eosio::chain_api_plugin --plugin eosio::history_api_plugin --contracts-console

Ele começará a gerar blocos. Fantástico!

Se você estiver recebendo um "nodeos" de erro: comando não encontrado, você deve adicionar o novo caminho de binários à variável de ambiente PATH. Verifique mais informações sobre o assunto no GitHub

Se a janela do terminal estiver fechada e você quiser iniciar seu nó novamente, basta executar o comando acima. Ele começará a produzir blocos a partir de seu último.

Também quando você executou o comando pela primeira vez, algumas pastas foram criadas no caminho ~/Library/Application Support/eosio/ - Lá você pode encontrar alguns dos arquivos de que falaremos nas próximas linhas.

Mas primeiro, você provavelmente se perguntar quais são todos esses parâmetros no comando, então vamos dar uma olhada

1. Comando principal

nodeos

1. Opções de configuração para eosio::producer_plugin

-e — Permitir a produção de blocos, mesmo se a cadeia estiver ultrapassada
-p <nome_do_produtor> — ID do produtor controlado por este nó

1. Opções de configuração da aplicação --plugin arg - Plugin(s) para habilitar, pode ser especificado várias vezes

Com EOSIO Dawn 4.2 há várias opções de linha de comando para eosio::chain_plugin que você pode usar:

# recupera o banco de dados de blocos reversíveis se esse banco de dados estiver em mau estado
--fix-reversible-blocks

# não pula nenhuma verificação que possa ser pulada durante a reprodução de blocos irreversíveis
--force-all-checks

# limpa o banco de dados do estado da cadeia e reproduz todos os blocos
--replay-blockchain

# limpa o banco de dados do estado da cadeia, recuperar o maior número possível de blocos do registro de blocos e, em seguida, reproduz novamente esses blocos
--hard-replay-blockchain

# limpa o banco de dados do estado da cadeia e o diário de blocos
--delete-all-blocks 

3. Validar o ambiente

Você está pronto para fazer algumas coisas interessantes ?

O EOSIO vem com contratos de exemplo que podem ser carregados e executados para fins de teste. Nós validaremos nossa configuração de nó único usando o contrato eosio.token. Presume-se que o nó está funcionando como descrito acima.

3.1 Criar uma carteira

Cada contrato requer uma conta associada, portanto, primeiro é preciso criar uma carteira. Para criar uma carteira, você precisa ter a carteira_api_plugin carregada no processo de nodeos. Isto pode ser feito de duas maneiras:

Através de uma entrada plugin no arquivo config.ini (ou seja, plugin = eosio::wallet_api_plugin) na pasta ~/Library/Application Support/eosio/nodeos/config
Através de uma opção de linha de comando plugin ao invocar os nodeos (ou seja - plugin eosio::wallet_api_plugin)

Use a carteira para criar um sub-comando de cleos para criar uma carteira.

cd ~/eos/build/programs/cleos/ 

# emite uma senha que você precisa salvar para poder bloquear/desbloquear a carteira
# Se você não quiser usar a carteira "padrão" acrescente: -n {seu_nome_da_carteira} no final de seu comando
criar carteira de cleos

3.2 Importar a chave privada para a conta eosio

Nota: Você só deve usá-lo para fins de teste

A chave pode ser encontrada no arquivo config.ini que está localizado em ~/Library/Application Support/eosio/nodeos/config.

# faucet-private-key = [chave pública, chave privada WIF] para assinatura da conta do criador da torneira (eosio::faucet_testnet_plugin) 

[EOS6MRyAjQq8ud7hVNYcfnVPJqcVpscN5So8BhtHuGYqET5GDW5CV,5KQwrPbwdL6PhXujxW37FSSQZ1JiwsST4cqQzDeyXtP79zkvFD3]

Uma vez que você recebeu a chave, você precisa importá-la para a carteira:

cleos wallet import --private-key={eosio_account_private_key}

3.3 Criar uma conta para o contrato "eosio.token”

A conta chamada "token" será utilizada para o contrato "eosio.token". Gerar dois pares de chaves públicas/privadas que serão posteriormente designadas como Public-OwnerKey e Public-ActiveKey.

cleos create key # OwnerKey 
cleos create key # ActiveKey

Isto produzirá dois pares de chaves públicas e privadas do formulário:

Chave privada: XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
Chave pública: EOSXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX


Importar as duas chaves privadas para a carteira.

cleos wallet import --private-key={private-OwnerKey} 
cleos wallet import --private-key={private-ActiveKey}

Nota: Se você não especificar o nome da carteira, será usado o "padrão". Além disso, não esqueça de salvar suas chaves geradas.

Crie a conta token usando o comando cleos create account. A criação será autorizada pela conta eosio. As duas chaves públicas geradas acima serão associadas à conta, uma como sua OwnerKey e a outra como sua ActiveKey. Você deverá obter uma resposta JSON com um ID de transação confirmando que foi executada com sucesso.

cleos create account eosio token {public-OwnerKey} {public-ActiveKey}

executed transaction: e0d7f17de1e7f1a7b73dfda511ce7714d25fceec6b43d86ddf997fb38852e0c2  200 bytes  2774 us
#         eosio <= eosio::newaccount            {"creator":"eosio","name":"token","owner":{"threshold":1,"keys":[{"key":"EOS6EhzztSvBp1K76GqF6A893bL…

Se você ver “warning: transaction executed locally, but may not be confirmed by the network yet”, não se preocupe.O aviso de transação executada localmente é normal e se aplica a todas as transações. O envio com sucesso de uma transação não é garantia de que a transação será executada. Se os produtores do bloco estiverem muito carregados no momento, a transação poderá ser abandonada.

Verifique se a conta foi criada com sucesso com o seguinte comando:

cleos get account token --json

e se tudo tiver ocorrido bem, você receberá uma resposta semelhante à seguinte:

{
  "account_name": "token",
  "head_block_num": 70942,
  "head_block_time": "2018-07-29T16:53:48.000",
  "privileged": false,
  "last_code_update": "1970-01-01T00:00:00.000",
  "created": "2018-07-29T16:49:47.500",
  "ram_quota": -1,
  "net_weight": -1,
  "cpu_weight": -1,
  "net_limit": {
    "used": -1,
    "available": -1,
    "max": -1
  },
  "cpu_limit": {
    "used": -1,
    "available": -1,
    "max": -1
  },
  "ram_usage": 2724,
  "permissions": [{
      "perm_name": "active",
      "parent": "owner",
      "required_auth": {
        "threshold": 1,
        "keys": [{
            "key": "EOS5h87m6u3DppJ4eMsSP6X9As9DAtXDzxsWzRN8RsUBCjk4axnjw",
            "weight": 1
          }
        ],
        "accounts": [],
        "waits": []
      }
    },{
      "perm_name": "owner",
      "parent": "",
      "required_auth": {
        "threshold": 1,
        "keys": [{
            "key": "EOS6s2JuFtzQAnPSNu9R9w3k53d7kEDVEjTmceTsZwy4Wn235Yf5W",
            "weight": 1
          }
        ],
        "accounts": [],
        "waits": []
      }
    }
  ],
  "total_resources": null,
  "self_delegated_bandwidth": null,
  "refund_request": null,
  "voter_info": null
}

3.5 Carregar o contrato "eosio.token" para a *blockchain*

Faça o upload do contrato usando a conta simbólica. A resposta deve ser uma transação_id com algum JSON. Isto indica que seu contrato foi carregado com sucesso:

# token de contrato cleos definido {caminho_para_pasta_de_contrato} {caminho_para_arquivo_west} {caminho_para_arquivo_abi_}
cleos set contract token ./contracts/eosio.token/ ./contracts/eosio.token/eosio.token.wast ./contracts/eosio.token/eosio.token.abi

Reading WAST/WASM from ./contracts/eosio.token/eosio.token.wast...
Assembling WASM...
Publishing contract...
executed transaction: 82f252b7b1e71197626cf912a975562c08cd452e47b6582399b47baca22d83b5  8096 bytes  8986 us
#         eosio <= eosio::setcode               {"account":"token","vmtype":0,"vmversion":0,"code":"0061736d01000000017e1560037f7e7f0060057f7e7e7f7f...
#         eosio <= eosio::setabi                {"account":"token","abi":"0e656f73696f3a3a6162692f312e30010c6163636f756e745f6e616d65046e616d65050874…

Você também pode verificar se o código foi definido com o seguinte comando:

cleos get code token
code hash: 48a05166e9a5493b422288d137a08a7b2ccf7fb2c3473b630909440d7bbf177a

Antes de utilizar o contrato eosio.token, você deve primeiro criar e depois emitir os tokens.

# Criar
cleos push action token create '{"issuer":"token","maximum_supply":"1000000.0000 TKN","can_freeze":"0","can_recall":"0","can_whitelist":"0"}' -p token

executed transaction: 9c2ef8724134d693f60c7c68e38a25d37450944b78a7df09f9cc3cb360a9f078  120 bytes  1861 us
#         token <= token::create                {"issuer":"token","maximum_supply":"1000000.0000 TKN"}

# Issue
cleos push action token issue '{"to":"token","quantity":"1000.0000 TKN","memo":""}' -p token

executed transaction: c37952237ed5521575edb19d201841f2ac256ebe84c0957f0266963b96cc64cc  120 bytes  490 us
#         token <= token::issue                 {"to":"token","quantity":"1000.0000 TKN","memo":""}

Em seguida, verificar o saldo inicial:

cleos get table token token accounts

{
  "rows": [{
      "balance": "1000.0000 TKN"
    }
  ],
  "more": false
}

3.6 Transferir fundos usando o contrato "eosio.token”

O seguinte comando mostra uma ação de "transferência" sendo enviada para o contrato eosio.token, transferindo "20.0000 TKN" da conta "token" para a conta "eosio". Uma transação submetida com sucesso gerará um ID de transação e uma saída JSON semelhante à seguinte.

cleos push action token transfer '{"from":"token","to":"eosio","quantity":"20.0000 TKN","memo":"my first transfer"}' -p token

executed transaction: be3929724d07d796df9913d944e1ebd20ca527ec273415ecbc94cb6fc08230e1  144 bytes  6097 us
#         token <= token::transfer              {"from":"token","to":"eosio","quantity":"20.0000 TKN","memo":"my first transfer"}
#         eosio <= token::transfer              {"from":"token","to":"eosio","quantity":"20.0000 TKN","memo":"my first transfer"}

3.7 Verificar os saldos

Verifique o estado de ambas as contas envolvidas na transação anterior da seguinte forma:

cleos get table token eosio accounts
{
  "rows": [{
      "balance": "20.0000 TKN"
    }
  ],
  "more": false
}

cleos get table token token accounts
{
  "rows": [{
      "balance": "980.0000 TKN"
    }
  ],
  "more": false
}

a conta receptora eosio agora tem um saldo de 20 TKN, e o token da conta emissora agora tem 20 TKN a menos do que sua emissão inicial.

Vamos resumir todas as etapas até agora. Primeiro instalamos o EOSIO e montamos nosso ambiente de desenvolvimento. Instalamos os executáveis necessários para o desenvolvimento do contrato e iniciamos nosso primeiro nó de teste que gera blocos na blockchain. Aprendemos a gerar chaves públicas/privadas e a importá-las para nossas carteiras. Criamos uma conta usando nossas chaves públicas - OwnerKey & ActiveKey e implantamos o contrato eosio.token. Por fim, transferimos fundos usando o contrato eosio.token entre as contas.

Artigo escrito por Infinite X e traduzido para o português por Rafael Ojeda

Você pode encontrar o artigo original aqui.