Cómo construir Dapps en la blockchain de Cardano

Esta es una traducción del artículo de Chidume Nnamdi hecha por Héctor Botero. Puedes ver el artículo original haciendo click aquí

La blockchain de Cardano es una de las blockchains con mayor crecimiento rápido y la más usada en el 2022. La blockchain de Cardano es una plataforma de blockchain de tercera generación, con prueba de apuesta (Proof-of-Stake), y hogar de la criptomoneda ADA.

En este tutorial, les mostraremos cómo construir una DApp en el blockchain Cardano. Cubriremos lo siguiente:

• ¿Qué es Cardano?
• ¿Qué es una blockchain?
• ¿Qué son las DApps?
• ¿Qué es ADA?
• Cardano y sus tokens nativos
• ¿Qué es Plutus?
• Escribir contratos inteligentes usando Plutus
• Ejemplo: escribir una aplicación “¡Hola Mundo!” en Plutus
• Ejemplo: sayInput

¡Comencemos!

¿Qué es Cardano?

La blockchain de Cardano es una nueva blockchain basada en el consenso del algoritmo Shelley. Está diseñada para que sea una plataforma segura, escalable y fácil de usar, para construir y ejecutar aplicaciones descentralizadas.

Shelley es una pila de software que provee capas de abstracción sobre las blockchains subyacentes.

¿Qué es un blockchain?

Una blockchain es una base de datos distribuida en registros, unida por una serie de pruebas criptográficas. Los registros son llamados bloques. Las cadenas de bloques (blockchains) son una colección de bloques.

Ethereum es una blockchain que está basada en Ethereum Virtual Machine. Para hacer transacciones en la blockchain de Ethereum, debemos gastar algunos Ethers. Esta es una criptomoneda que es usada para pagar el gas en la red.

Así mismo, en la blockchain de Cardano, usaremos ADA para pagar las tarifas de gas.

¿Qué son las Dapps?

Una aplicación descentralizada y distribuida es una aplicación que no está controlada por un solo ente. De lo contrario, una DApp es como una aplicación convencional. Una DApp puede ser una aplicación web, una aplicación de líneas de comandos, una aplicación desktop o móvil.

La diferencia entre una DApp y una aplicación convencional, es que la aplicación convencional está controlada por un solo ente. Una DApp tiene al blockchain como su backend.

Por ejemplo, una aplicación de tareas hechas en React puede que tenga su información (las tareas) almacenadas en la blockchain de Ethereum. O, puedes construir un sistema de votaciones en Angular y tener los datos almacenados en la blockchain de Cardano.

¿Qué es ADA?

Como mencioné arriba, ADA es la criptomoneda nativa de la blockchain de Cardano. Puedes usar y transferir ADA en la blockchain de Cardano, tal cual como lo harías con los ETH en la blockchain de Ethereum.

ADA puede ser como criptomoneda y como un token. Esto quiere decir que, ADA siendo usada como la moneda nativa de Cardano, significa que:

• Es aceptada para pagar tarifas
• Es aceptada para hacer depósitos
• Es la única moneda en la cual, las recompensas son distribuidas

Así como los ETH están divididos en denominaciones (por ejemplo, Wei), ADA también tiene denominaciones. Lovelace es la menor unidad de ADA: 1 ADA es igual a 10^(-18) Lovelace, el cual puede ser dividido en un total de 1.000.000 Lovelace.

Cardano y los tokens nativos

La blockchain de Cardano hace que sea posible construir tokens nativos. Estos tokens, pueden ser usados para representar un valor e intercambiarlos en la blockchain de Cardano

Los tokens pueden ser fungibles o no fungibles. Los tokens fungibles representan valor mientras que, los tokens no fungibles representan ítems del mundo real (por ejemplo, un carro o una pieza de arte).

En las siguientes secciones, te enseñaremos cómo escribir y crear contratos inteligentes en la blockchain de Cardano, usando el lenguaje de programación Plutus.

¿Qué es Plutus?

Plutus es un lenguaje de programación usado para escribir lenguajes inteligentes en la blockchain de Cardano. Otros lenguajes de programación que puedes usar en vez de la blockchain de Cardano incluyen: Glow lang, Marlowe, etc. Plutus es el más rápido de entre ellos.

Plutus está basado en Haskell, así que usarlo requiere conocimiento previo de programación en Haskell.

Escribiendo contratos inteligentes usando Plutus

Vamos a mostrarte cómo escribir contratos inteligentes usando el lenguaje de programación Plutus. Estas aplicaciones pueden ejecutarse fuera de la cadena y manejar instancias de contratos inteligentes.

De acuerdo con Cardano Testnets, los contratos de Plutus consisten de partes que se ejecutan en la blockchain (con código en la cadena) y partes que se ejecutan en la máquina del usuario (fuera de la cadena o código cliente). Escribiremos nuestros contratos inteligentes en un editor en línea y simulador de Plutus.

Un contrato inteligente de Plutus es un código de Haskell que se ejecuta en la cartera del usuario y envía códigos a la blockchain para que sean ejecutados por los nodos en la blockchain. Los contratos inteligentes son ejecutados en la blockchain, no en la máquina del usuario.

Los contratos inteligentes de Plutus tienen definiciones que son usados para definir el contrato inteligente y su estado. Dentro de estas definiciones están los endpoints los cuales, definen el comportamiento del contrato inteligente. Estos endpoints son funciones que son ejecutadas por la cartera. Son conocidas como funciones fuera de la cadena y son usadas para construir transacciones y enviarlas al blockchain.

Ejemplo: escribir una aplicación “¡Hola Mundo! en Plutus”

Vamos a escribir una DApp sencilla en la blockchain de Cardano, usando el idioma de programación de Plutus.

Más artículos increíbles de LogRocket:

• No te pierdas ni un momento con The Replay, un boletín informativo de LogRocket
• Aprende cómo el Galileo de LogRocket corta entre el ruedo para, proactivamente, resolver los problemas en tu aplicación
• Usa React de useEffect para optimizar el desempeño de tu aplicación
• Intercambia entre múltiples versiones de Node
• Descubre cómo animar tu aplicación React con AnimXYZ
• Explora Tauri, un nuevo framework para construir binarios
• Compara NestJS vs Express.js

Escribiremos un contrato inteligente que estampará “¡Hola Mundo!” a la consola.

Abre el editor en línea y simulador Plutus:

import Data.Text qualified as T
import Playground.Contract
import Plutus.Contract
import PlutusTx.Prelude
import Prelude qualified as Haskell

-- | A 'Contract' that logs a message.
hello :: Contract () EmptySchema T.Text ()
hello = logInfo @Haskell.String "Hello, world"

endpoints :: Contract () EmptySchema T.Text ()
endpoints = hello

type DummySchema = Endpoint "dummy" ()

mkSchemaDefinitions ''DummySchema

$(mkKnownCurrencies [])

Lo que acabamos de mostrar ya puede ser poblado por nosotros. Vamos a ir a través del código:

import Data.Text qualified as T
import Playground.Contract
import Plutus.Contract
import PlutusTx.Prelude
import Prelude qualified as Haskell

Aquí, importamos las bibliotecas y construir las funciones que necesitaremos:

• La biblioteca Data.Text es usada para convertir hilos a textos
• El Playground.Contract importa la interfaz del contrato inteligente, definida en playground.
• La biblioteca Plutus.Contract es usada para definir los contratos inteligentes de la biblioteca central de Plutus
• La biblioteca PlutusTx.Prelude reemplaza la biblioteca Haskell Prelude normal e incluye funciones que son refinadas y más fáciles para compilar, por el compilador PlutusTx.

hello :: Contract () EmptySchema T.Text ()
hello = logInfo @Haskell.String "Hello, world"

El código de arriba, define la función hello. El Contract () EmptySchema T.Text () le dice al compilador que la función regresará sin nada. La función logInfo es una función que ya viene incluida, que da un mensaje a la consola. Resumiendo, la función `hello dará un mensaje Hello, world a la consola.

endpoints :: Contract () EmptySchema T.Text ()
endpoints = hello

Esto crea una función `endpoints`, el cual será usado para ejecutar la función `hello`. Esto expone a la función `hello` en la blockchain.

~~~
type DummySchema = Endpoint "dummy" ()

mkSchemaDefinitions ''DummySchema

$(mkKnownCurrencies [])

Esto crea el tipo DummySchema el cual, es usado para definir el estado del contrato inteligente. Finalmente, expone los endpoints al blockchain.

En nuestro playground Plutus, podemos hacer click en el botón verde Compile para compilar nuestros contratos. El botón azul Simulate abrirá una página donde podemos ejecutar los contratos inteligentes en la blockchain.

Haz click en el botón verde Compile. Luego de una compilación exitosa, el botón azul Simulate abrirá una página donde puedes ejecutar los contratos inteligentes de la blockchain:

Te darás cuenta que tenemos dos carteras, cada una con un balance abierto de 100 Lovelace. La Available functions de cada cartera te mostrará las funciones que están disponibles para ser usadas.

En nuestro caso, vemos nuestra función hello y la otra función Pay to Wallet. La función Pay to Wallet es usada para enviar fondos a otra cartera y, es definida por el contrato de Plutus. No vamos a poder el código ya que está añadido ahí cuando importemos los módulos debajo:

import Playground.Contract
import Plutus.Contract{% raw %}

Si vemos en la parte de abajo de la página, vemos una sección de Actions. Esta sección es donde las funciones que queremos que se ejecuten, son añadidas cuando le hacemos click a las direcciones de la carta de la cartera.

Ya tenemos una carta de Actions, la carta simula un retraso en la blockchain. Podemos remover esta carta haciendo click en el ícono X.

Ahora, hacemos click en el botón dummy y verás una carta aparecer en la sección Actions:

Hacemos click en el botón verde de Evaluate y verás que la función hello se ejecuta en la cadena. Luego de un tiempo, la página Transactions aparecerá:

Ve abajo, a la sección de Logs y verás el mensaje de la función hello Hello, worlden la consola:

Ejemplo: usando la función sayInput

Vamos a escribir otro programa que usará un string, y lo colocaremos en la consola.

Añade el código de abajo al editor online Plutus:

import Data.Text qualified as T
import Playground.Contract
import Plutus.Contract
import PlutusTx.Prelude
import Prelude qualified as Haskell

type Schema =
        Endpoint "sayInput" Haskell.String

contract :: AsContractError e => Contract () Schema e ()
contract = selectList [sayInput]

-- | The "sayInput" contract endpoint.
sayInput :: AsContractError e => Promise () Schema e ()
sayInput = endpoint @"sayInput" $ \inputValue -> do
    logInfo @Haskell.String $ inputValue

endpoints :: AsContractError e => Contract () Schema e ()
endpoints = contract

mkSchemaDefinitions ''Schema

$(mkKnownCurrencies [])

Ya hemos visto la primera parte del código, aquí hemos importado las bibliotecas que necesitamos para ejecutar la aplicación.

Luego, vamos a definir el tipo de {% raw %}Schema. Este tipo es usado para definir el estado del contrato inteligente. Después, vamos a configurar una lista del endpoint del contrato y vamos a añadir el endpoint sayInput.

También vamos a definir el endpoint sayInput, el cual toma un string como entrada y lo registra en la consola.

Finalmente, hemos hecho que el endpoint esté disponible en la blockchain.

Haz click en el botón verde Compile. Luego de una compilación exitosa, deberías ver esto:

Haz click en el botón azul Simulate. Esto abrirá una página donde puedes ejecutar los contratos inteligentes de la blockchain.

Date cuenta que tenemos la función sayInput en la dirección de la billetera. Haz click en ella.

La función sayInput aparecerá en la sección Actions:

Ahora, escribe cualquier string en el campo de entrada y haz click en el botón Evaluate :

Verás el string que haz escrito en la página Transactions

Conclusión

En este tutorial, hemos demostrado cómo escribir una DApp en la blockchain de Cardano, usando el programa de lenguaje Plutus.

Hemos empezado introduciendo la blockchain de Cardano y el lenguaje de programación Plutus. Luego, hemos explicado Cardano comparándolo con la blockchain de Ethereum. Luego, hemos introducido el lenguaje de programación de Plutus y descrito cómo podemos usarlo para compilar y ejecutar contratos inteligentes en la blockchain de Cardano.

Finalmente, hemos dado algunos ejemplos de contratos inteligentes en el lenguaje de programación Plutus, y ejecutarlos en un simulador de la blockchain de Cardano.

Únete a organizaciones como Bitso y Coinsquare, los cuales usan LogRocket para monitorear proactivamente sus aplicaciones de la Web3

Los problemas del lado del cliente que impactan la habilidad del usuario para activar y realizar transacciones en tus aplicaciones, pueden afectar drásticamente tu línea final. Si estás interesado en monitorear los problemas UX, corregir automáticamente errores de JavaScript, y rastrear los pedidos lentos de una red y los componentes del tiempo de carga, prueba LogRocket

https://lp.logrocket.com/blg/web3-signup

LogRocket es como un DVR para una página web y aplicaciones móviles, grabando todo lo que sucede en tu aplicación o sitio web. En vez de adivinar por qué los problemas suceden, puedes agregar y reportar el rendimiento de las métricas vitales del frontend, repetir las sesiones del usuario junto a los estados de la aplicación, los pedidos de registros de red y automatizar todos los errores superficiales.

Moderniza cómo depurar tus aplicaciones web y móviles. Comienza el monitoreo de forma gratuita.