TUTORIAL: creando tokens nativos en Cardano testnet (Linux)

5 min readJun 5, 2021

Guía en español para aprender a crear tokens usando cardano-node y Daedalus en la testnet.

Basado/inspirado en: Minting Native Tokens on Cardano Testnet

El libro mayor (ledger) de Cardano, posee la característica ‘Multi-activos’ (multi-asset) lo cual permite registrar transacciones en varios activos de forma nativa sin necesidad de smart contracts. Los activos que se pueden crear con esta característica en Cardano se llaman ‘tokens nativos’.

Con la actualización Mary lanzada en marzo de 2021, se habilitó esta funcionalidad, permitiendo la creación de 31787 tokens al momento de escribir este artículo (Dato: TokenTool).

Al final de este tutorial habrás aprendido a crear una transacción que acuñará un token en la testnet de Cardano con metadata.

Caso de uso

Para efectos de demostrar la utilidad y el potencial de los tokens nativos, en esta oportunidad acuñaremos un token que simulará la creación de un certificado de Denominación de Origen, según la propuesta hecha en nuestro artículo: Usando la blockchain Cardano para emitir certificados de Denominación de Origen en Venezuela.

Requisitos

Para ejecutar con éxito la acuñación del token deberás contar con:

Daedalus testnet sincronizada al 100%.
cardano-node 1.27.0 (lo instalé siguiendo esta guía).

Manos a la obra

Para poder hacer uso de la sincronización de Daedalus con la blockchain, guardaremos esta variable con la ruta del archivo cardano-node.socket (puede variar entre distribuciones de Linux):

export CARDANO_NODE_SOCKET_PATH=~/.local/share/Daedalus/testnet/cardano-node.socket

Vamos a crear una variable para almacenar el ID de la testnet, lo necesitaremos más adelante:

export TESTNET_ID=1097911063

Almacenemos también el nombre del token y la cantidad:

export TOKEN_NAME=DOC
export TOKEN_AMOUNT=1

Asegúrate de estar en un directorio en el que tengas permiso de escritura, lo mejor es crear uno nuevo para esta operación pues vamos a crear varios archivos y directorios relacionados con la transacción.

Con los siguiente comandos, crearemos un monedero desde el cual acuñaremos el token:

cardano-cli stake-address key-gen --verification-key-file stake.vkey --signing-key-file stake.skeycardano-cli address key-gen --verification-key-file payment.vkey --signing-key-file payment.skeycardano-cli address build --payment-verification-key-file payment.vkey --stake-verification-key-file stake.vkey --out-file payment.addr --testnet-magic $TESTNET_ID

Ahora, podrás encontrar la dirección de tu nuevo monedero en el archivo payment.addr, utiliza Daedalus para enviar algunas ADA de prueba a ese monedero.

¿Donde puedes adquirir ADA en testnet? En el faucet oficial: https://developers.cardano.org/en/testnets/cardano/tools/faucet/

Consultemos nuestro saldo a ver si cayó la transferencia:

cardano-cli query utxo --address $(< payment.addr) --testnet-magic $TESTNET_ID --mary-era

Deberás ver algo como esto:

Los montos son expresados en lovelace (0.000001 ADA)

Exportaremos los parámetros del protocolo, los necesitaremos para calcular la comisión de la transacción. Los guardaremos en un archivo llamado protocol.json:

cardano-cli query protocol-parameters --testnet-magic $TESTNET_ID --out-file protocol.json

La política de acuñación

Para crear nuestra política, vamos a crear un directorio:

mkdir policy

Ahora, crearemos las llaves que nos ayudarán a generar el policyID, parámetro indispensable para la creación de un token:

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

Crearemos ahora el archivo en el cual guardaremos el policy script:

touch policy/policy.script && echo "" > policy/policy.script

Ahora, el policy script más básico posible:

echo "{" >> policy/policy.script  echo "  \"keyHash\": \"$(cardano-cli address key-hash --payment-verification-key-file policy/policy.vkey)\"," >> policy/policy.script  echo "  \"type\": \"sig\"" >> policy/policy.script  echo "}" >> policy/policy.script

Acá la documentación sobre los policy scripts

Ya podemos generar nuestro policyID:

cardano-cli transaction policyid --script-file ./policy/policy.script >> policy/policyId

A continuación ya podemos crear nuestra transacción.

La transacción

La creación de un token consiste en la ejecución de una transacción de acuñación compuesta de:

Entrada (UXTO)
Salida (dirección y monto)
Información de acuñación (política y nombre del token)
Metadata

Comenzaremos con la metadata, que consiste en un archivo en formato JSON que llamaremos metadata.json. Por exigencia del protocolo, la raíz debe ser un número entero, el resto es la información de la D.O.C. o en tu caso lo que desees incluir:

Para preparar la entrada, consultaremos de nuevo el saldo de nuestro monedero y esta vez nos fijaremos en los datos que lo componen: TxHash (id de la transacción), TxIx (índice), Amount (monto en lovelace).

Guardemos esos datos en variables (en tu caso los valores serán distintos):

export TX_HASH=9bf9d1f58a0b49276c69a2075f19d93660c81af57851d1fcb1db3927
export TX_IX=0
export AVAILABLE_LOVELACE=2000000

Ahora construyamos la transacción en bruto, vamos a guardarla en un archivo llamado matx.raw:

cardano-cli transaction build-raw \
   --mary-era \
   --fee 0 \
   --tx-in $TX_HASH#$TX_IX \
   --tx-out $(< payment.addr)+$AVAILABLE_LOVELACE+"$TOKEN_AMOUNT $(< policy/policyId).$TOKEN_NAME" \
   --mint="$TOKEN_AMOUNT $(< policy/policyId).$TOKEN_NAME" \
   --metadata-json-file metadata.json \
   --out-file matx.raw

Luego, procedemos a calcular la tarifa. Este comando nos devolverá el monto en lovelace:

cardano-cli transaction calculate-min-fee \
   --tx-body-file matx.raw \
   --tx-in-count 1 \
   --tx-out-count 1 \
   --witness-count 1 \
   --testnet-magic $TESTNET_ID \
   --protocol-params-file protocol.json

Guardemos el monto de la tarifa en una variable (reemplaza el valor por el que te arrojó en tu consola):

export TX_FEE=176589

Ahora que tenemos la tarifa, volvamos a construir la transacción:

cardano-cli transaction build-raw \
   --mary-era \
   --fee $TX_FEE \
   --tx-in $TX_HASH#$TX_IX \
   --tx-out $(< payment.addr)+$(($AVAILABLE_LOVELACE - $TX_FEE))+"$TOKEN_AMOUNT $(< policy/policyId).$TOKEN_NAME" \
   --minting-script-file policy/policy.script \
   --mint="$TOKEN_AMOUNT $(< policy/policyId).$TOKEN_NAME" \
   --metadata-json-file metadata.json \
   --out-file matx.raw

Firmamos:

cardano-cli transaction sign \
   --signing-key-file payment.skey \
   --signing-key-file policy/policy.skey \
   --script-file policy/policy.script \
   --testnet-magic $TESTNET_ID \
   --tx-body-file matx.raw \
   --out-file matx.signed

Ya podemos enviar nuestra transacción a la blockchain:

cardano-cli transaction submit --tx-file  matx.signed --testnet-magic $TESTNET_ID

¡Listo!

Una vez que la transacción haya sido propagada y validada, podremos verla al consultar de nuevo nuestro saldo. Ya tienes en tu monedero el token creado, ahora la puedes enviar a tu monedero Daedalus testnet para que puedas visualizarlo.

Además, con el TxHash puedes también visualizar la transacción en el explorador de la tesnet: https://explorer.cardano-testnet.iohkdev.io/

Errores comunes

Puede que al enviar la transacción, te arroje algún error por algún parámetro mal colocado, en esta guía encontrarás los errores más comunes y su solución: Diagnosing transactions problems and troubleshooting.