Backend Helpers | Automation and Software Development for Cloud Applicationses

Creando Transacciones en Cardano

Cardano es una fuente pública, abierta, impulsada por la investigación plataforma blockchain descentralizada que utiliza prueba de participación algoritmo de consenso. En esta publicación, vamos a demostrar cómo crear una transacción en la red de prueba.

Ejecutar un nodo de Cardano en la red de prueba


Para enviar transacciones de creación, necesitará un nodo cardano en ejecución. demostramos en una publicación anterior cómo ejecutar un nodo cardano usando docker. También puedes consultar otras opciones para ejecutar tu desarrollo nodo en el curso de operadores de stake pools


Consultando la Red Cardano


cardano-cli es una aplicación que se instala como parte del nodo cardano. El primer paso que debemos hacer para usarlo es exportar elCARDANO_NODE_SOCKET_PATH y apunte al archivo del socket cardano, por ejemplo:



export CARDANO_NODE_SOCKET_PATH="/opt/cardano/db/node.socket"

El comando query tip consulta la cadena de bloques y devuelve información básica:


$cardano-cli query tip --testnet-magic 1

{
    "block": 897914,
    "epoch": 67,
    "era": "Babbage",
    "hash": "bfe59e384f3df28fb275d427ee13058c61d2e99194ca4ebe139f9817aff422bb",
    "slot": 27437634,
    "syncProgress": "100.00"
}

El parámetro --testnet-magic 1 indica que estamos consultando la testnet

Pares de claves y direcciones de Cardano Wallet

Los pares de claves de Cardano siguen el ed25519 que involucra una clave de verificación pública y una clave privada.Recuerde que las claves públicas se pueden compartir con cualquier persona, pero las claves privadas deben conservarse seguro y secreto

Las direcciones de billetera de Cardano tienen dos partes:

  • Dirección de pago: se utiliza para almacenar, recibir y enviar dinero
  • Dirección de participación: se utiliza para almacenar y retirar recompensas. También defino los parámetros del stake pool como la propiedad y las recompensas.

El siguiente comando creará un conjunto de pares de claves de pago que incluye una clave pública pago.vkey y una clave privada pago.skey 


cardano-cli address key-gen \
 --verification-key-file payment.vkey \
 --signing-key-file payment.skey

Podemos crear tantos pares de claves como queramos, el siguiente comando crea un segundo conjunto de claves que vamos a usar para demostrar cómo enviar ADA de una dirección a otra:


cardano-cli address key-gen \
 --verification-key-file payment2.vkey \
 --signing-key-file payment2.skey

El siguiente comando crea un conjunto de claves de staking:


cardano-cli stake-address key-gen     --verification-key-file stake.vkey     --signing-key-file stake.skey

Después de crear el conjunto de claves, podemos crear ahora dos direcciones de pago: una donde estamos va a depositar algunas ADA para probar marsopas y una segunda para demostrar cómo crear una transacción:


cardano-cli address build \
    --payment-verification-key-file payment.vkey \
    --stake-verification-key-file stake.vkey \
    --testnet-magic 1 \
    --out-file payment.addr

Utilizamos el segundo conjunto de claves para crear la segunda dirección de pago:


cardano-cli address build \
    --payment-verification-key-file payment2.vkey \
    --stake-verification-key-file stake2.vkey \
    --testnet-magic 1 \
    --out-file payment2.addr

Obtener algunas ADA para las pruebas

Puede solicitar algunos fondos desde el Grifo Testnets para crear transacciones en la red de prueba



Después de obtener sus ADA, puede consultar el saldo de su dirección:



    cardano-cli query utxo     --address $(cat payment.addr)     --testnet-magic 1

Verá un resultado que muestra el saldo de su dirección:


                           TxHash                                 TxIx        Amount
--------------------------------------------------------------------------------------
b7a4e98d6bc0758d7bfd2453712e89abb9c27cca5a77477c6ef890b06839c137     0        10000000000 lovelace + TxOutDatumNone

Crear una transacción

Cardano implementa elmodelo UXTO para registrar las transacciones en la cadena de bloques. Vamos a crear una transacción. para enviar 2 ADA desde la dirección 1 a la dirección 2. Los siguientes pasos son necesarios para para crear una transacción en la cadena de bloques:

  • Obtener los parámetros del protocolo
  • Calcular la tarifa
  • Defina el tiempo de vida (TTL) para la transacción
  • Crear la transacción
  • Firmar la transacción
  • Enviar la transacción

Paso 1: Obtener los parámetros del protocolo

El siguiente comando obtiene los parámetros para la red de prueba:


    cardano-cli query protocol-parameters \
    --testnet-magic 1 \
    --out-file protocol_test.json

Paso 2: Calcular la tarifa

Para calcular la tarifa, necesitamos crear un borrador de transacción primero. La transacción cardano-cli build-rawcrea una transacción sin procesar que usaremos como borrador para calcular La cuota. Este comando espera los siguientes parámetros:

  • --tx-in: Entrada de transacción con la sintaxis TxHash#TxIx donde TxHash es el hash de transacción y TxIx es el índice
  • --tx-out: salida de transacción. Cada transacción tiene al menos 2 salidas: la dirección que recibe la transacción y la dirección que recibe el cambio de la transacción

Los parámetros --invalid-hereafter y --fee pueden ser 0 para crear el borrador de la transaccción: 


cardano-cli transaction build-raw \
    --tx-in b7a4e98d6bc0758d7bfd2453712e89abb9c27cca5a77477c6ef890b06839c137#0 \
    --tx-out $(cat payment.addr)+0 \
    --tx-out $(cat payment2.addr)+0 \
    --invalid-hereafter 0 \
    --fee 0 \
    --out-file tx.draft

Después de generar el borrador, usamos el comando cardano-cli transaction calculate-min-fee para calcular la tarifa:


cardano-cli transaction calculate-min-fee \
    --tx-body-file tx.draft \
    --tx-in-count 1 \
    --tx-out-count 2 \
    --witness-count 1 \
    --byron-witness-count 0 \
    --testnet-magic 1 \
    --protocol-params-file protocol_test.json

El resultado del comando anterior es 176721 Lovelace. Con este valor ahora podemos calcular el cambio para devolverlo a payment.addr después de pagar la tarifa: 9997.8320350 ADA (todos los valores deben expresarse en Lovelace)


expr 10000000000 - 2000000 - 176721
9997823279

Paso 3: Definir el tiempo de vida (TTL) para la transacción

El TTL (Tiempo de vida) es el límite de altura de la ranura para que una transacción incluirse en un bloque. La transacción será cancelada si no es incluido en un bloque antes de este límite.TTL = ranura + N ranuras . Para consultar la ranura actual usamos el comando query tip:


cardano-cli query tip --testnet-magic 1
{
    "block": 897914,
    "epoch": 67,
    "era": "Babbage",
    "hash": "bfe59e384f3df28fb275d427ee13058c61d2e99194ca4ebe139f9817aff422bb",
    "slot": 27437634,
    "syncProgress": "100.00"
}

El comando query tip nos dijo que el espacio actual en ese momento era 27437634. Con esta información podemos calcular un TTL, por ejemplo, 500 ranuras en el futuro: 


expr 27437634 + 500
27438134

Paso 4: Construcción de la transacción

Usamos el comando cardano-cli build-raw para crear la transacción:


cardano-cli transaction build-raw \
    --tx-in b7a4e98d6bc0758d7bfd2453712e89abb9c27cca5a77477c6ef890b06839c137#0 \
    --tx-out $(cat payment2.addr)+2000000 \
    --tx-out $(cat payment.addr)+9997823279 \
    --invalid-hereafter 27438134 \
    --fee 176721 \
    --out-file tx.raw

Paso 5: Firmar la transacción

Usamos el comando cardano-cli transaction sign con la clave de firma payment.skey y guarde la transacción firmada en el archivo de salida tx.signed:


cardano-cli transaction sign \
    --tx-body-file tx.raw \
    --signing-key-file payment.skey \
    --testnet-magic 1 \
    --out-file tx.signed

Paso 6: Enviar la transacción

Finalmente, podemos usar el comando cardano-cli transaction submit para enviar la transacción a la cadena de bloques:


    cardano-cli transaction submit \
    --tx-file /root/transactions/tx.signed \
    --testnet-magic 1

Transaction successfully submitted.

Consulta el estado de la transacción

Puedes verificar si la transacción ha sido incluida en la cadena de bloques consultando el saldo de addr1 y addr2:


/cardano-cli query utxo \
    --address $(cat payment.addr) \
    --testnet-magic 1


                          TxHash                                 TxIx        Amount
--------------------------------------------------------------------------------------
daa4f16c9671989f4e79eb2b505e4435c8afcf73a24847c77bde733ae2edf63f     1        9997823279 lovelace + TxOutDatumNone


cardano-cli query utxo \
    --address $(cat payment2.addr) \
    --testnet-magic 1


                           TxHash                                 TxIx        Amount
--------------------------------------------------------------------------------------
daa4f16c9671989f4e79eb2b505e4435c8afcf73a24847c77bde733ae2edf63f     0        2000000 lovelace + TxOutDatumNone

Conclusión

Cardano se considera una cadena de bloques de tercera generación. Ofrece características muy interesantes como la Introducción de prueba de participación como algoritmo de consenso. En esta publicación aprendimos cómo crear transacciones en la red de prueba.

References

ENTRIES