Cómo enviar Ethereum con Node y Web3

Para enviar Ethereum de una billetera a otra, necesitamos tener las siguientes cosas en línea:

  1. Generando carteras de prueba Ethereum.
  2. Financiamiento de Ethereum en una billetera de prueba.
  3. Entorno de red de prueba de blockchain de Ethereum.
  4. Programa de transferencia de fondos.

Vamos a sumergirnos.

Paso 1: Generación de carteras de prueba de Ethereum

Ya hemos cubierto la generación de direcciones Ethereum en este artículo. Por favor revíselo una vez. Esperaré.

Suponiendo que tenga al menos dos direcciones Ethereum en el lugar, una para enviar y otra para recibir. Sigamos adelante.

Paso 2: Financiar Ethereum en una billetera de prueba

Para enviar Ethereum desde nuestra cuenta, primero debemos agregar algo de Ethereum de prueba en nuestra billetera. Esta prueba de Ethereum también se llama “Faucets” .

Visite este sitio web para obtener algunos Ethers de prueba.

Para solicitar fondos, primero debe publicar un tweet en Twitter que contenga su dirección de Ethereum y copiar / pegar el enlace del tweet en el sitio web que se muestra arriba.

Para generar un tweet, haga clic en este enlace y cambie la dirección hexadecimal a su dirección Ethereum.

Copie / pegue el enlace del tweet y elija la opción 3 Ethers / 8 hours en el sitio web.

Eso es todo. Recibirá 3 Ethers de prueba en su cuenta.

Paso 3: entorno de red de prueba de la cadena de bloques de Ethereum

Necesita una red de prueba Ethereum donde pueda registrar su transacción. Puede ejecutar una instancia de Ethereum local o utilizar servicios gratuitos como Infura . ¡Prefiero este último porque es realmente fácil y gratis!

Visite infura.io y cree su cuenta gratuita.

Una vez que se crea la cuenta, puede crear un nuevo proyecto.

Obtendrá el secreto y la identificación del proyecto. Manténlo seguro.

Programa para transferir fondos

Creemos nuestro programa.

Cree una nueva carpeta e inicialice el proyecto Node.

npm init –y

Instalemos las dependencias.

npm install –S web3@1.2.2 ethereumjs-tx@2.1.1 axios

Aquí está nuestro código.

const Web3 = require ( “web3” ) ;
const EthereumTx = require ( ‘ethereumjs-tx’ ) . Transacción ;
const axios = require ( ‘axios’ ) ;
const ethNetwork = ‘https://rinkeby.infura.io/v3/su identificación de proyecto’ ;
const web3 = nuevo Web3 ( nuevo Web3. proveedores . HttpProvider ( ethNetwork ) ) ;
 

asíncrono
función transferFund ( sendersData , recieverData , amountToSend ) {
    devolver nueva promesa ( asíncrono ( determinación , rechazar ) => {
        var nonce = Await web3. eth . getTransactionCount ( sendersData. dirección ) ;

        . web3
eth . getBalance ( . sendersData dirección , asíncrono ( err ,resultado ) => {
            if ( err ) {
                devolver rechazar ( ) ;
            }

            let balance
= web3. utils . fromWei ( resultado , “éter” ) ;

            consola.
log ( saldo + “ETH” ) ;
            if ( balance < amountToSend ) {

                consola.
log ( ‘fondos insuficientes’ ) ;
                volver rechazar ( ) ;
            }
   

            let gasPrices
= aguardar getCurrentGasPrices ( ) ;

            dejar detalles
= {
                “a” : recieverData. dirección ,
                “valor” : web3. utils . toHex ( web3. utils . toWei ( amountToSend. toString ( ) , ‘ether’ ) ) ,
                “gas” : 21000 ,
                “gasPrice” :gasPrices. bajo * 1000000000 ,
                “nonce” : nonce ,
                “chainId” : 4 // EIP 155 chainId – mainnet: 1, rinkeby: 4
            } ; transacción
           
            constante = nuevo EthereumTx ( detalles , { cadena : ‘rinkeby’ } ) ;

            deje privateKey
= sendersData. privateKey . dividir ( ‘0x’ ) ;

            let privKey
= Buffer. de (privateKey [ 1 ] , ‘hex’ ) ;

            transacción.
sign ( privKey ) ;
           
            const serializedTransaction = transacción. serializar ( ) ;
           

            web3.
eth . sendSignedTransaction ( ‘0x’ + serializedTransaction. toString ( ‘hex’ ) , ( err , id ) => {
                if ( err ) {

                    consola.
log ( err ) ;
                    volver rechazar ( ) ;
                }
                const url = `https : //rinkeby.etherscan.io/tx / $ {id}`;

                consola.
log ( url ) ;

                resolver
( { id : id , link : url } ) ;
            } ) ;
        } ) ;
    } ) ;
} función


asíncrona
getCurrentGasPrices ( ) {

    dejar respuesta
= esperar axios. get ( ‘https://ethgasstation.info/json/ethgasAPI.json’ ) ;

    deje precios
= {

      bajo
: respuesta. datos . safeLow / 10 ,

      medio
: respuesta. datos . media / 10 ,

      alta
: respuesta. datos . rápido / 10
    } ; precios de
    devolución ;
} función


asíncrona
getBalance ( dirección ) { devolver nueva promesa ( ( resolver , rechazar ) => {
        web3.
eth . getBalance ( dirección , async ( err , resultado ) => { if ( err ) { devolver rechazar ( err ) ; }
            resolver
( web3. utils .

   

           
               
           
fromWei ( resultado , “éter” ) ) ;
        } ) ;
    } ) ;
}


transferFund
( { dirección : ‘0x0xxx00000000xx00x0’ , privateKey : ‘1×11111111’ } , { dirección : ‘0x0xxx000000000000x00x0x0’ } , 0.10 )

Reemplace las direcciones en la última línea del código por su propia dirección. Después de ejecutar el código, la URL de la transacción rinkeby se imprimirá en la pantalla.

Entendamos el código.

Primero, hicimos una conexión a nuestra cadena de bloques Ethereum testnet proporcionada por Infura.

const ethNetwork = ‘https://rinkeby.infura.io/v3/su identificación de proyecto’;

const web3 = new Web3 (nuevo Web3.providers.HttpProvider (ethNetwork))

Luego, en la función principal, primero estamos verificando si el saldo del remitente no es menor que la cantidad que se pretende enviar.

Luego, obtenemos los precios actuales de la gasolina que se requieren para transferir Ethereum. Estamos utilizando una API de terceros para este propósito.

Finalmente, estamos preparando la carga útil de la transacción.

dejar detalles = {
    “a” : recieverData. dirección ,
    “valor” : web3. utils . toHex ( web3. utils . toWei ( amountToSend. toString ( ) , ‘ether’ ) ) ,
    “gas” : 21000 ,
    “gasPrice” : gasPrices. bajo * 1000000000 ,
    “nonce” : nonce ,
    “chainId” : 4 // EIP 155 chainId – mainnet: 1,
} ;

Hemos especificado la dirección del receptor en la carga útil de la transacción.

Ahora, firmemos la transacción con la clave privada del remitente.

transacción constante = nuevo EthereumTx (detalles, {cadena: ‘rinkeby’});

dejar privateKey = sendersData.privateKey.split (‘0x’);
// importante


let privKey = Buffer.from (privateKey [1], ‘hex’);


transaction.sign (privKey);


const serializedTransaction = transaction.serialize ();

En la última función, estamos enviando la transacción serializada a nuestra cadena de bloques. Si todo está bien, recibirá un ID de transacción y una URL de rinkeby para rastrear el estado de extracción de la transacción.

Eso es todo. Acaba de enviar el Ethereum a otra dirección.

Conclusión

Ethereum es realmente popular debido a su amplio soporte para desarrolladores y API para crear aplicaciones que se ejecutan en la plataforma blockchain. En este tutorial, realizamos una sencilla aplicación que realiza la transferencia de Ethereum de una cuenta a otra. Es un script simple escrito en JavaScript. Espero que tengas una idea general de cómo desarrollar aplicaciones que se ejecutan en la red blockchain.

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *