Enviando transações usando Web3

transações

web3.js

Alchemy

Iniciante

Elan Halpern

Alchemy docs

4 de novembro de 2020

10 minutos de leitura

Editar página

Este é um guia para iniciantes sobre como enviar transações na Ethereum usando Web3. Existem três etapas principais para enviar uma transação para a blockchain da Ethereum: criar, assinar e transmitir. Vamos passar por todas as três, com a esperança de responder a quaisquer perguntas que você possa ter! Neste tutorial, usaremos a Alchemy (opens in a new tab) para enviar nossas transações para a cadeia da Ethereum. Você pode criar uma conta gratuita na Alchemy aqui (opens in a new tab).

NOTA: Este guia é para assinar suas transações no backend do seu aplicativo. Se você quiser integrar a assinatura de suas transações no frontend, confira a integração da Web3 com um provedor de navegador (opens in a new tab).

O básico

Assim como a maioria dos desenvolvedores de blockchain quando estão começando, você pode ter feito algumas pesquisas sobre como enviar uma transação (algo que deveria ser bem simples) e se deparado com uma infinidade de guias, cada um dizendo coisas diferentes e deixando você um pouco sobrecarregado e confuso. Se você está nesse barco, não se preocupe; todos nós já estivemos lá em algum momento! Então, antes de começarmos, vamos esclarecer algumas coisas:

1. A Alchemy não armazena suas chaves privadas

Isso significa que a Alchemy não pode assinar e enviar transações em seu nome. O motivo disso são questões de segurança. A Alchemy nunca pedirá que você compartilhe sua chave privada, e você nunca deve compartilhar sua chave privada com um nó hospedado (ou com qualquer pessoa, na verdade).
Você pode ler da blockchain usando a API principal da Alchemy, mas para escrever nela você precisará usar outra coisa para assinar suas transações antes de enviá-las através da Alchemy (isso é o mesmo para qualquer outro serviço de nó).

2. O que é um “assinante” (signer)?

Os assinantes assinarão transações para você usando sua chave privada. Neste tutorial, usaremos a Web3 da Alchemy (opens in a new tab) para assinar nossa transação, mas você também pode usar qualquer outra biblioteca Web3.
No frontend, um bom exemplo de assinante seria a MetaMask (opens in a new tab), que assinará e enviará transações em seu nome.

3. Por que preciso assinar minhas transações?

Todo usuário que deseja enviar uma transação na rede Ethereum deve assinar a transação (usando sua chave privada), a fim de validar que a origem da transação é quem afirma ser.
É super importante proteger essa chave privada, pois ter acesso a ela concede controle total sobre sua conta Ethereum, permitindo que você (ou qualquer pessoa com acesso) realize transações em seu nome.

4. Como protejo minha chave privada?

Existem muitas maneiras de proteger sua chave privada e usá-la para enviar transações. Neste tutorial, usaremos um arquivo .env. No entanto, você também pode usar um provedor separado que armazena chaves privadas, usar um arquivo de repositório de chaves (keystore) ou outras opções.

5. Qual é a diferença entre `eth_sendTransaction` e `eth_sendRawTransaction`?

eth_sendTransaction e eth_sendRawTransaction são ambas funções da API da Ethereum que transmitem uma transação para a rede Ethereum para que ela seja adicionada a um bloco futuro. Elas diferem na forma como lidam com a assinatura das transações.

eth_sendTransaction (opens in a new tab) é usado para enviar transações não assinadas, o que significa que o nó para o qual você está enviando deve gerenciar sua chave privada para que possa assinar a transação antes de transmiti-la para a cadeia. Como a Alchemy não guarda as chaves privadas dos usuários, ela não suporta esse método.
eth_sendRawTransaction (opens in a new tab) é usado para transmitir transações que já foram assinadas. Isso significa que você primeiro precisa usar signTransaction(tx, private_key) (opens in a new tab), e então passar o resultado para eth_sendRawTransaction.

Ao usar a Web3, eth_sendRawTransaction é acessado chamando a função web3.eth.sendSignedTransaction (opens in a new tab).

É isso que usaremos neste tutorial.

6. O que é a biblioteca Web3?

Web3.js é uma biblioteca wrapper em torno das chamadas JSON-RPC padrão que é bastante comum de usar no desenvolvimento da Ethereum.
Existem muitas bibliotecas Web3 para diferentes linguagens. Neste tutorial, usaremos a Web3 da Alchemy (opens in a new tab), que é escrita em JavaScript. Você pode conferir outras opções aqui (opens in a new tab), como a Ethers.js (opens in a new tab).

Certo, agora que tiramos algumas dessas dúvidas do caminho, vamos passar para o tutorial. Sinta-se à vontade para fazer perguntas a qualquer momento no Discord (opens in a new tab) da Alchemy!

7. Como enviar transações seguras, otimizadas para gás e privadas?

A Alchemy possui um conjunto de APIs de Transação (opens in a new tab). Você pode usá-las para enviar transações reforçadas, simular transações antes que elas aconteçam, enviar transações privadas e enviar transações otimizadas para gás.
Você também pode usar a API Notify (opens in a new tab) para ser alertado quando sua transação for retirada da mempool e adicionada à cadeia.

NOTA: Este guia requer uma conta na Alchemy, um endereço Ethereum ou carteira MetaMask, NodeJs e npm instalados. Se não, siga estas etapas:

Crie uma conta gratuita na Alchemy (opens in a new tab)
Crie uma conta na MetaMask (opens in a new tab) (ou obtenha um endereço Ethereum)
Siga estas etapas para instalar o NodeJs e o NPM (opens in a new tab)

Etapas para enviar sua transação

1. Crie um aplicativo da Alchemy na rede de teste Sepolia

Navegue até o seu Painel da Alchemy (opens in a new tab) e crie um novo aplicativo, escolhendo Sepolia (ou qualquer outra rede de teste) para sua rede.

2. Solicite ETH do faucet da Sepolia

Siga as instruções no faucet da Sepolia da Alchemy (opens in a new tab) para receber ETH. Certifique-se de incluir seu endereço Ethereum da Sepolia (da MetaMask) e não de outra rede. Depois de seguir as instruções, verifique novamente se você recebeu o ETH em sua carteira.

3. Crie um novo diretório de projeto e use `cd` para entrar nele

Crie um novo diretório de projeto a partir da linha de comando (terminal para Macs) e navegue até ele:

mkdir sendtx-example
cd sendtx-example

4. Instale a Web3 da Alchemy (ou qualquer biblioteca Web3)

Execute o seguinte comando no diretório do seu projeto para instalar a Web3 da Alchemy (opens in a new tab):

Nota: se você quiser usar a biblioteca Ethers.js, siga as instruções aqui (opens in a new tab).

npm install @alch/alchemy-web3

5. Instale o dotenv

Usaremos um arquivo .env para armazenar com segurança nossa chave de API e chave privada.

npm install dotenv --save

6. Crie o arquivo `.env`

Crie um arquivo .env no diretório do seu projeto e adicione o seguinte (substituindo “your-api-url" e "your-private-key")

Para encontrar a URL da sua API da Alchemy, navegue até a página de detalhes do aplicativo que você acabou de criar no seu painel, clique em “View Key” (Ver Chave) no canto superior direito e pegue a URL HTTP.
Para encontrar sua chave privada usando a MetaMask, confira este guia (opens in a new tab).

API_URL = "your-api-url"
PRIVATE_KEY = "your-private-key"

Não faça commit do .env! Certifique-se de nunca compartilhar ou expor seu arquivo .env com ninguém, pois você estará comprometendo seus segredos ao fazer isso. Se você estiver usando controle de versão, adicione seu .env a um arquivo gitignore.

7. Crie o arquivo `sendTx.js`

Ótimo, agora que temos nossos dados confidenciais protegidos em um arquivo .env, vamos começar a codificar. Para o nosso exemplo de envio de transação, enviaremos ETH de volta para o faucet da Sepolia.

Crie um arquivo sendTx.js, que é onde configuraremos e enviaremos nossa transação de exemplo, e adicione as seguintes linhas de código a ele:

async function main() {
    require('dotenv').config();
    const { API_URL, PRIVATE_KEY } = process.env;
    const { createAlchemyWeb3 } = require("@alch/alchemy-web3");
    const web3 = createAlchemyWeb3(API_URL);
    const myAddress = '0x610Ae88399fc1687FA7530Aac28eC2539c7d6d63' //TODO: substitua este endereço pelo seu próprio endereço público

    const nonce = await web3.eth.getTransactionCount(myAddress, 'latest'); // nonce começa a contar a partir de 0

    const transaction = {
     'to': '0x31B98D14007bDEe637298086988A0bBd31184523', // endereço do faucet para devolver eth
     'value': 1000000000000000000, // 1 ETH
     'gas': 30000,
     'nonce': nonce,
     // campo de dados opcional para enviar mensagem ou executar contrato inteligente
    };

    const signedTx = await web3.eth.accounts.signTransaction(transaction, PRIVATE_KEY);

    web3.eth.sendSignedTransaction(signedTx.rawTransaction, function(error, hash) {
    if (!error) {
      console.log("🎉 O hash da sua transação é: ", hash, "\n Verifique a Mempool da Alchemy para ver o status da sua transação!");
    } else {
      console.log("❗Algo deu errado ao enviar sua transação:", error)
    }
   });
}

main();

Certifique-se de substituir o endereço na linha 6 pelo seu próprio endereço público.

Agora, antes de começarmos a executar este código, vamos falar sobre alguns dos componentes aqui.

nonce : A especificação do nonce é usada para rastrear o número de transações enviadas do seu endereço. Precisamos disso por motivos de segurança e para evitar ataques de repetição (replay attacks) (opens in a new tab). Para obter o número de transações enviadas do seu endereço, usamos getTransactionCount (opens in a new tab).
transaction: O objeto da transação tem alguns aspectos que precisamos especificar
- to: Este é o endereço para o qual queremos enviar ETH. Neste caso, estamos enviando ETH de volta para o faucet da Sepolia (opens in a new tab) do qual solicitamos inicialmente.
- value: Este é o valor que desejamos enviar, especificado em Wei, onde 10^18 Wei = 1 ETH
- gas: Existem muitas maneiras de determinar a quantidade certa de gás a ser incluída em sua transação. A Alchemy tem até um webhook de preço do gás (opens in a new tab) para notificá-lo quando o preço do gás ficar dentro de um determinado limite. Para transações na Mainnet, é uma boa prática verificar um estimador de gás como o ETH Gas Station (opens in a new tab) para determinar a quantidade certa de gás a ser incluída. 21000 é a quantidade mínima de gás que uma operação na Ethereum usará, então, para garantir que nossa transação seja executada, colocamos 30000 aqui.
- nonce: veja a definição de nonce acima. O nonce começa a contar a partir de zero.
- [OPCIONAL] data: Usado para enviar informações adicionais com sua transferência ou chamar um contrato inteligente, não é necessário para transferências de saldo, confira a nota abaixo.
signedTx: Para assinar nosso objeto de transação, usaremos o método signTransaction com nossa PRIVATE_KEY
sendSignedTransaction: Assim que tivermos uma transação assinada, podemos enviá-la para ser incluída em um bloco subsequente usando sendSignedTransaction

Uma nota sobre dados (data) Existem dois tipos principais de transações que podem ser enviadas na Ethereum.

Transferência de saldo: Enviar ETH de um endereço para outro. Nenhum campo de dados é necessário; no entanto, se você quiser enviar informações adicionais junto com sua transação, você pode incluir essas informações no formato HEX neste campo.
- Por exemplo, digamos que queríamos escrever o hash de um documento IPFS na cadeia da Ethereum para dar a ele um carimbo de data/hora imutável. Nosso campo de dados deve então se parecer com data: web3.utils.toHex(‘IPFS hash‘). E agora qualquer pessoa pode consultar a cadeia e ver quando esse documento foi adicionado.
Transação de contrato inteligente: Executar algum código de contrato inteligente na cadeia. Neste caso, o campo de dados deve conter a função inteligente que você deseja executar, juntamente com quaisquer parâmetros.
- Para um exemplo prático, confira a Etapa 8 neste Tutorial Hello World (opens in a new tab).

8. Execute o código usando `node sendTx.js`

Navegue de volta para o seu terminal ou linha de comando e execute:

node sendTx.js

9. Veja sua transação na Mempool

Abra a página da Mempool (opens in a new tab) no seu painel da Alchemy e filtre pelo aplicativo que você criou para encontrar sua transação. É aqui que podemos observar a transição da nossa transação do estado pendente para o estado minerado (se for bem-sucedida) ou para o estado descartado (dropped) se não for bem-sucedida. Certifique-se de manter em “All” para que você capture as transações “mined” (mineradas), “pending” (pendentes) e “dropped” (descartadas). Você também pode pesquisar sua transação procurando por transações enviadas para o endereço 0x31b98d14007bdee637298086988a0bbd31184523 .

Para visualizar os detalhes da sua transação depois de encontrá-la, selecione o hash da transação (tx hash), o que deve levá-lo a uma visualização parecida com esta:

A partir daí, você pode visualizar sua transação no Etherscan clicando no ícone circulado em vermelho!

Iupiiii! Você acabou de enviar sua primeira transação na Ethereum usando a Alchemy 🎉

Para comentários e sugestões sobre este guia, envie uma mensagem para Elan no Discord (opens in a new tab) da Alchemy!

Originalmente publicado em https://docs.alchemyapi.io/tutorials/sending-transactions-using-web3-and-alchemy (opens in a new tab)

Última atualização da página: 3 de março de 2026

+16