Como criar seu primeiro Smart Contract em Solidity com Foundry

Se o Bitcoin foi o grande catalisador para o surgimento das criptomoedas modernas como conhecemos, a Ethereum foi a grande catalisadora para o surgimento de milhares de outras criptomoedas, NFTs e a própria Web 3.0 que vem se falando cada vez mais. Vitalik Buterin, criador da rede Ethereum e seu time, vislumbraram na tecnologia blockchain não apenas a possibilidade de criar um dinheiro virtual P2P, ou seja descentralizado e seguro, como a oportunidade de permitir a criação de “contratos inteligentes” (smart contracts). Assim, qualquer programador ao redor do mundo poderia publicar seus códigos para serem executados na rede Ethereum e com isso iniciar o surgimento de todo um ecossistema ainda maior e mais vibrante (embora ainda de menor capitalização) do que o Bitcoin original.

Em 2014, foi Gavin Wood, um dos fundadores da Ethereum, que teve a ideia de criar a linguagem Solidity, especificamente para a codificação de Smart Contracts na rede Ethereum e demais redes compatíveis (forks, como a BNB Smart Chain que surgiu anos mais tarde). Os smart contracts escritos em Solidity são publicados na rede e toda vez que acionados por clientes, rodam em um interpretador chamado EVM, a Ethereum Virtual Machine, semelhante ao que acontece com a VM do Java, caso você conheça.

A linguagem Solidity é hoje a principal tecnologia relacionada a smart contracts que você deve estudar se deseja aprender a criar aplicações que rodam na blockchain, principalmente Dex, Defi, DAOs e é claro, dapps Web3. Uma linguagem jovem, semelhante ao padrão ECMA para quem está acostumado com programação JS, mas com tipagem estática. Aliás, os contratos em si lembram muito as classes existentes em outras linguagens Orientadas à Objetos.

A minha ideia com este tutorial é lhe dar uma introdução nesta linguagem e tecnologia, lhe despertando então interesse (e capacidade) por conhecer mais sobre este universo que não pára de crescer. Acredito estar desta forma colaborando com o desenvolvimento de novos profissionais neste meio, principalmente aqueles sem grandes conhecimentos do idioma Inglês, onde você encontra muito material acerca de Solidity.

Neste tutorial usaremos o Foundry. Se preferir, pode assistir ao vídeo abaixo ao invés de ler.

Então vamos lá!

#1 – Ambiente

Primeiro é importante entender que não tem uma única forma de criar os seus smart contracts com Solidity. Em outro tutorial aqui do blog eu mostrei como fazer com a ferramenta Remix, por exemplo, e neste outro com HardHat. São diferentes ferramentas, mas para a mesma finalidade.

Para usarmos o Foundry neste tutorial, o primeiro passo é instalar ele no seu terminal. Abra seu terminal de linha de comando e rode os seguintes comandos:

Talvez você tenha de reiniciar o seu terminal antes do último comando para que funcione corretamente. Isso instalará 4 ferramentas da suíte Foundry na sua máquina, sendo que a mais importante delas é a Forge, que serve para escrevermos scripts de teste e deploy de nossos smart contracts. Esse mesmo comando foundryup pode ser usado mais tarde para atualizar seu Foundry.

Agora para escrevermos nossos códigos eu vou usar o VS Code. Você vai precisar primeiramente do Node.js, pois ele é a base o VS Code. Então vá até o site oficial e baixe a versão LTS para sua máquina, instalando-a até o final (marcando tudo que ela perguntar durante o processo). Depois o VS Code pode ser baixado no site oficial.

As instalações são bem diretas, mas se precisar de ajuda, o vídeo abaixo pode te ajudar.

Um dos motivos de eu recomendar o Visual Studio Code ao invés de outros editores é que além dele ser gratuito, leve e multiplataforma, ele tem a possibilidade de instalarmos extensões para diferentes linguagens, como no caso da extensão Solidity da empresa Nomic Foundation, que eu recomendo que instale na aba de extensões assim que estiver com o VS Code aberto a primeira vez.

Agora que temos tudo pronto no ambiente, é hora de criarmos o nosso projeto. Para isso, rode o comando abaixo.

O Foundry é escrito em Rust, mas toda a programação que você vai fazer é via Solidity, a mesma linguagem do smart contract. Como resultado você terá a estrutura do seu projeto criada automaticamente, como abaixo.

Essa estrutura inicial é de um projeto chamado Counter e você encontrará o contrato dele na pasta src, sendo um arquivo com extensão “.sol” (de Solidity). Nada importante pra gente, pode ignorar. Outras pastas importantes incluem a test, onde vamos ter contratos de teste (sim, você escreve contratos para testar outros contratos) e a pasta script, onde vamos ter scripts para deploy e outras ações.

#2 – Criando o Hello World

Como vamos criar o nosso contrato do zero e ele vai ser bem simples, recomendo renomear o Counter.sol da pasta para HelloWorld.sol e apagar todo o seu conteúdo.

Assim que tiver este arquivo em branco, tem duas instruções iniciais que devemos colocar. Uma delas é a licença do seu código-fonte, que você pode incluir como abaixo, que vai adicionar a licença MIT. Tendo interesse em mudar a licença para outra à sua escolhe, fique à vontade.

A segunda instrução é a versão do compilador de Solidity que será usada para compilar este contrato. Isso porque assim como funciona com a linguagem Java, C# e outras, nós escrevemos o programa (contrato neste caso) em uma linguagem e ela precisa ser compilada para uma linguagem de máquina que será interpretada pela EVM (Ethereum Virtual Machine) mais tarde. Ao longo do tempo novas versões da linguagem são lançadas com novas funcionalidades e portanto é importante especificar qual a versão que você precisa para o seu projeto.

Para isso, use o exemplo abaixo que vai adicionar uma instrução de versão para você, que deve ser preenchida com a versão de Solidity que foi instalada junto do Foundry na sua máquina.

Abaixo destas informações todas é que vamos começar a codificar nosso primeiro contrato. Se você já conhece alguma linguagem orientada à objetos antes, vai se sentir em casa pois escrever um contrato é muito semelhante a escrever classes. Para começar, você define o seu contrato usando a palavra reservada contract e definindo o seu escopo entre chaves.

Dentro do contrato você pode colocar suas propriedades e funções, assim como faria com classes e começaremos declarando uma propriedade chamada message, apenas para guardar o conteúdo de uma mensagem.

O tipo da variável definimos como string (texto), o modificador de acesso colocamos como public (o que indica que pode ser acessado de fora do contrato), o nome da variável colocamos message (mensagem em Inglês) e atribuímos o valor entre aspas “Hello World” para ela, da mesma forma que faríamos em JavaScript e tantas outras linguagens de programação.

Outros tipos válidos para variáveis, dentre muitos:

• bool: true ou false;
• int: números inteiros (com variações em bits como int8, int256, etc);
• uint: inteiros positivos (sem sinal, unsigned, com variações em bits como uint8, uint256, etc);
• address: endereços na rede;

Da mesma forma, o processo de criação de uma função também é bem simples e abaixo segue um exemplo de função helloWorld.

Neste exemplo usamos a palavra reservada function para dizer que vamos escrever uma função, damos o nome à mesma (camel case) e abrimos parênteses para definir os parâmetros, que optei aqui por não ter nenhum. Na sequência definimos o modificador de acesso (public, indicando que ela pode ser chamada fora deste contrato), o tipo de função (usei view pois vamos precisar visualizar uma informação do contrato) e a palavra reservada returns para informar o que essa informação retorna, neste caso uma única variável string memory (que explicarei mais tarde o porque do memory).

Talvez o ponto mais diferentão aqui seja a palavra reservada view, que indica que esta função vai ler o “estado” do contrato, ou seja, as suas propriedades/variáveis internas. Outra opção seria a palavra reservada pure, que indica que esta é uma função pura, ou seja, sem estado, sem usar variáveis externas. É importante ressaltar desde já que o uso de variáveis de classe ou de função impactam diretamente no custo das chamadas à este contrato, o que exploraremos futuramente aqui no blog. E por último também temos as funções payable, que permitem que alguém envie fundos (pague) para usar a função.

Além disso, outro ponto que é bacana reforçar é quanto ao modificador de acesso, public, que se não for informado vai ser private por padrão, ou seja, sem acesso externo.

O conteúdo da função em si dispensa explicações e agora que temos nosso HelloWorld codificado, é hora de testarmos ele.

#3 – Testando o Hello World

Testes são uma parte crucial do desenvolvimento de qualquer software mas Solidity coloca isso em outro patamar. Isso porque como seu contrato ficará visível na blockchain e na maioria das vezes ele envolverá dinheiro, é crucial que ele esteja em pleno funcionamento e que seja seguro. Não apenas isso, as transações na blockchain são imutáveis, então não temos margem para corrigir pequenas coisinhas depois, como é comum no mundo web.

Com o Foundry é possível escrever unit tests em Solidity, a mesma linguagem do smart contract, graças ao componente do toolkit chamado Forge, mesmo recurso de testes usado no concorrente HardHat.

Para escrever um teste em Solidity, renomei o arquivo Counter.t.sol da pasta test para HelloWorld.t.sol e comece importando o contrato principal e a lib de testes.

Depois, crie um contrato HelloWorldTest que herda da lib Test e possui uma propriedade do tipo do contrato principal.

Para o setup dos testes, crie uma função que instancia o contrato.

E por fim, crie uma função de teste, como abaixo.

Note que essa função faz um teste muito simples que é se a mensagem está correta, usando a função assertEq para verificar a igualdade.

Para rodar esse teste, primeiro precisamos compilar o projeto, só que como sua pasta de script deve ter um script errado, exclua ele. Depois, compile com:

E rode os testes com:

O resultado deve ser como abaixo, indicando que 1 teste está passando.

E com isso finalizamos o nosso primeiro tutorial de Solidity com Foundry aqui do blog. Neste outro, dou um exemplo maior (CRUD) e neste ensino a fazer deploy na blockchain.

Até a próxima!