Code monkey: criptomoneda

Mostrando entradas con la etiqueta criptomoneda. Mostrar todas las entradas

lunes, 8 de diciembre de 2025

Criptomonedas explicadas de manera sencilla (o casi)

En una entrega anterior dimos un vistazo a lo que son las criptomonedas. Las cual es:

Una entidad NO FÍSICA basada en blockchain que solo existe en una red distribuida.
Una entidad NO FÍSICA descentralizada, no depende de una entidad gubernamental o bancaria.
Una entidad NO FÍSICA segura puesto que utiliza criptografía para realizar sus transacciones, y así evitar copias o fraudes (en teoría).
Una entidad NO FÍSICA cuyo valor es ambiguo o volátil, según la oferta o la demanda (ojo ahí).
Una entidad NO FÍSICA que se almacena en "carteras digitales" llamada Wallets.

Si desglosamos etimológicamente la palabra CRIPTOMONEDA nos encontramos con dos vocablos:

Cripto: cubierto, escondido.
Monete o monere: recordar, advertir, aconsejar.

¿Cuál es el sentido, objetivo o fin de las criptomonedas?

Las criptomonedas nacen con un propósito central: crear un sistema de dinero digital que funcione sin depender de bancos, gobiernos o intermediarios, permitiendo transacciones seguras, globales y transparentes.

Las criptomonedas buscan ser un sistema de pagos seguro basado en criptografía, sin necesidad de bancos centrales.
Su objetivo es ofrecer un medio descentralizado y digital para realizar transacciones financieras, reduciendo la dependencia de instituciones tradicionales.
También responden a la necesidad de finanzas descentralizadas (DeFi) y a la creación de nuevos casos de uso en la economía digital.

Esto se basa en la tecnología blockchain, que garantiza seguridad y descentralización.

Las criptomonedas existen para crear un sistema financiero:

Descentralizado.
Seguro.
Global.
Transparente.
Accesible para todos.
Innovador y programable.

No son solo dinero digital: son la base de una nueva infraestructura económica.

Las criptomonedas más conocidas son:

Bitcoin (BTC).
Ethereum (ETH).
Litecoin (LTC).

¿Para qué sirve?

Para comprar bienes y servicios (aunque no en todos lados).
Para invertir o especular con su precio.
Para transferir dinero de forma rápida y global sin intermediarios.

La tecnología que hace posible a Bitcoin, Ethereum y muchas otras criptomonedas se le conoce como blockchain (cadena de bloques).

La blockchain es, esencialmente, un libro de registros digital distribuido donde se guardan transacciones de forma segura, transparente e inmutable.

1. Estructura: bloques encadenados

Cada bloque contiene:

Datos de transacciones.
Un hash (identificador único).
El hash del bloque anterior.

Esto crea una cadena donde si cambias un bloque, rompes toda la cadena, lo que evita manipulaciones.

2. Red distribuida

Miles de computadoras (nodos) guardan una copia completa de la cadena. Esto elimina la necesidad de un intermediario central y aumenta la seguridad.

3. Mecanismos de consenso

Para validar transacciones, la red usa algoritmos como:

Proof of Work (PoW) – usado por Bitcoin.
Proof of Stake (PoS) – usado por Ethereum 2.0.

Estos mecanismos permiten que todos los nodos se pongan de acuerdo sin confiar unos en otros.

4. Inmutabilidad y seguridad

Una vez que un bloque se registra, no puede modificarse sin rehacer toda la cadena, lo cual es computacionalmente inviable.

Todo esto suena bonito y agradable, pero ¿Cómo se compran? Veamos un paso a paso.

1. Elige un exchange (plataforma)

Según las guías actuales, en México se usan plataformas como:

Binance.
Bitso.
Coinbase.
KuCoin.

Estas plataformas permiten comprar, vender y almacenar criptomonedas.

2. Crea una cuenta y verifica tu identidad

Los exchanges regulados te pedirán:

Identificación oficial.
Selfie.
Comprobante básico de datos.

Esto es parte del proceso KYC (Know Your Customer).

3. Deposita fondos

Puedes depositar:

Transferencia bancaria SPEI.
Tarjeta de débito.
A veces tarjeta de crédito (con comisiones más altas).

4. Compra la criptomoneda

En la plataforma eliges:

La moneda (BTC, ETH, USDT, etc.).
El monto.
El tipo de orden (mercado o límite).

5. Guarda tus criptomonedas

Opciones:

Wallet del exchange (más fácil, menos segura).
Wallet propia (Metamask, Ledger, Trezor).
Cold wallets para máxima seguridad.

Proceso de transacción de una bitcoin

Veamos un diagrama que describe el flujo de una transacción de bitcoin.

                   ┌──────────────────────────┐
                   │ 1. Usuario crea transacción│
                   │  - Monto                  │
                   │  - Dirección destino      │
                   └─────────────┬────────────┘
                                 │
                                 ▼
                   ┌──────────────────────────┐
                   │ 2. Wallet selecciona UTXO │
                   │  (entradas disponibles)   │
                   └─────────────┬────────────┘
                                 │
                                 ▼
                   ┌──────────────────────────┐
                   │ 3. Wallet construye       │
                   │    la transacción         │
                   │  - Inputs (UTXO)          │
                   │  - Outputs (destino y     │
                   │    cambio)                │
                   └─────────────┬────────────┘
                                 │
                                 ▼
                   ┌──────────────────────────┐
                   │ 4. Firma digital con      │
                   │    clave privada          │
                   └─────────────┬────────────┘
                                 │
                                 ▼
                   ┌──────────────────────────┐
                   │ 5. Se envía a un nodo     │
                   │    de la red Bitcoin      │
                   └─────────────┬────────────┘
                                 │
                                 ▼
                   ┌──────────────────────────┐
                   │ 6. Nodo valida reglas     │
                   │  - Firma válida           │
                   │  - UTXO no gastado        │
                   │  - Suma entradas ≥ salidas│
                   └─────────────┬────────────┘
                                 │
                                 ▼
                   ┌──────────────────────────┐
                   │ 7. Transacción entra al   │
                   │    MEMPOOL (pendiente)    │
                   └─────────────┬────────────┘
                                 │
                                 ▼
                   ┌──────────────────────────┐
                   │ 8. Mineros seleccionan    │
                   │    transacciones según fee│
                   └─────────────┬────────────┘
                                 │
                                 ▼
                   ┌──────────────────────────┐
                   │ 9. Minero arma un bloque  │
                   │    y ejecuta PoW          │
                   └─────────────┬────────────┘
                                 │
                                 ▼
                   ┌──────────────────────────┐
                   │10. Bloque válido se       │
                   │    difunde a la red       │
                   └─────────────┬────────────┘
                                 │
                                 ▼
                   ┌──────────────────────────┐
                   │11. Nodos verifican bloque │
                   │    y lo agregan a la      │
                   │    blockchain             │
                   └─────────────┬────────────┘
                                 │
                                 ▼
                   ┌──────────────────────────┐
                   │12. Transacción CONFIRMADA │
                   │    (1 confirmación)       │
                   └─────────────┬────────────┘
                                 │
                                 ▼
                   ┌──────────────────────────┐
                   │13. Más bloques encima     │
                   │    = más seguridad        │
                   │    (6 confirmaciones)     │
                   └──────────────────────────┘

Este diagrama es solo un ejemplo de transacción.

Conclusión:

El mundo de las criptomonedas es aún lugar recóndito y no muy fácil de navegar (quien diga lo contrario miente). Encontrarás a cada embustero y vende-humos que dirá lo fácil que es usar para comprar e invertir, aunque él no tiene ni idea de cómo hacerlo. Millonarios que heredaron su fortuna que promueven criptomonedas que jamás han usado, cursos sobre mentes millonarias (con un desembolso monetario por supuesto) y cómo lograrlo en sencillos pasos .

A las personas de a pie solo nos queda informarnos y no dejarnos llevar por la ola que arrastra a miles de incautos. No deberíamos creer en todas las maravillas de está tecnología, siempre hay riesgos y casi nadie habla de ello. Siempre hay algo oculto cuando sale algo "innovador".

Como desarrolladores, deberíamos conocer cual es la pauta a seguir. Que plataforma(s) y lenguaje(s) son los que deberíamos aprender.

Enlaces:

https://ethereum.org/en/developers/
https://docs.soliditylang.org/en/latest/
https://codemonkeyjunior.blogspot.com/2025/03/criptomonedas-que-son-y-para-que-sirven.html
https://alquimistadecodigo.blogspot.com/2025/12/comparativa-rholang-vs-plutus-vs.html

domingo, 9 de marzo de 2025

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 muchas 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.

Permite crear aplicaciones descentralizadas y seguras (dApps).
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.

Se escribe el contrato en Plutus o Solidity.
Se publica en la blockchain, donde nadie puede modificarlo o borrarlo.
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

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

Ejemplo usando Solidity

MiPrimerToken.sol

// 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

Abre Remix.
Crea un nuevo archivo (MiPrimerToken.sol) y pega el código.
Compila el Contrato: Ve a la pestaña "Solidity Compiler".
Selecciona la versión 0.8.0 o superior.
Haz clic en "Compile MiPrimerToken.sol".
Despliega el Contrato:
Ve a la pestaña "Deploy & Run Transactions".
Selecciona el entorno "JavaScript VM" para pruebas locales.
En el campo "Deploy", ingresa el _supplyInicial (por ejemplo, 1000000).
Haz clic en "Deploy". Interactúa con el Contrato:
Una vez desplegado, verás las funciones del contrato.
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.