Como Publicar um Contrato Inteligente em uma Rede de Testes da Ethereum

Contratos inteligentes! Eles são supostamente os novos aplicativos da web. Ok, vamos então produzir um.

Basicamente, um contrato inteligente é um aplicativo da web que não é hospedado em um servidor controlado por uma determinada empresa, como DigitalOcean ou Google Cloud. Em vez disso, esse aplicativo da web é hospedado em todos os nós da Ethereum ao mesmo tempo, sendo que as entidades que os controlam são muitas. Mas as entidades verificam umas às outras para garantir que cada entidade tenha o aplicativo da web original em vez de alguma outra versão dele.

Dessa forma, podemos publicar um aplicativo da web que certamente não será modificado pelo publicador, assim como um editor de livros pode auditar o texto do livro de um autor. Além disso, o aplicativo da web, uma vez publicado, nunca pode ser despublicado. Cada entidade garante que todas as outras entidades ainda hospedem esse aplicativo da web não modificado.

Chega de conversa! Como podemos criar um contrato inteligente na Ethereum e publicá-lo?

(Uma pequena observação: Todo o código abaixo tecnicamente não oferece as garantias listadas acima porque a rede Ethereum que usamos é apenas para fins de teste. Na Ethereum real, você precisaria pagar dinheiro real [a partir de 6 de maio de 2023: um pagamento único de cerca de $2.000 de acordo com esse cara] para manter o contrato inteligente vivo, não modificado, para sempre.)

Criando e publicando um contrato inteligente na Ethereum

Vamos publicar um contrato inteligente na rede de testes (testnet) da Ethereum chamada Sepolia. O contrato inteligente simplesmente armazenará uma mensagem e um endereço com o significado: apenas o proprietário da carteira no endereço armazenado pode alterar a mensagem. Qualquer pessoa pode ler a mensagem. É isso.

Para criar nosso contrato inteligente, execute o seguinte script:

mkdir hardhat-contract
cd hardhat-contract

npm install \
   hardhat \
   dotenv \
   @nomiclabs/hardhat-ethers \
   @nomiclabs/hardhat-etherscan

npx hardhat

A CLI do Hardhat fará uma série de perguntas para configurar o projeto. Selecione Create an empty hardhat.config.js para criar um arquivo de configuração vazio.

Para publicar nosso contrato inteligente, como mencionado acima, vamos usar a rede de testes da Ethereum chamada Sepolia. Para isso, vamos editar o arquivo do caminho hardhat-contract/hardhat.config.js:

require("@nomiclabs/hardhat-ethers");
require("@nomiclabs/hardhat-etherscan");
require("dotenv").config();

const INFURA_API_KEY = process.env.INFURA_API_KEY;
const ETHERSCAN_API_KEY = process.env.ETHERSCAN_API_KEY;
const SEPOLIA_PRIVATE_KEY = process.env.SEPOLIA_PRIVATE_KEY;

module.exports = {
 solidity: "0.8.18",
 networks: {
   sepolia: {
     url: `https://sepolia.infura.io/v3/${INFURA_API_KEY}`,
     accounts: [SEPOLIA_PRIVATE_KEY]
   }
 },
 etherscan: {
   apiKey: ETHERSCAN_API_KEY,
 },
};

Além disso, crie um novo arquivo .env no mesmo diretório e escreva o seguinte:

ETHERSCAN_API_KEY=XXX
INFURA_API_KEY=YYY
SEPOLIA_PRIVATE_KEY=ZZZ

Você encontrará sua chave atual do Etherscan, assim que criar uma conta gratuita, aqui. Ou do Infura, aqui. E sua chave da carteira, que é sua chave privada da Sepolia, você pode recuperá-la na MetaMask, indo até Detalhes da Conta -> Exportar chave privada.

Se você usar um gerenciador de carteira de criptomoedas diferente da MetaMask, pode perguntar ao ChatGPT como obter a chave privada da sua carteira. A chave privada, durante este tutorial está tecnicamente sempre sob seu controle, mas se você tiver ETH da rede principal (mainnet) nela, é aconselhável não exportar sua chave privada para o seu disco rígido. Na MetaMask, você pode facilmente criar uma nova carteira com Criar conta e abastecê-la com ETH da rede de testes através desta página.

Agora, vamos definir um mensageiro como um endereço da rede de testes, que pode publicar uma mensagem irreversível como uma string.

Para isso, crie um novo arquivo no caminho contracts/UndeletableMessage.sol:

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.18;

contract UndeletableMessage {
 string public message;
 address public messenger;

 constructor(string memory _message, address _messenger) {
   message = _message;
   messenger = _messenger;
 }

 modifier onlyMessenger() {
   require(msg.sender == messenger, "Only the messenger can call this function");
   _;
 }

 function setMessage(string memory newMessage) external onlyMessenger {
   message = newMessage;
 }
}

A seguir, iremos realmente implantar este contrato em uma rede de testes da Ethereum com o caminho scripts/deploy-contract.js:

const hre = require("hardhat");

function sleep(ms) {
 return new Promise((resolve) => setTimeout(resolve, ms));
}

async function main() {
 const initialMessage = "Your initial important message";
 const [deployer] = await ethers.getSigners();
 const ownerAddress = deployer.address;

 const Token = await ethers.getContractFactory("UndeletableMessage");
 const token = await Token.deploy(initialMessage, ownerAddress);
 await token.deployed();
 console.log(`UndeletableMessage deployed to: https://sepolia.etherscan.io/address/${token.address}`);

 console.log("Waiting 30 seconds before verifying the contract...");
 await sleep(30 * 1000);

 console.log("Verifying contract on Etherscan...");
 await hre.run("verify:verify", {
   address: token.address,
   constructorArguments: [initialMessage, ownerAddress],
   network: "goerli",
 });
 console.log("Contract verified on Etherscan");
}

main()
 .then(() => process.exit(0))
 .catch((error) => {
   console.error(error);
   process.exit(1);
 });

Agora, vamos compilar o contrato inteligente e executar o script que fará referência ao contrato inteligente:

npx hardhat compile
npx hardhat run --network sepolia scripts/deploy-contract.js

Você deve obter a seguinte saída:

Compiled 1 Solidity file successfully
UndeletableMessage deployed to: https://sepolia.etherscan.io/address/0x3cCe57Ef683ED3631B6EEA15312D35e38B4627b6
Waiting 30 seconds before verifying the contract...
Verifying contract on Etherscan...
Nothing to compile
Successfully submitted source code for contract
contracts/UndeletableMessage.sol:UndeletableMessage at 0x3cCe57Ef683ED3631B6EEA15312D35e38B4627b6
for verification on the block explorer. Waiting for verification result...

Successfully verified contract UndeletableMessage on Etherscan.
https://sepolia.etherscan.io/address/0x3cCe57Ef683ED3631B6EEA15312D35e38B4627b6#code
Contract verified on Etherscan

O contrato inteligente realmente foi implantado? Como podemos ler essa mensagem pública? Como podemos alterar a mensagem pública?

Se você acessar aquele link da Sepolia, você chegará à página do contrato:

A partir daqui, você pode ir para a guia Contract e clicar em Read Contract:

Como você pode ver, a mensagem é a padrão "Your initial important message" (sua mensagem importante inicial) que foi especificada no script deploy-contract.js.

Vá para a opção Write Contract. Clique em Connect to Web3 e faça login com a carteira cuja chave privada está no arquivo .env. Agora, você pode enviar uma transação para a rede de testes para transmitir uma mensagem diferente:

Agora, você pode verificar se a transação foi concluída. Em outras palavras: você pode verificar se você modificou o estado deste contrato:

Mas e se você se conectar à API Web3 usando outra carteira? Tente criar uma nova carteira, coloque um pouco de ETH da rede de testes nela usando este link e, em seguida, tente escrever no contrato novamente:

Se você rastrear a transação exata, ela terá uma aparência semelhante a esta:

Você pode ver o erro Only the messenger can call this function (Somente o mensageiro pode chamar esta função) que escrevemos acima no modificador do nosso contrato.

Psst! Aqui está todo o código deste artigo: Obtenha o código. Você só precisa clonar o repositório, criar e preencher seu próprio arquivo .env. Em seguida, execute ./RUN. O repositório também contém um arquivo do Docker e instruções sobre como usar para executar todo o código discutido em um sistema operacional isolado.

Contratos inteligentes: esse é o futuro?

Então, o que fizemos? Na verdade, publicamos um texto que nunca será removido da Internet novamente (se tivéssemos pago $2.000 e realmente feito isso na rede principal em vez da rede de testes).

Isso não é realmente uma conquista óbvia, já que muitos sites saem do ar com o tempo e qualquer vídeo do YouTube que você não tenha baixado pode se perder um dia.

Mas, dado que as pessoas ganham dinheiro validando dados na Ethereum, este texto "EU SOU QUEM EU SOU" (se tivéssemos publicado na rede principal) estará acessível para sempre.

Dessa forma, enquanto a humanidade usar dinheiro, você pode pagar por um contrato inteligente para preservar suas informações.

Artigo original publicado por Dimitri Rusin. Traduzido por Paulinho Giovannini.