Enviar transacciones usando la Web3

Esta es un guia apta para principiantes sobre cómo enviar transacciones de Ethereum usando la Web3. Hay tres pasos esenciales para enviar una transacción a la cadena de bloques de Ethereum, que son: crear, firmar y emitir. Explicaremos los tres pasos y esperamos responder a cualquier duda que puedas tener. En este tutorial, usaremos Alchemy(opens in a new tab) para enviar nuestras transacciones a la red de Ethereum. Puede crear una cuenta de Alchemy aquí(opens in a new tab).

NOTA: Esta guía es para firmar sus transacciones en el backend para su aplicación. Si quiere integrar la firma de sus transacciones en el frontend, consulteIntegrar Web3 con un proveedor de navegador(opens in a new tab).

Los fundamentos

Como la mayoría de desarrolladores de cadena de bloques cuando comienzan, es posible que haya indagado sobre cómo enviar una transacción (algo que debería ser muy sencillo) y que se haya topado con una gran cantidad de guías, cada una de ellas diciendo cosas diferentes, que le dejan a uno un poco aturdido y confundido. Por lo tanto, si se encuentra en esa situación, no desespere. ¡Todos lo hemos pasado por ello en algún momento! Así que, antes de comenzar, aclaremos algunos puntos:

1.Alchemy no almacena sus claves privadas

• Esto significa que Alchemy no puede firmar ni enviar transacciones en su nombre. Es así por motivos de seguridad. Alchemy nunca le pedirá que comparta su clave privada, ni tampoco debería compartir nunca su clave privada con un nodo alojado (ni con nadie).
• Puede leer desde la cadena de bloques usando la API del nucleo de Alchemy, pero para escribirlo, necesitará usar algo más para firmar sus transacciones antes de enviarlas mediante Alchemy (esto es lo mismo para cualquier otro servicio de nodo).

2.¿Qué es un «signatario»?

• Los firmantes firmarán las transacciones por usted con su clave privada. En este tutorial, nosotros usaremos Alchemy Web3(opens in a new tab) para firmar nuestra transacción, aunque también puede usar cualquier otra biblioteca Web 3.
• En el frontend, un buen ejemplo de firmante sería MetaMask(opens in a new tab), que firmará y enviará las transacciones en su nombre.

3.¿Por qué tengo que firmar mis transacciones?

• Todo usuario que quiera enviar una transacción en la red Ethereum debe firmarla (utilizando su clave privada), para validar que la transacción proviene de quien afirma proceder.
• Es sumamente importante proteger esta clave privada, ya que tener acceso a ella otorga el control absoluto de su cuenta de Ethereum y le permite a usted (o a cualquier persona con acceso) realizar transacciones en su nombre.

4.¿Cómo puedo proteger mi clave privada?

• Hay muchas formas de proteger tu clave privada y de utilizarla para enviar transacciones. En este tutorial utilizaremos un archivo .env. Sin embargo, también puede utilizar un proveedor independiente que almacene claves privadas, utilizar un banco de claves u otras opciones.

5. ¿Cuál es la diferencia entre eth_sendTransaction y eth_sendRawTransaction?

eth_sendTransaction y eth_sendRawTransaction son funciones de la API de Ethereum que emiten una transacción en la red de Ethereum para que se añada a un nuevo bloque. Se diferencian en cómo gestionan la firma de las transacciones.

• eth_sendTransaction(opens in a new tab) se utiliza para enviar transacciones sin firmar, lo que significa que el nodo al que se envía debe gestionar su clave privada para que pueda firmar la transacción antes de difundirla en la cadena. Dado que Alchemy no almacena las claves privadas de los usuarios, no utilizamos este método.
• eth_sendRawTransaction(opens in a new tab) se utiliza para emitir las transacciones que ya han sido firmadas. Esto significa que primero debes usar signTransaction(tx, private_key)(opens in a new tab), y luego enviar el resultado a eth_sendRawTransaction.

Cuando se utiliza web3, se puede acceder a eth_sendRawTransaction a través de la función web3.eth.sendSignedTransaction(opens in a new tab).

Esto es lo que vamos a usar en este tutorial.

6.¿Qué es la biblioteca Web3?

• Web3.js es una biblioteca de «wrappers» o programas que rodean las funciones estándar JSON-RPC que son muy comunes en el desarrollo de Ethereum.
• Hay muchas blibiotecas en Web3 para diferentes lenguajes. En este tutorial usaremos Alchemy Web3(opens in a new tab) que está desarrollado en JavaScript. Puede consultar aquí(opens in a new tab) otras opciones, como ethers.js(opens in a new tab).

Bien, ahora que ya hemos resuelto algunas de estas dudas, comencemos con el tutorial. ¡No dude preguntar sus dudas en cualquier momento a través del canal discord(opens in a new tab) de Alchemy!

7. ¿Cómo enviar transacciones seguras, privadas y con gas optimizado? {how-to-send-secure-gas-optimized-and-private-transactions}

• Alchemy tiene un conjunto de API para transacciones(opens in a new tab). Puede usarlas para enviar transacciones reforzadas, simular transacciones antes de que ocurran, enviar transacciones privadas y transacciones con gas optimizado.
• También puede utilizar la API de Notify(opens in a new tab) para recibir alertas cuando su transacción se toma desde la zona de espera y se añade a la cadena.

NOTA: Para consultar esta guía, debe tener una cuenta de Alchemy, una dirección de Ethereum o una cartera MetaMask, NodeJs, y npm instaladas. De lo contrario, siga estos pasos:

1. Cree una cuenta gratuita de Alchemy(opens in a new tab)
2. Crea una cuenta de Metamask(opens in a new tab) (u obtenga una dirección de Ethereum)
3. Siga estos pasos para instalar NodeJs y NPM(opens in a new tab)

Pasos para enviar su transacción

1.Crea una aplicación de Alchemy en la red de pruebas de Sepolia

Vaya a su panel de control de Alchemy(opens in a new tab) y cree una nueva aplicación, seleccionando Sepolia (u otra red de pruebas) para su red.

2.Solicitar ETH desde un grifo Sepolia

Sigue las instrucciones en el faucet (o grifo) Sepolia de Alchemy(opens in a new tab) para recibir ETH. Asegúrese de incluir su dirección Ethereum de Sepolia (desde MetaMask) y no otra red. Después de seguir las indicaciones, compruebe dos veces que ha recibido los ETH en su cartera.

3. Crea un nuevo directorio de proyecto y cden él

Cree un nuevo directorio de proyecto desde la ventana de comandos (terminal para macs) y navega hasta ella:

1mkdir sendtx-example
2cd sendtx-example

4.Instale Alchemy Web3 (o cualquier biblioteca en Web3)

Ejecute el siguiente comando en el directorio del proyecto que instalará Alchemy Web3(opens in a new tab):

Observe que si quiere utilizar la biblioteca de ethers.js, debe seguir estas instrucciones(opens in a new tab).

1npm install @alch/alchemy-web3

5.Instala dotenv

Utilizaremos un archivo .env para almacenar de manera segura nuestra clave API y clave privada.

1npm install dotenv --save

6. Cree el archivo .env

Cree un archivo .env en el directorio de su proyecto y añada lo siguiente (sustituyendo "your-api-url" y "your-private-key")

• Para encontrar la URL de la API de Alchemy, vaya a la página de información de la aplicación que acaba de crear en su panel de control, haga clic en «Ver clave» en la esquina superior derecha y obtenga la URL HTTP.
• Para encontrar su clave privada utilizando Metamask, consulte esta guía(opens in a new tab).

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

7. Cree el archivo sendTx.js

Vale, ahora que su información confidencial ya está protegida en un archivo .env, iniciemos la programación. Para nuestro ejemplo de envío de transacción, enviaremos ETH de vuelta al grifo Sepolia.

Cree un archivo sendTx.js, que es donde configuraremos y enviaremos nuestra transacción de muestra, y añádale las siguientes líneas de código:

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: replace this address with your own public address
7
8    const nonce = await web3.eth.getTransactionCount(myAddress, 'latest'); // nonce starts counting from 0
9
10    const transaction = {
11     'to': '0x31B98D14007bDEe637298086988A0bBd31184523', // faucet address to return eth
12     'value': 1000000000000000000, // 1 ETH
13     'gas': 30000,
14     'nonce': nonce,
15     // optional data field to send message or execute smart contract
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("🎉 The hash of your transaction is: ", hash, "\n Check Alchemy's Mempool to view the status of your transaction!");
23    } else {
24      console.log("❗Something went wrong while submitting your transaction:", error)
25    }
26   });
27}
28
29main();
Mostrar todo

Asegúrese de reemplazar la dirección en la línea 6 por su propia dirección pública.

Ahora, antes de pasar a la ejecución de este código, hablaremos sobre algunos de los componentes.

• nonce: la especificación del nonce se utiliza para hacer un seguimiento del número de transacciones enviadas desde su dirección. La necesitamos por motivos de seguridad y para evitar ataques repetitivos(opens in a new tab). Para conocer el número de transacciones enviadas desde su dirección, utilizamos getTransactionCount(opens in a new tab).
• transaction: la transacción tiene algunos aspectos que debemos especificar.
  • to: Es la dirección a la que queremos enviar ETH. En este caso, estamos enviando ETH de regreso al grifo Sepolia(opens in a new tab) al que inicialmente le solicitamos.
  • value: Esta es la cantidad que deseamos enviar, especificada en Wei, donde 10^18 Wei = 1 ETH
  • gas: hay numerosas formas de determinar la cantidad correcta de gas que se debe incluir en la transacción. Incluso, Alchemy tiene un webhook del precio de del gas(opens in a new tab) que informa cuando el precio del gas se encuentra dentro de un límite determinado. Una buena práctica para transacciones en la red principal consiste en consultar una calculadora de gas como ETH Gas Station(opens in a new tab) para determinar la cantidad correcta de gas por añadir. La cantidad mínima de gas que utiliza una operación en Ethereum es de 21.000; por tanto, y para asegurarnos de que nuestra transacción se ejecute, añadiremos 30.000.
  • nonce: consulte la definición anteriormente mencionada. Nonce empieza a contar desde cero.
  • [OPTIONAL] datos: utilizado para enviar información adicional con su transferencia, o para activar un contrato inteligente ―no requerido para transferencias de saldo― consulte la nota de abajo.
• signedTx: para firmar nuestro objeto de transacción utilizaremos el método signTransaction con nuestra PRIVATE_KEY
• sendSignedTransaction: una vez que tenemos una transacción firmada, podemos enviarla para que se incluya en un bloque posterior utilizando sendSignedTransaction

Una nota sobre los datos Hay dos tipos principales de transacciones que se pueden enviar en Ethereum.

• Transferencia de saldo: enviar ETC de una dirección a otra. No se requiere ningún campo de datos, sin embargo, si desea enviar información adicional junto a su transacción, puede incluir esa información en formato HEX en este campo.
  • Por ejemplo, digamos que queremos escribir el hash de un documento IPFS a la cadena de Ethereum para darle una fecha y hora inmutable. Nuestro campo de datos debe mostrarse como datos: web3.utils.toHex(‘IPFS hash‘). Ahora cualquiera puede consultar la cadena y ver cuándo se añadió el documento.
• Transacción de contrato inteligente: ejecute algún código de contrato inteligente en la cadena. En este caso, el campo de datos debería tener la función inteligente que desee ejecutar, junto a cualquier parámetro.
  • Para un ejemplo práctico, consulte el paso 8 en este Tutorial abierto a todos los públicos(opens in a new tab).

8. Ejecuta el código usando node sendTx.js

Navegue hasta la terminal o línea de comandos y ejecute:

1node sendTx.js

9.Consulta tu transacción en el Mempool

Abra la página de la Zona de espera(opens in a new tab) en su panel de control de Alchemy y filtre la aplicación que creó para encontrar su transacción. Aquí es donde podemos ver la transición de nuestra transacción desde un estado pendiente a un estado acuñado (si tiene éxito) o a un estado descartado si no tiene éxito. Asegúrese de conservarlo en «Todos» para reflejar las transacciones «acuñadas», «pendientes» y «descartadas». También puede buscar su transacción por transacciones enviadas a la dirección 0x31b98d14007bdee637298086988a0bbd31184523 .

Para ver los detalles de su transacción una vez que la haya encontrado, seleccione el hash de tx, que debería llevarle a una pantalla parecida a esta:

Aquí puede ver su transacción en Etherscan pulsando el icono dentro de un círculo rojo.

¡Enhorabuena! Acabas de realizar tu primera transacción en Ethereum con Alchemy 🎉

Si desea ver comentarios y sugerencias sobre esta guía, envíe un mensaje a Elan en el canal Discord(opens in a new tab) de Alchemy.

Publicado originalmente en https://docs.alchemyapi.io/tutorials/sending-transactions-using-web3-and-alchemy(opens in a new tab)