Pular para o conteúdo principal

Enviando transações usando Web3

transações
web3.js
Alchemy
Iniciante
Elan Halpern
4 de novembro de 2020
10 minutos de leitura

Este é um guia amigável para iniciantes para enviar transações do Ethereum usando Web3. Existem três etapas principais para enviar uma transação para a blockchain Ethereum: criar, assinar e transmitir. Analisaremos todas as três, esperando 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 Ethereum. Você pode criar uma conta gratuita da 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 do Web3 com um provedor de navegador (opens in a new tab).

O Básico

Como a maioria dos desenvolvedores de blockchain quando começam, você pode ter pesquisado 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 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. Isso ocorre por motivos 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).
  • 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 (o mesmo vale para qualquer outro serviço de nó).

2. O que é um “assinador”?

  • Assinadores assinarão transações para você usando sua chave privada. Neste tutorial, usaremos o Alchemy web3 (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 um assinador seria o 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 queira 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 ela afirma ser.
  • É super importante proteger esta 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 eu protejo minha chave privada?

  • Há 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 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 do 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.

Ao usar 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?

Ok, agora que esclarecemos algumas dessas questões, vamos 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, com gás otimizado e privadas?

NOTA: Este guia requer uma conta Alchemy, um endereço Ethereum ou carteira MetaMask, NodeJs e npm instalados. Caso contrário, siga estas etapas:

  1. Crie uma conta gratuita da Alchemy (opens in a new tab)
  2. Crie uma conta MetaMask (opens in a new tab) (ou obtenha um endereço Ethereum)
  3. Siga estes passos 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) como sua rede.

2. Solicite ETH do faucet da Sepolia

Siga as instruções no faucet 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. Após seguir as instruções, verifique novamente se você recebeu o ETH em sua carteira.

3. Crie um novo diretório de projeto e entre nele com cd

Crie um novo diretório de projeto na linha de comando (terminal para Macs) e navegue para dentro dele:

1mkdir sendtx-example
2cd sendtx-example

4. Instale o Alchemy Web3 (ou qualquer biblioteca web3)

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

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

1npm install @alch/alchemy-web3

5. Instale o dotenv

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

1npm install dotenv --save

6. Crie o arquivo .env

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

  • Para encontrar sua URL da API da Alchemy, navegue até a página de detalhes do aplicativo que você acabou de criar em seu painel, clique em “Ver Chave” no canto superior direito e pegue a URL HTTP.
  • Para encontrar sua chave privada usando o MetaMask, confira este guia (opens in a new tab).
1API_URL = "your-api-url"
2PRIVATE_KEY = "your-private-key"

7. Crie o arquivo sendTx.js

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

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

1async function main() {
2    require('dotenv').config();
3    const { API_URL, PRIVATE_KEY } = process.env;
4    const { createAlchemyWeb3 } = require("@alch/alchemy-web3");
5    const web3 = createAlchemyWeb3(API_URL);
6    const myAddress = '0x610Ae88399fc1687FA7530Aac28eC2539c7d6d63' //TODO: substitua este endereço pelo seu próprio endereço público
7
8    const nonce = await web3.eth.getTransactionCount(myAddress, 'latest'); // o nonce começa a contagem em 0
9
10    const transaction = {
11     'to': '0x31B98D14007bDEe637298086988A0bBd31184523', // endereço do faucet para devolver o ETH
12     'value': 1000000000000000000, // 1 ETH
13     'gas': 30000,
14     'nonce': nonce,
15     // campo de dados opcional para enviar mensagem ou executar contrato inteligente
16    };
17
18    const signedTx = await web3.eth.accounts.signTransaction(transaction, PRIVATE_KEY);
19
20    web3.eth.sendSignedTransaction(signedTx.rawTransaction, function(error, hash) {
21    if (!error) {
22      console.log("🎉 O hash da sua transação é: ", hash, "\n Verifique a Mempool da Alchemy para ver o status da sua transação!");
23    } else {
24      console.log("❗Algo deu errado ao enviar sua transação:", error)
25    }
26   });
27}
28
29main();
Exibir tudo

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

Agora, antes de executarmos 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 para fins 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: Esta é a quantia que desejamos enviar, especificada em Wei, onde 10^18 Wei = 1 ETH
    • gas: Há 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 de gás (opens in a new tab) para notificá-lo quando o preço do gás cair para dentro de um certo limite. Para transações na Mainnet, é uma boa prática verificar um estimador de gás como a ETH Gas Station (opens in a new tab) para determinar a quantidade certa de gás a incluir. 21000 é a quantidade mínima de gás que uma operação no Ethereum usará; portanto, para garantir que nossa transação seja executada, colocamos 30000 aqui.
    • nonce: veja a definição de nonce acima. A contagem do Nonce começa do zero.
    • [OPCIONAL] data: Usado para enviar informações adicionais com sua transferência, ou para 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: Depois que tivermos uma transação assinada, podemos enviá-la para ser incluída em um bloco subsequente usando sendSignedTransaction

Uma observação sobre dados Existem dois tipos principais de transações que podem ser enviadas no Ethereum.

  • Transferência de saldo: Envie 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, poderá incluir essas informações no formato HEX neste campo.
    • Por exemplo, digamos que quiséssemos escrever o hash de um documento IPFS na blockchain Ethereum para dar a ele um carimbo de data/hora (timestamp) imutável. Nosso campo de dados ficaria então como: web3.utils.toHex(‘hash IPFS‘). E agora qualquer pessoa pode consultar a cadeia e ver quando esse documento foi adicionado.
  • Transação de contrato inteligente: Execute 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.

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

Volte para o seu terminal ou linha de comando e execute:

1node sendTx.js

9. Veja sua transação na Mempool

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

Para ver os detalhes da sua transação assim que a encontrar, selecione o hash da tx, que o levará a uma visualização como esta:

Captura de tela do observador da Mempool

De lá, você pode visualizar sua transação no Etherscan clicando no ícone circulado em vermelho!

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

Para feedback 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: 18 de dezembro de 2025

litvintechl (opens in a new tab)
JoeChenJJ (opens in a new tab)
pettinaripp (opens in a new tab)
+16

Este tutorial foi útil?