Criptomonedas: ¿Qué son y para qué sirven?

 

Una criptomoneda es:

• Una moneda digital (no es física).
• Descentralizada de todo gobierno o entidad bancaria (hasta que alguien demuestre lo contrario).
• Sirve para comprar cosas como un NTF o enviar dinero e invertir.
• Funciona con blockchain (un bloque de cadenas seguro y transparente que se distribuye en mucha computadoras).

Algunos ejemplos son: Bitcoin, Ethereum, Dogecoin.

Como se menciona las blockchains se usan en en criptomonedas, contratos digitales (Smart Contracts), votaciones seguras, rastreo de productos, etc.

Por ejemplo:

Cardano es un blockchain que funciona como una plataforma para crear y ejecutar Contratos Inteligentes, similar a Ethereum y tiene su propia criptomoneda llamada ADA. Usa el sistema Prueba de Participación en lugar de Prueba de Trabajo para validar transacciones.

Plutus es un lenguaje de programación que usa Cardano para escribir contratos inteligentes.

1. Permite crear aplicaciones descentralizadas y seguras (dApps).
2. Esta basado en Haskell.

Pero, ¿Qué es un Contrato inteligente?

Es un programa de computadora que se ejecuta automáticamente en una blockchain cuando se cumplen ciertas condiciones.

¿Cómo funciona? Veamos un ejemplo.

1. Se escribe el contrato en Plutus o Solidity. 
2. Se publica en la blockchain, donde nadie puede modificarlo o borrarlo. 
3. Cuando se cumplen las condiciones, el contrato se ejecuta automáticamente.

Digamos que un usuario compra un NFT y realiza (envía) el pago. Entonces el contrato verifica el pago. Si es correcto, se le envía el NFT al usuario.

Aspectos que debe tener una criptomoneda segura

1. Debe ser descentralizada. 
2. Tener un blockchain seguro y transparente. 
3. Un consenso confiable: PoW (Prueba de Trabajo) y PoS (Prueba de Participación). 
4. Algoritmo de cifrado fuerte (SHA-256, etc.) 
5. Resistencia a ataques. 
6. Desarrollo activo y una comunidad fuerte. 
7. Privacidad y anonimato.

Ejemplo usando Solidity

MiPrimerToken.sol

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31

// SPDX-License-Identifier: MIT pragma solidity ^0.8.0; // Contrato ERC-20 básico contract MiPrimerToken { // Variables de estado string public nombre = "MiPrimerToken"; string public simbolo = "MPT"; uint256 public totalSupply; // Mapeo para almacenar los balances de cada cuenta mapping(address => uint256) public balanceOf; // Evento para notificar transferencias event Transfer(address indexed from, address indexed to, uint256 value); // Constructor: inicializa el supply total y lo asigna al creador del contrato constructor(uint256 _supplyInicial) { totalSupply = _supplyInicial; balanceOf[msg.sender] = _supplyInicial; // El creador del contrato recibe todos los tokens } // Función para transferir tokens function transfer(address _to, uint256 _value) public returns (bool success) { require(balanceOf[msg.sender] >= _value, "Saldo insuficiente"); // Verifica que el remitente tenga suficientes tokens balanceOf[msg.sender] -= _value; // Resta los tokens del remitente balanceOf[_to] += _value; // Suma los tokens al destinatario emit Transfer(msg.sender, _to, _value); // Emite el evento de transferencia return true; } }

Cómo Probar el Contrato

1. Abre Remix.
2.  Crea un nuevo archivo (MiPrimerToken.sol) y pega el código. 
3.  Compila el Contrato: Ve a la pestaña "Solidity Compiler". 
4.  Selecciona la versión 0.8.0 o superior. 
5.  Haz clic en "Compile MiPrimerToken.sol". 
6.  Despliega el Contrato: 
7.  Ve a la pestaña "Deploy & Run Transactions". 
8.  Selecciona el entorno "JavaScript VM" para pruebas locales. 
9.  En el campo "Deploy", ingresa el _supplyInicial (por ejemplo, 1000000). 
10.  Haz clic en "Deploy". Interactúa con el Contrato: 
11.  Una vez desplegado, verás las funciones del contrato. 
12.  Prueba la función transfer enviando tokens a otra dirección (puedes generar cuentas en Remix).

Este es un ejemplo básico, pero te da una idea de cómo funcionan los contratos inteligentes en Ethereum.

El mismo programa, pero en Plutus y Cardano.

{-# LANGUAGE DataKinds         #-}
{-# LANGUAGE DeriveAnyClass    #-}
{-# LANGUAGE DeriveGeneric     #-}
{-# LANGUAGE NoImplicitPrelude #-}
{-# LANGUAGE TemplateHaskell   #-}

module MiPrimerToken where

import           PlutusTx
import           PlutusTx.Prelude
import           Ledger
import           Ledger.Value
import           Ledger.Ada
import           Ledger.Typed.Scripts
import           Playground.Contract

-- Definimos el tipo de dato para nuestro token
data MiToken = MiToken
    { tokenName :: TokenName
    , tokenSymbol :: CurrencySymbol
    } deriving (Show, Generic, ToJSON, FromJSON)

-- Parámetros del contrato
data TokenParams = TokenParams
    { tpToken :: MiToken
    , tpAmount :: Integer
    } deriving (Show, Generic, ToJSON, FromJSON)

-- Validación del contrato
validateToken :: TokenParams -> () -> ScriptContext -> Bool
validateToken params _ ctx =
    -- Verificamos que la cantidad de tokens sea correcta
    let txOuts = txInfoOutputs $ scriptContextTxInfo ctx
        totalTokens = foldMap (valueOf (tpToken params)) txOuts
    in totalTokens == tpAmount params

-- Instancia de ScriptType para el contrato
instance ScriptType MiToken where
    type instance RedeemerType MiToken = ()
    type instance DatumType MiToken = ()

-- Compilación del validador
tokenValidator :: TokenParams -> Validator
tokenValidator params = mkValidatorScript $
    $$(PlutusTx.compile [|| validateToken ||])
    `PlutusTx.applyCode`
    PlutusTx.liftCode params

-- Código para interactuar con el contrato en el Playground
endpoints :: Contract () TokenParams Text ()
endpoints = do
    params <- endpoint @"crear-token"
    let val = tokenValidator params
    logInfo @Text $ "Token creado: " <> show (tpToken params)
    logInfo @Text $ "Cantidad total: " <> show (tpAmount params)
    void $ submitTxConstraints (typedValidator val) mempty

Continuaremos con este tema en próximas entregas.

Enlaces:

https://ethereum.org/en/developers/
https://docs.soliditylang.org/en/latest/