A web3 está aí e cada vez mais as empresas estão querendo criar funcionalidades e até sistemas inteiros baseados na blockchain. Desta forma, para acompanhar esta tendência é importante que os programadores aprendam como implementar isto e felizmente a esta altura já existem muitas formas de fazer este tipo de integração, em especial com as blockchains baseadas em Ethereum ou EVM-compatible.
No tutorial de hoje eu vou ensinar como escrever aplicações Node.js que se conectam à blockchain e fazem consultas e transações nela. Não é imprescindível o conhecimento de blockchain para implementar os exemplos de código, mas ajuda bastante, então se for o seu primeiro contato, recomendo estudar blockchain por esse tutorial aqui.
Então vamos lá!
#1 – Setup
Neste tutorial vamos usar Node.js e ele não é indicado para quem nunca programou Node.js na vida. Inclusive você precisa ter esta ferramenta já instalada na sua máquina antes de começar. No vídeo abaixo ensino como instalar Node.js e VS Code, a ferramenta que uso para programar.
Depois de ter o Node.js instalado na sua máquina, o próximo passo é ter uma carteira de criptomoedas, já que para se comunicar com a blockchain é obrigatório ter uma. Como vamos programar para blockchains Ethereum, tem de ser uma carteira compatível com a mesma e eu recomendo a MetaMask. O vídeo abaixo ensina o que é e como criar a sua, gratuitamente.
A MetaMask vem por padrão configurada para a rede Mainnet da Ethereum, o que não é muito indicado para desenvolvimento. Indo no select de redes no topo dela você pode usar a opção “mostrar redes de teste” e habilitar o aparecimento da rede Sepolia, usada para testes e que vamos usar aqui. Mesmo sendo uma rede de testes você vai precisar de saldo em ETH para poder fazer transações para ela, então recomendo que use este Faucet PoW para ganhar algumas moedas. Basta conectar a sua carteira, colocar a minerar e em minutos terá saldo para usar na rede Sepolia. Caso tenha problemas com a Sepolia, outra opção é usar a BSC Testnet da Binance, que no vídeo que passei acima eu ensino a configurar na MetaMask ou qualquer outra rede compatível com EVM (Avalanche, Polygon, etc).
Para que nosso script possa assinar transações usando a sua carteira ele vai precisar da chave privada dela. Para obtê-la vá na MetaMask, acesse sua conta no canto superior esquerdo, depois nas reticências escolha Detalhes da Conta, como mostra a imagem abaixo, indo na opção “Private Keys”. Guarde a chave privada da rede Ethereum em um lugar seguro, vamos precisar dela logo mais.
Agora sim, temos todo o necessário para começar a programar, então vamos criar nosso projeto. Crie na sua máquina uma pasta viem-node e dentro dela rode o comando para inicialização do projeto.
|
1 2 3 |
npm init -y |
Com o projeto inicializado, vamos instalar e inicializar o TypeScript na pasta e o TS-Node, pois a biblioteca que vamos usar a seguir é muito mais poderosa com ele.
|
1 2 3 4 |
npm i -D typescript ts-node @types/node npx tsc --init |
Para que os types do Node que instalamos sejam interpretados corretamente, é importante ir no tsconfig.json e ajustar a seção types para inclui-los.
|
1 2 3 |
"types": ["node"], |
Com o projeto inicializado, vamos instalar as dependências que usaremos.
|
1 2 3 |
npm i dotenv viem |
O dotenv é para guardarmos as configurações de ambiente, enquanto que o Viem é o módulo que usaremos para comunicação com a blockchain. Ele nada mais faz do que abstrai todas as chamadas ao node RPC da blockchain que vamos nos conectar, facilitando toda a comunicação da nossa aplicação com o mesmo, já que usaremos boas e velhas funções JS. Mais que isso, ele infere tipos de uma maneira extremamente poderosa, sendo o seu maior trunfo frente às bibliotecas concorrentes no âmbito de web3.
Para configurar nossas variáveis de ambiente, crie um arquivo .env na raiz da aplicação e nele coloque as seguintes variáveis.
|
1 2 3 4 |
WALLET=<o endereço público da sua MetaMask> PRIVATE_KEY=<sua chave privada da MetaMask> |
Atenção com a private key da sua carteira cripto: jamais informe ela, para ninguém. Também não versione esse arquivo .env, certifique-se de colocá-lo no seu .gitignore se estiver usando Git.
Agora ajuste no seu package.json para inicializar o projeto usando ts-node, para evitar a etapa de transpilação durante o desenvolvimento e ajuste o type do projeto também para suporte a sintaxe mais moderna do JS/TS.
|
1 2 3 4 5 6 |
"type": "module", "scripts": { "start": "node --loader ts-node/esm src/index.ts" }, |
Crie um index.ts em uma pasta src na raiz do projeto e teste um olá mundo com npm start para garantir que está tudo funcionando.
Agora terminamos o setup e podemos começar a programar.
#2 – Saldo ETH
A primeira coisa que você deve aprender é como ver o saldo da sua carteira e como transferir fundos dela para outra carteira. Considerando que estamos programando para redes ETH, tanto o saldo quanto a transferência dizem respeito a essa moeda pois é a nativa da rede. Mais tarde mostrarei como interagir com smart contracts, aí poderá ver saldo e transferir outros tokens, por exemplo, além de chamadas a contratos em geral.
Para começarmos a programar vá no seu arquivo index.ts na raiz da sua aplicação e vamos começar importando as bibliotecas que precisamos.
|
1 2 3 4 5 6 7 8 9 10 11 |
import "dotenv/config"; import { createPublicClient, http, formatEther } from 'viem' import { sepolia } from 'viem/chains' const client = createPublicClient({ chain: sepolia, transport: http(), }) |
Aqui eu importei e configurei o dotenv, que vai carregar todas nossas variáveis de ambiente contidas no arquivo .env para a memória.
Depois, importei as funções createPublicClient, http e formatEther que usaremos a seguir, além de um objeto sepolia com as informações da respectiva rede que vamos usar. Se você vier a usar outra rede, importe o objeto mais apropriado.
Primeiro, vamos criar rapidamente a função que pega e imprime o saldo de uma carteira no console, como abaixo.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
async function getEthBalance(address: `0x${string}`) { const client = createPublicClient({ chain: sepolia, transport: http(), }) const balance = await client.getBalance({ address }); console.log(formatEther(balance)); } getEthBalance(process.env.WALLET as `0x${string}`); |
No exemplo acima eu criei um cliente público (somente leitura) com a blockchain Sepolia via HTTP. Com esse client eu posso enviar calls para a blockchain, incluindo algumas funções nativas como a getBalance, que espera o endereço a ser consultado. O retorno do getBalance, em wei, então é convertido para ETH com a função formatEther que havíamos importado. Repare na tipagem do endereço, exigência do Viem + TS.
A última linha é apenas para chamar a função quando rodarmos a aplicação e optei por passar a nossa carteira configurada no .env por parâmetro. O resultado deve ser a impressão do seu saldo em ETH. Confirme olhando na sua carteira cripto se veio corretamente.
Agora vamos fazer algo mais elaborado, uma transferência!
#3 – Transferência ETH
Além de ver saldo, outra tarefa muito recorrente é a transferência de fundos. Como estamos em uma rede ETH, a transferência é realizada sobre a moeda nativa, ou seja, ETH. Para que uma transferência ocorra é necessário enviar uma transação para a rede, assinada pela carteira que vai enviar os fundos.
Antes de fazer esta transferência é importante que você tenha uma segunda conta configurada para a mesma blockchain para poder fazer o teste. Você pode fazer isso facilmente na própria interface da MetaMask indo na sua conta e escolhendo a opção “Add account” como mostrado na imagem abaixo ou instalando em outro navegador.
Agora vamos adicionar algumas importações adicionais no topo do arquivo, necessárias para transações.
|
1 2 3 4 |
import { createWalletClient, parseEther } from "viem"; import { privateKeyToAccount } from "viem/accounts"; |
Para criar e assinar uma transação você vai precisar das seguintes informações:
- o endereço público da carteira que vai enviar ETH;
- a chave privada da carteira que vai enviar ETH;
- to: o endereço público da carteira que vai receber ETH;
- value: o valor a ser transferido, em wei;
Com essas informações em mãos, podemos escrever o código abaixo, da função transferEth.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 |
async function transferEth(to: `0x${string}`, value: string) { const privateKey = process.env.PRIVATE_KEY as `0x${string}`; if (!privateKey) throw new Error("Defina PRIVATE_KEY no .env"); // Conta do remetente const account = privateKeyToAccount(`0x${privateKey}`); // Cliente conectado à rede Sepolia const client = createWalletClient({ account, chain: sepolia, transport: http() }); console.log(`Enviando ${value} ETH para ${to}...`); // Montar e assinar transação const hash = await client.sendTransaction({ to, value: parseEther(value) // quantidade em ETH }); console.log("Tx hash:", hash); console.log("Veja no block explorer: https://sepolia.etherscan.io/tx/" + hash); } transferEth("0x576906e0321cd8d57928aef6b3e9e81cd6d0ecef", "0.001"); |
A primeira linha carrega e valida a PRIVATE_KEY de quem vai enviar os fundos, a partir do .env. A linha seguinte faz a inicialização de um objeto account a partir da private key e aqui vai um truque: a string da private key deve ser hexa, ou seja, iniciada em 0x, mas quando você copia da MetaMask geralmente vem sem o 0x na frente, por isso o ajuste que fiz ali.
Com essa account, mais as informações da rede (chain) e do nó RPC que vamos usar (transport), podemos inicializar um objeto do tipo wallet client. Diferente dos public clientes, que somente fazem operações de leitura, os wallet clients são a forma como fazemos transações (operações de escrita) na blockchain com a biblioteca Viem. Essa é uma característica bem marcante dessa biblioteca, ter clientes distintos para leituras e escritas.
Na linha seguinte, montamos a transação com os parâmetros da função sendTransaction que vai assinar e enviar para a blockchain, com um detalhe especial para o uso de parseEther para converter de ETH para wei, exigência das blockchains. Como retorno temos o hash da transação, para conferência no block explorer. Um exemplo de transação realizada com o código acima pode ser vista aqui.
E com isso você aprendeu como consultar saldo e enviar fundos entre carteiras usando Node.js e a biblioteca Viem, com uma ajudinha da MetaMask. No próximo tutorial, quero te ensinar como você se comunica via Node.js com Smart Contracts existentes na blockchain. Veja aqui
Até lá!
Olá, tudo bem?
O que você achou deste conteúdo? Conte nos comentários.