Construa seu primeiro Ethereum Smart Contract com solidez – Tutorial

Então você quer construir um contrato inteligente? Talvez você queira entender como eles funcionam, talvez você queira construir seu próprio Dapp, talvez você queira lançar o primeiro bilhão de dólares em ICO (sarcasmo) … Independentemente de suas intenções, aprender como os contratos inteligentes funcionam é inestimável. A plataforma Ethereum possui um enorme potencial para criar Dapps que poderia mudar a maneira como interagimos na web nas próximas décadas. Enquanto a Ethereum implementa contratos inteligentes que funcionam muito como uma transação blockchain padrão, eles produzem uma declaração condicional que deve ser atendida antes que uma função seja executada. Contratos inteligentes podem ser usados ??para votação, crowdfunding, leilões cegos, carteiras com várias assinaturas e MUITO mais.

Um exemplo de contrato inteligente rápido:

Bob tem seu próprio negócio de depósito de sucata nos Estados Unidos, Eric é seu fornecedor de sucata de ferro. Eric é baseado fora da China. Bob e Eric têm um ótimo relacionamento comercial. Eles confiam uns nos outros e fazem negócios há muito tempo. Ambos têm negócios em expansão e Bob, em particular, vende sucata de ferro rotineiramente. Bob implanta um contrato onde, uma vez que seu estoque de sucata de ferro atinja uma certa faixa, ele envia automaticamente um pedido para Eric por £ de sucata de ferro em Yéter por tonelada. Eric concorda com o acordo e aceita o pagamento de Bob em éter imediatamente. Eric começa a trabalhar imediatamente e começa a cumprir o pedido de Bob. Eric pode trocar seu éter em uma troca local on-line pelo Yuan por uma pequena taxa e será processado instantaneamente. Se Eric decide manter o éter ou converter-se a Yuan é sua escolha, mas de qualquer forma ele pode agora colocar esse capital para funcionar imediatamente!

Ambas as partes estão em êxtase! Normalmente, Bob precisa entrar em contato com seu banco e solicitar uma transferência de dinheiro para o banco de Eric na China. Normalmente leva ~ 48 horas para processar a transferência eletrônica, quando Eric terá que esperar alguns dias para que o banco liquide o pagamento. Não só isso, o banco de Bob vai cobrar uma taxa de transferência de dinheiro para Eric … Tempo e dinheiro pela janela. Para piorar as coisas, ambas as partes têm que lidar com a dor de cabeça do câmbio, transformando os dólares americanos em Yuan Chinês.

Então, o que eu vou aprender?

Como diz o ditado, "você tem que engatinhar antes de poder andar". Antes de começarmos a implantar nosso primeiro contrato, é importante aprendermos algumas noções básicas. Mais importante, gostaria de salientar que a plataforma da Ethereum foi lançada em 2016. Embora ainda esteja na infância, agora é a hora perfeita para começar a aprender sobre contratos inteligentes.

Neste tutorial vamos aprender sobre:

  • Ethereum Nodes
  • Construindo uma rede de blockchain privada
  • MetaMask Browser Plug In
  • Navegador Névoa
  • Carteira Ethereum
  • Web3 Ethereum JavaScript API
  • Remix Web Browser IDE
  • Interface de linha de comando do Geth (Go Ethereum)
  • Linguagem de programação de solidez

Importante: Se em algum momento você encontrar um problema ao executar um programa, tente iniciá-lo como administrador clicando com o botão direito do mouse e selecionando “Executar como administrador”.

Configurando um nó Ethereum

Na forma mais simples, um nó Ethereum é qualquer dispositivo que esteja executando o protocolo Ethereum (blockchain). Embora os nós estejam normalmente sendo executados em desktops e laptops, o desenvolvimento para dispositivos móveis está em andamento. Quando nos conectamos ao protocolo Ethereum, estamos na rede blockchain Ethereum e estamos executando um nó. Ao executar um nó Ethereum, podemos nos conectar a outros nós na rede, ter acesso direto ao blockchain e até fazer coisas como bloquear minas, enviar transações e implantar contratos inteligentes.

Os nós são escritos em Go (Go Ethereum / Geth), C ++ e Python. Neste tutorial vamos nos ater aos mais populares dos três, Go. Importante também notar que, baixando o Geth, estamos baixando o blockchain INTEIRO Ethereum. Dito isso, verifique se você tem ~ 35GB de armazenamento no disco rígido antes de continuar.

  1. Visite o site Go Ethereum e instale o Geth

Visite aqui: https://geth.ethereum.org/downloads/

2. Faça o download da versão mais recente do Geth (atualmente 1.8.7) para Windows, certifique-se de baixar a versão de 64 bits.

Lançamentos para download do Geth Ethereum

3. Quando o download estiver concluído, abra o instalador e clique em "Concordo"

4. Verifique se a caixa Geth está marcada e clique em "Next"

5. Você será solicitado a selecionar uma pasta de destino para o seu download. Por padrão, o Geth será instalado em C: Arquivos de Programas Geth

6. Feche a instalação depois de concluído

7. Abra o prompt de comando (usarei o Git Bash – faça o download aqui: https://git-scm.com/ , certifique-se de adicionar variáveis ??PATH durante a instalação) e navegue até o diretório Geth digitando “cd C: Arquivos de Programas Geth ”

Arquivo de caminho Geth

8. Comece a sincronizar com o blockchain Ethereum digitando “Geth”. Como esta é sua primeira sincronização, você baixará o blockchain INTEIRO de outros colegas. Isso levará algum tempo para ficar confortável …

O que você verá ao lançar o Geth pela primeira vez (após o download)

Feito? À direita! Agora você está executando um Ethereum Node. E que comece a diversão…

Estabelecendo nossa própria rede privada Ethereum

Agora que temos acesso ao protocolo Ethereum através do nosso nó, vamos configurar nosso próprio servidor privado para desenvolver e implantar nosso contrato inteligente. Note que nada disso será realmente implementado no blockchain Ethereum, em vez disso, vamos implantar em nosso próprio blockchain. Começaremos inicializando o primeiro bloco em nosso blockchain, o bloco da gênese (genesis.json).

  1. Crie uma nova pasta na sua área de trabalho chamada "Cadeia Privada".
  2. Abra o prompt de comando nesta pasta e crie uma pasta de diretório de dados para o nosso chaindata digitando “Mkdir chaindata”. Você pode abrir um prompt de comando nesta pasta segurando Shift e clicando com o botão direito do mouse e, em seguida, selecione "abrir janela de comando aqui".
  3. Em seguida, precisamos criar e salvar nosso bloco genesis.json em nossa pasta Private Chain, pois o bloco genesis será usado para inicializar nossa rede privada e armazenar dados na pasta do diretório de dados “chaindata”.
  4. Abra o bloco de notas, copie e cole o código abaixo em um novo arquivo chamado “genesis.json” e salve este arquivo em nossa pasta Cadeia Privada.

Saiba mais sobre os parâmetros genesis.json visite o link abaixo: https://ethereum.stackexchange.com/questions/2376/what-does-each-genesis-json-parameter-mean

 { 
"coinbase": "0x0000000000000000000000000000000000000001",
"dificuldade": "0x20000",
"extraData": "",
"gasLimit": "0x2fefd8",
"nonce": "0x0000000000000042",
"mixhash": "0x0000000000000000000000000000000000000000000000000000000000000000",
"parentHash": "0x0000000000000000000000000000000000000000000000000000000000000000",
"timestamp": "0x00",
"alloc": {},
"config": {
"chainId": 15,
"homesteadBlock": 0,
"eip155Block": 0,
"eip158Block": 0
}
}

5. Agora queremos inicializar nossa rede privada no diretório chaindata usando nosso arquivo genesis.json. Nós vamos dizer ao Geth que queremos o diretório de dados no diretório "chaindata" e onde o arquivo genesis.json pode ser encontrado (tenha certeza que o genesis.json NÃO está na pasta chaindata). Digite o seguinte comando na linha cmd apontando para a pasta Cadeia privada.

 geth --datadir =. / chaindata / init ./genesis.json 

6. Você deve então ver que o estado da gênese foi escrito com sucesso.

7. Agora podemos iniciar o Geth e nos conectar à nossa própria rede privada. Como você verá, a conexão do soquete do terminal geth.ipc será aberta e, portanto, a porta 30303 será aberta.

 geth --datadir =. / chaindata / 

Sempre que iniciarmos o Geth, o endpoint IPC será aberto, que é usado para processar conexões com o Geth com programas como MetaMask, Ethereum Wallet, Mist, ou para abrir o console Geth Javascript API. Vamos discutir todos estes próximos.

Tudo bem, tudo bem, tudo bem! Nós agora estabelecemos nossa própria rede privada geth!

O que é MetaMask exatamente?

MetaMask é tanto um navegador Ethereum e uma carteira. Através da MetaMask você pode interagir com Dapps e contratos inteligentes na web sem ter que baixar o blockchain ou instalar qualquer software. Você simplesmente adiciona MetaMask ao cromo como extensões, cria uma carteira e deposita éter. Enquanto atualmente disponível apenas para o Chrome, espere ver um lançamento para o Firefox no futuro próximo.

A maior queda do Metamask é que, como qualquer carteira online, você deve confiar na MetaMask. A possibilidade de MetaMask ser hackeada ou vazar sua chave privada existe, pois suas informações são armazenadas on-line.

Você pode fazer o download da MetaMask aqui: https://chrome.google.com/webstore/detail/metamask/nkbihfbeogaeaoehlefnkodbefgpgknn?hl=pt-BR

O Navegador Névoa

Mist é uma aplicação de elétrons, o que significa que é um aplicativo híbrido de desktop com uma interface web também. Isso permite um desenvolvimento e mudanças mais rápidos da interface Mist e ajuda com a parte do navegador do Mist. É importante que você reconheça que o Mist está em beta, então espere encontrar alguns problemas aqui e ali.

Névoa é poderosa na medida em que inclui um nó Geth que é executado em segundo plano após o lançamento; uma conexão com o blockchain Ethereum é feita imediatamente. Mas como queremos praticar o desenvolvimento de um contrato inteligente, vamos executar um nó em nossa rede privada e não precisaremos do Mist para conectar ao nó padrão do Geth.

Leia mais sobre Mist: https://github.com/ethereum/mist/wiki

E quanto à carteira Ethereum?

A Ethereum Wallet é apenas uma implementação da Mist que só pode acessar um único Dapp – o wall dapp, isso é devido a falta de recursos no Mist. O Ethereum Wallet é escrito em código HTML e Javascript puro, usa o web3.js para gerenciar suas contas e é executado dentro do navegador Mist. Você também pode baixar uma versão autônoma, se preferir. A carteira ainda não está oficialmente lançada, os erros existirão.

Ethereum Wallet: https://github.com/ethereum/meteor-dapp-wallet

Vamos baixar o Navegador Névoa & Conectar-se à nossa rede privada

Vamos levar um segundo para baixar o navegador Mist para que possamos nos conectar com nossa rede privada.

  1. Navegue até a página de download Mist e baixe a última versão do instalador Mist – https://github.com/ethereum/mist/releases

2. Abra o instalador e clique em "Concordo"

3 Confirme o caminho de download C: Program Files Mist (default) clicando em “Next”

4. Confirme se os dados do blockchain estão armazenados no caminho padrão em. Roaming Ethereum e clique em “Install”

Sinta-se à vontade para abrir o Mist e mexer na interface do usuário para ter uma idéia melhor das coisas, mas estaremos abrindo o Mist em breve.

Conectando névoa à nossa rede privada

Agora que eliminamos a inicialização da nossa rede privada com o bloco do genesis, podemos abrir uma linha de comando em nossa pasta Private Chain e dizer ao Geth para se conectar ao nosso datadir. Digite o seguinte comando no prompt de comando:

 geth --datadir =. / chaindata / 

Geth irá agora começar a correr e assim que abrirmos o ponto de extremidade geth.ipc, o Mist irá abrir; A névoa então fará a conexão com nossa rede privada. Certifique-se de que Mist esteja conectado, confirmando que “Private-Net” existe no canto superior direito da janela de inicialização Mist.

Ignore "Procurando por colegas", lembre-se de que estamos em nossa própria rede para que você nunca se conecte a outros colegas.

Os princípios da névoa

Vamos abrir o Mist e nos familiarizar com algumas coisas:

  1. No topo, podemos ver nossa barra de ferramentas. Navegar para o “Ethereum Node” sob a guia “Develop” mostrará que NÃO estamos conectados ao Geth, pois está desativado – estamos executando nossa própria rede. Muito parecido com o Chrome, na guia "Desenvolver", também podemos acessar "Ferramentas do desenvolvedor"

2. No lado esquerdo do navegador Mist, podemos ver as várias abas diferentes que estão abertas, assim como qualquer outro navegador. Ao clicar na caixa verde, estamos abrindo a Carteira Ethereum. A carteira é uma aplicação distribuída que torna incrivelmente fácil interagir com a interface JavaScript do Go Ethereum

3. Como você pode ver, estamos conectados à carteira Ethereum através de https://wallet.ethereum.org/ , não se esqueça que Mist é simplesmente um navegador. A partir daqui podemos fazer coisas como ver transações passadas, enviar éter e até implantar ou observar contratos.

4. Na guia "Carteiras", podemos ver nossas contas, adicionar novas contas, criar contratos de carteira (como contas de proprietário único, contratos de carteira com várias assinaturas e até mesmo carteiras de importação) e também examinar transações passadas

5. Vamos criar uma conta clicando em “Adicionar conta” (sinônimo de “carteira”), depois “Criar nova conta” e digite uma senha super segura (mesmo que esta seja uma conta em nossa rede privada e não será conectada a a rede Ethereum, é um bom hábito). Clique em "OK" e crie sua carteira

Sob a aba "Enviar", podemos enviar éter de uma carteira para outra, ou até mesmo de uma carteira para um contrato. Como você pode ver abaixo, antes de acertar o envio, temos a opção de definir o gás (taxa) para a nossa transação. Todas as transações exigem alguma quantidade de gás para incentivar o processamento. Dependendo da rapidez com que queremos que a transação seja processada e aprovada pelo blockchain, podemos ajustar a quantidade de gás.

Por fim, na guia "Contratos", podemos implantar novos contratos, observar contratos existentes e observar tokens criados anteriormente. Aqui é onde vamos criar e implantar nosso contrato "Hello World!"

Também podemos ver a opção de assistir contratos e tokens. Se tivermos interesse em interagir com um contrato implantado anterior, podemos clicar em "Assista a contratos" e inserir o nome do contrato, o endereço do contrato e o contrato ABI (interface binária do aplicativo). Se tivermos interesse em assistir ou gastar tokens ERC-20 (fichas desenvolvidas no blockchain do Ethereum), também podemos inserir o endereço do contrato do token, o nome do token e o símbolo do token.

Agora, para uma das partes mais empolgantes… Se passarmos para a guia do explorador (caixa azul com lupa), veremos que um navegador com uma barra de endereços é aberto na parte superior e uma página da Web é carregada. Se clicarmos em "conectar" no canto superior direito da tela, podemos conectar o navegador à nossa carteira. Nós então nos conectaremos à “Web 3.0” e daqui poderemos visitar os aplicativos distribuídos com tecnologia Ethereum (Dapps) e usar nossa carteira para interagir com eles. Experimente você mesmo e acesse https://www.stateofthedapps.com/ para ver alguns exemplos. Muito legal, né? Como eu mencionei antes, tudo isso é relativamente novo, então tente usar sua imaginação para onde tudo isso possa acontecer … apenas não se perca no espaço … você precisa voltar e terminar o resto deste tutorial …

Como estamos em nossa rede privada, poderemos conectar nossa carteira ao navegador, mas não temos nenhum éter real . Assim, estaremos limitados ao que podemos fazer ao interagir com esses Dapps. Para obter a experiência completa, você precisará se conectar à rede Ethereum e depositar ether em sua carteira, mas isso não significa que não podemos navegar.

Web3.js ?! O que???

Você pode estar se perguntando “como a Mist consegue conectar uma carteira a um navegador e interagir com o blockchain Ethereum?” Mist é apenas um navegador, um navegador injetado com a biblioteca Web3.js e pode se comunicar com um nó Ethereum ou transacionar com um contrato inteligente implantado no blockchain. A biblioteca Web3.js se comunica com um nó Ethereum por meio de chamadas JSON RPC, conectando-se a uma conexão HTTP ou IPC.

Se você quiser saber mais sobre o Web3.js, visite a documentação do GitHub aqui: https://github.com/ethereum/wiki/wiki/JavaScript-API

Vamos respirar por um segundo …

Ok, então eu joguei muito em você até agora. Embora muitas coisas possam não ter ficado na primeira tentativa, recomendo que você continue. Em seguida, estaremos interagindo com o IDE da web do Remix, criaremos nosso primeiro contrato inteligente em solidez, implantaremos por meio do Mist e até mesmo interagiremos com ele.

Se algo não foi explicado claramente ou talvez eu tenha perdido alguma coisa, fique à vontade para deixar um comentário abaixo! Estou sempre feliz em esclarecer qualquer confusão e responder a perguntas que você possa ter. Como sempre, o Google é sempre uma fonte segura para mais informações.

Remix Web Browser IDE

Vamos pular direto nas coisas e começar a escrever nosso código! Embora possamos escrever diretamente no Mist, primeiro vamos escrever nosso código de Solidity no IDE do navegador da web Remix. Por quê? Bem, o Remix tem um punhado de recursos que possibilitam uma experiência de desenvolvimento mais abrangente (por enquanto). Normalmente é melhor usado para contratos de menor porte. Recursos do Remix incluem:

  • Depurador integrado (passo a passo, instruções, variáveis ??de monitoramento, dados de chamadas, pilha de chamadas)
  • Avisos como código não seguro, custo de gás, se as funções podem ser constantes e verificam se há nomes de variáveis ??sobrepostos
  • Teste integrado e ambiente de implementação
  • Análise estática
  • Sintaxe e destaque de erro
  • Funciona com objetos Web3 injetados
  • Pode implantar diretamente no MetaMask ou no Mist

Vamos fazer o nosso caminho para Remix, visitando: https://remix.ethereum.org/

Bem no meio da página, podemos ver nosso espaço para o nosso código. No canto superior esquerdo da tela, podemos ver algumas opções de arquivos diferentes disponíveis: "Criar novo arquivo", "Adicionar arquivo local", "Publicar todos os arquivos abertos em um Github Gnub anônimo", "Copiar todos os arquivos para outra instância", e por último, "Conectar-se ao Localhost". Também podemos ver uma lista de contratos atuais em desenvolvimento.

No lado superior direito da tela, temos várias guias para seleção. Nossa aba “Compile” nos permite compilar nosso contrato depois de concluído (definido como Auto compile por padrão). Se clicarmos em "detalhes", obteremos uma lista com vários detalhes do contrato, desde metadados até código de bytes, até a ABI e até mesmo o código de implantação do Web3 de nosso contrato.

Todas as guias "Configurações", "Depurador", "Análise" e "Suporte" têm seu caso de uso e vale a pena se familiarizar com você. No interesse do tempo, vamos usar a guia "Executar" para o restante deste tutorial. Se clicarmos na guia "Executar", poderemos ver algumas configurações de contrato diferentes.

Ambiente: Existem 3 tipos de ambientes que o Remix pode ser conectado. Os ambientes Web3 Provider e Injected Web3 exigem ferramentas externas como MetaMask ou Mist. A VM do JavaScript é o que vamos seguir, pois isso permitirá que a execução ocorra em nosso navegador, além de nossa implementação no Mist.

Conta: Remix fornece 5 contas diferentes com 100 Ether pré-carregado! Estes podem ser usados ??durante o desenvolvimento do contrato, se desejado.

Limite de gás: defina um limite para a quantidade de gás (taxa) anexada ao contrato.

Preço do gás: defina uma quantidade necessária de gás para o contrato.

Valor: Implante o contrato com uma quantidade X de ether anexado.

Finalmente… Hands On Solidity!

Para aqueles que estão familiarizados com o Javascript, tenho certeza de que você notará as sobreposições com o Solidity. Muito parecido com o JS, o Solidity é uma linguagem de alto nível orientada a contratos projetada para atingir a Ethereum Virtual Machine (EVM). O código é estaticamente digitado, suporta herança, bibliotecas e tipos complexos definidos pelo usuário, entre outros recursos.

Em nosso contrato “Hello World!”, Vamos criar uma variável de estado chamada counter e atribuir um valor inicial de 5. Então vamos criar uma função que aumenta nossa variável de estado em 1, uma função que diminui a variável por 1, uma função que retorna nosso counter e, por último, uma função que destruirá o contrato.

O primeiro bit do código que vamos digitar no Remix é a versão do código fonte. No momento da escrita deste Solidity 0.4.16 é a última versão que é reconhecida pela Mist. Vamos chamar esta versão digitando no topo do nosso contrato:

 solidez do pragma ^ 0.4.16; 

A palavra-chave pragma é assim chamada porque geralmente os pragmas são instruções para o compilador sobre como tratar o código-fonte.

Mais informações sobre Solidity podem ser encontradas aqui nos documentos: https://solidity.readthedocs.io/en/develop/index.html

Funções e estados

Olhando para o esqueleto de um contrato inteligente, podemos ver que os contratos são meramente coleções de código (suas funções) e dados (seus estados) que correspondem a um endereço de contrato específico no blockchain.

Por exemplo, a linha uint256 counter; define o counter de variáveis ??do tipo uint256 (inteiro sem sinal de 256 bits). Agora ele pode ser considerado como um único slot em um banco de dados que pode ser obtido chamando a função do código que gerencia o banco de dados. Podemos até definir um valor para o counter variáveis ??enquanto também definimos o tipo como uint256.

 contador de uint256 = 5; 

As variáveis ??de estado geralmente estão fora das funções, tornando-as variáveis ??globais e geralmente são as primeiras linhas do nosso contrato. Agora, conseguimos definir nosso counter variáveis ??como um uint256 e um valor de 5. Se quisermos chamar uma função para aumentar o valor do counter em 1, criaremos uma função (vamos chamá-la de “ add ”) e diga para adicionar 1 ao counter .

 function add () public { 
contador ++;
}

Depois de chamar a função “add ()”, o counter terá um valor de 6.

Construindo o contrato

Vamos criar nosso contrato "Hello World!" Criando primeiro um contrato chamado:

 solidez do pragma ^ 0.4.16; 
 contrato HelloWorld { 


}

Agora podemos incluir a variável de estado do counter sobre a qual falamos antes. Lembre-se, vamos atribuir essa variável de estado como um inteiro sem sinal de 256 bits (sem sinal, significando que esse tipo pode ser apenas inteiros positivos, não positivos e negativos. O tamanho de 256 bits é um design da Máquina Virtual Ethereum). Ah sim, também configure para um valor de 5.

 solidez do pragma ^ 0.4.16; 
 contrato HelloWorld { 
 contador de uint256 = 5; 

}

Vá em frente e veja se você pode criar duas funções abaixo dessa atribuição de variável de estado. Nós precisamos 1). uma função que aumenta o contador por 1 e 2). uma função que diminui o contador em 1.

 solidez do pragma ^ 0.4.16; 
 contrato HelloWorld { 

contador de uint256 = 5; // variável de estado que atribuímos anteriormente
 function add () public {// aumenta o contador em 1 
contador ++;
}

function subtract () public {// diminui o contador em 1
contador--;
}


}

Você verá no código acima que atribuímos a ambas as funções o modificador public . Como o Solidity conhece dois tipos de chamadas de função (internas que não criam uma chamada EVM real – também chamada de “chamada de mensagem”) e externas, existem quatro tipos de visibilidade para funções e variáveis ??de estado. Funções podem ser especificadas como external , public , internal ou private , o padrão é public . Além do fato de que o Remix emitirá uma mensagem de aviso informando que nenhuma visibilidade é especificada e está padronizando para public , digitar a visibilidade da função é um bom hábito para entrar. Isso nos permitirá entender melhor as configurações do contrato ao avaliar nosso código.

Estamos chegando perto, mas não exatamente lá. Nossa variável de estado pode mudar dependendo da função que chamamos, mas precisamos de uma função que produza o valor do counter . Tente criar uma função chamada “getCounter ()” que retornará o counter . Esta será uma ação somente de leitura , então precisamos informar nossa função de que estaremos retornando uma constante. Além disso, ao retornar uma variável de estado, devemos informar à nossa função o tipo que está sendo retornado; nesse caso, estamos retornando um uint256, conforme discutido anteriormente.

 solidez do pragma ^ 0.4.16; 
 contrato HelloWorld { 

contador de uint256 = 5; // variável de estado que atribuímos anteriormente
 function add () public {// aumenta o contador em 1 
contador ++;
}

function subtract () public {// diminui o contador em 1
contador--;
}
 function getCounter () public retornos constantes (uint256) { 
contador de retorno;
}
}

Enquanto chamar uma função na rede Ethereum exigirá uma pequena quantidade de gás a ser gasto, nenhum gás é necessário ao retornar uma função constante.

Impressionante! Então agora temos um contrato que nos permite alterar o valor do nosso counter variáveis ??globais. Nós também podemos aumentá-lo em 1, diminuí-lo em 1 e retornar o valor de nosso contador sempre que quisermos. Vamos dar um giro …

Vamos testar este Thang

Portanto, seu código deve estar em Remix e a opção “Compilação automática” deve ser marcada por padrão na guia “Compile”. Faça o seu caminho até a guia "Executar". As configurações padrão terão o ambiente definido como JavaScript VM, uma conta será selecionada, o limite de gás será 3000000 e seu valor e preço de gás será 0. Clique em "Criar" na guia "Executar". Agora você deve ver seu contrato criado como abaixo.

Observe que a quantidade de éter em nossa conta caiu ligeiramente de 100 após a criação do contrato.

Logo de cara você pode ver as 3 funções que criamos – “add”, “substract” e “getCounter”. Você também pode ver que nossa variável de estado tem um valor atribuído a ela de 5. Agora, clique em “add” para aumentar nosso counter em 1. Então, vá em frente e clique em “getCounter” para chamar nosso counter recém-modificado. Você deve ver que o valor foi atualizado para 6. Tente novamente para "subtrair".

WOOHOO! Dê um tapinha nas costas. Você acabou de fazer isso. Contrato criado!

Implantando contratos no Mist

Agora que testamos e confirmamos nosso código no Remix, vamos iniciar o Mist (verifique se ele está conectado à rede privada) e implantá-lo em nossa rede privada. Navegue até a guia “Contratos” da Ethereum Wallet in Mist. Em seguida, selecione "Implantar Novo Contrato" e cole nosso código do Remix na caixa do código-fonte.

Antes de prosseguirmos, precisamos ter éter em nossa carteira. Nós podemos minerar por éter em nossa rede privada executando o minerador. Faremos isso por meio do console JavaScript do Geth.

Abra OUTOUT janela de prompt de comando apontando para sua pasta de rede privada (C: / users / name / desktop / rede privada) e digite geth attach . Aperte enter. Você verá um console JavaScript Geth gerado e agora você pode inserir comandos diretamente no Geth. Vamos começar a minerar para algum éter digitando miner.start(); . Você verá que o console retorna “null” e a mineração já começou! Dê uma olhada em sua carteira na Mist, você verá incrementos de 5 éter continuamente adicionados à sua carteira. Você pode parar o minerador a qualquer momento digitando miner.stop(); no console … ou você pode continuar com o meu éter falso … o que te faz feliz!

Saiba mais sobre os comandos do console JS aqui: https://github.com/ethereum/go-ethereum/wiki/JavaScript-Console

Agora, volte para a guia "Contratos", "Implantar novo contrato", verifique se nosso código está na caixa de código-fonte. À direita da caixa do código-fonte, selecione "Hello World" como o contrato a ser implantado e clique em implantar.

Depois de inserir sua senha, volte para a guia "Carteiras". Role para baixo até "Lastest Transactions" e você verá o contrato que acabamos de implantar. Você também notará que o contrato mostra 0 de 12 confirmações e está preso em um estado perpétuo de "criação de contrato".

A razão pela qual nosso contrato não foi totalmente criado é que não há mineiros em nossa rede confirmando nosso novo contrato implantado. Comece a minerar novamente no console Geth JavaScript que abrimos anteriormente ( miner.start(); ). Quando começarmos a mineração novamente, veremos que o número de confirmações começará a aumentar, acabando por implantar nosso contrato.

Agora clique no nome do contrato. A partir daqui podemos fazer todo o tipo de coisas. Podemos transferir o éter para o contrato, copiar o endereço do contrato, gerar um código QR para ser escaneado, obter a interface de contratos (ABI) e até executar funções de contrato.

Como você pode ver, nosso contrato “Hello World” está exibindo nossa função getCounter () com a variável de estado do counter 5. Faça o seu caminho para “selecionar função” e selecione a função “adicionar” ou “subtrair”. Uma vez selecionado, clique em "executar". Não se esqueça, somos os únicos em nossa rede privada, por isso precisamos confirmar a transação executando nosso minerador!

E aí temos que! Nosso contrato executou a função de subtração e retornou um valor de "4". Agora temos um contrato inteligente ao vivo em nossa rede privada de blockchain Ethereum que pode ser interagida com o Mist!

Bônus: Adicionando uma Função de Auto-Destruição

Como mencionado acima, quando os contratos são implantados, eles são oficialmente adicionados ao blockchain Ethereum e qualquer um com o endereço do contrato pode interagir com o contrato, até certo ponto que é. E se nós, como proprietário, decidirmos remover o contrato do blockchain? Felizmente, o Solidity oferece um método incrivelmente fácil, talvez talvez muito fácil, para acabar com o contrato. Podemos realizar a operação de selfdestruct . Quando nós selfdestruct o contrato, todo o Éter restante armazenado no endereço do contrato é enviado para um alvo designado e o contrato não é mais.

Embora desejemos ter a opção de destruir o contrato, queremos ter certeza de que essa operação só pode ser realizada pelo criador do contrato. Pode ser CATASTRÓFICO negligenciar a atribuição de privilégios de selfdestruct a uma determinada pessoa (s). Precisamos primeiro informar ao nosso contrato quem é o proprietário do contrato, que é o msg.sender . Vá em frente e defina o owner variável de estado como msg.sender . Como o msg.sender está associado a um endereço, também precisamos informar ao Solidity que a variável de estado será atribuída como um address .

 solidez do pragma ^ 0.4.16; 
 contrato HelloWorld { 

contador de uint256 = 5; // variável de estado que atribuímos anteriormente
endereço owner = msg.sender; // set owner como msg.sender
 ........ 
 } 

Vamos chamar a função de autodestruição de "kill" e também criaremos uma instrução if condicional para garantir que a pessoa que está executando a função kill seja realmente o proprietário. Nós também iremos configurar selfdestruct(owner); para dizer ao contrato para enviar todos os fundos do contrato de volta para o owner do contrato.

 solidez do pragma ^ 0.4.16; 
 contrato HelloWorld { 

contador de uint256 = 5; // variável de estado que atribuímos anteriormente
endereço owner = msg.sender; // set owner como msg.sender
 function add () public {// aumenta o contador em 1 
contador ++;
}

function subtract () public {// diminui o contador em 1
contador--;
}
 function getCounter () public retornos constantes (uint256) { 
contador de retorno;
}
 function kill () public {// função de autodestruição, 
if (msg.sender == owner) {
autodestruição (proprietário);
}
}

Agora podemos voltar para Mist e reimplantar um novo contrato com a função kill() adicionada. Para ver a função kill () com força total, vamos implantar o novo contrato, enviar o éter para o contrato e depois inicializar kill() e ver nosso éter retornar à nossa carteira. Da mesma forma, também precisamos criar uma função que seja executada sempre que nosso contrato receber Ether. Para receber Ether, uma função de fallback deve ser marcada no contrato. Se tal função não existe, o contrato não pode receber Ether. Um contrato pode ter exatamente uma função sem nome, que será a função sem nome que marcaremos como payable . Adicione a função abaixo ao nosso contrato, a função pode ser colocada abaixo da função kill() .

 função () público a pagar { 

}

Ótimo, agora nosso contrato pode receber Ether de qualquer carteira que tenha o endereço do contrato! Vá em frente e clique em "Implantar" para implantar nosso novo contrato e enviar sua senha. Certifique-se de que seu minerador esteja em execução para confirmar a transação. Depois de concluído, vá para o contrato e clique em "Copiar endereço". Você receberá uma mensagem de aviso lembrando que está em uma rede de teste, selecione "copiar mesmo assim".

Vamos enviar algum éter …

Impressionante, nós copiamos o endereço do nosso contrato e agora podemos enviar um Ether para testar nossa função kill() . Clique na guia "Enviar" e copie o endereço do contrato no campo "para". Entre em qualquer quantidade de éter que você queira enviar para este teste, eu vou enviar mais de 30.000 Ether.

Você já conhece a rotina… role a tela para baixo e clique em “enviar”, ligue seu minerador e espere a transação ser processada. Você deve notar imediatamente sua carteira já não detém o éter que enviamos para o contrato. Abra o contrato NOVAMENTE sob a guia "Contratos", você verá que o contrato agora tem éter anexado a ele. Selecione a função kill na lista suspensa “Select function” e siga em frente e autodestrua o bad boy. Digite sua senha, acione o mineiro. Depois que 12/12 confirmações forem processadas, sua carteira será restaurada com o Ether que enviamos ao contrato. Agora o contrato está inoperante, mas a história do contrato ainda existe no blockchain.

Tudo em um dia de trabalho…

Aaaaaaandddd ai você tem isso. Parabéns por terminar o tutorial e ter implantado (e matado) seu primeiro contrato inteligente! Há muita coisa que foi abordada aqui, certamente algumas coisas ainda são um pouco de arranhão na cabeça. Tudo bem! Agora você sabe como abrir uma rede privada, escrever código Solidity, implantar no Mist & Remix e interagir com ele. Muito mais a fazer e aprender agora que você sabe o básico.

Espero que este tutorial tenha sido útil! Se você tiver alguma dúvida, gostaria que mais tutoriais fossem lançados, ou tivesse alguma dúvida, desça na seção de comentários abaixo. "Claps" também são muito apreciados!

-Pete

BTC: 17VWQpZHJqDJDZiiofKZvYhLQWFVHVseeG
ETH: 0x84787233aabe3899440655df04e9bee7596eaf17
LTC: LVbJ1igmzqsNLcYsC8m2PouGEuyqvYj5RG

Deixe uma resposta

O seu endereço de e-mail não será publicado. Campos obrigatórios são marcados com *