Solidity en un vistazo

Como vimos en el post pasado, Solidity es un lenguaje de programación para programar Smart contracts que se ejecutarán en el blockchain Ethereum.

Herramientas que se necesitan para programar con Solidity

1. Editor de código como Visual Studio Code: https://code.visualstudio.com/. 
2. Remix IDE para compilar tu código: https://remix.ethereum.org/ 
3. Truffle, un framework popular que facilita la escritura, prueba e implementación de contratos: https://archive.trufflesuite.com/ 
4. Metamask (o una wallet similar), para gestionar tus claves privadas y Ether: https://chromewebstore.google.com/detail/metamask/nkbihfbeogaeaoehlefnkodbefgpgknn?hl=es&pli=1
5. IPFS, un conjunto de protocolos componibles punto a punto para direccionar, enrutar y transferir datos direccionados por contenido en un sistema de archivos descentralizado: https://docs.ipfs.tech/install/ipfs-desktop/
6. Etherscan, es una plataforma de exploración y análisis de bloques para Ethereum, una plataforma de contratos inteligentes descentralizados: https://etherscan.io/

Tipos de datos en Solidity

// Booleanos
bool public esActivo = true;

// Enteros con y sin signo
uint256 public numero = 100;
int8 public diferencia = -5;

// Tipo address: representa una dirección de Ethereum (20 bytes)

// Básica
address public propietario = msg.sender;

// La que puede recibir Ether
address payable public destinatario = payable(0x123...);

// Secuencia dinámica de bytes. 
bytes32 public hash = "Hola";

// Arrays de bytes de longitud fija (1 a 32 bytes).
bytes public datos = "Mensaje variable";

// Tipo enumerado con valores personalizados. Útil para estados discretos.
enum Estado { Inactivo, Activo, Finalizado }
Estado public estadoActual = Estado.Activo;

También existen los Tipos Referenciados. Estos tipos no se copian directamente, sino que se pasa una referencia a su ubicación en memoria o almacenamiento, algunos son:

// Tipo array
uint256[] public listaNumeros; // Array dinámico
uint256[5] public arrayFijo = [1, 2, 3, 4, 5]; // Array de tamaño fijo

// Tipo struct. Tipo compuesto que agrupa variables bajo un solo nombre
struct Persona {
    string nombre;
    uint256 edad;
}
Persona public usuario = Persona("Juan", 30);

// Tipo mapping Estructura clave-valor, similar a un diccionario o tabla hash. No tiene longitud fija ni se puede iterar directamente.
mapping(address => uint256) public saldos;

// Ejemplo de uso: saldos[msg.sender] = 100;

Tipos Especiales:

// Tipo que representa una función. Puede ser internal, external, public o private, y puede incluir modificadores como view o payable
function miFuncion() public view returns (uint256) {
    return 42;
}

// Representa un contrato específico como tipo. Útil para interactuar con otros contratos

contract OtroContrato {
    uint256 dato;
}
OtroContrato public otro = OtroContrato(direccion);

Ejemplo 1. Veamos un programa que abarca varios tipos:

EjemploTipos.sol

pragma solidity ^0.8.0;

contract EjemploTipos {
    uint256 public numero = 10;
    bool public activo = true;
    address public dueño = msg.sender;
    string public mensaje = "Hola Solidity";
    bytes32 public hashFijo = "Ejemplo";
    mapping(address => uint256) public saldos;
    uint256[] public lista;

    struct Usuario {
        string nombre;
        uint256 edad;
    }
    Usuario public persona = Usuario("Ana", 25);

    enum Estado { Apagado, Encendido }
    Estado public estado = Estado.Encendido;
}

Ejemplo 2. Crearemos un Hola, mundo en Solidity.

HolaMundo.sol

pragma solidity ^0.8.20;

contract HolaMundo{ 
  string public mensaje = "¡Hola, mundo!";
}

Para probar el código debemos ir a remix.ethereum.org:

1. Crear el programa HolaMundo.sol. 
2. Pegar el código. 
3. En Solidity Compiler: Selecciona la versión del compilador (0.8.x). 
4. Hacer clic en Compile HolaMundo.sol 
5. En la pestaña Deploy & Run Transactions: Selecciona el entorno "JavaScript VM" (una blockchain simulada) y hacer clic en "Deploy". 
6. Una vez desplegado: Usa el botón mensaje.

Ejemplo 3. Crearemos un smart contract que funcione como contador o incrementador de un número.

Contador.sol

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

contract Contador {
    // Variable de estado para almacenar el número
    uint256 public numero;

    // Constructor que inicializa el número en 0
    constructor() {
        numero = 0;
    }

    // Función para incrementar el número
    function incrementar() public {
        numero = numero + 1;
    }

    // Función para obtener el valor actual del número
    function obtenerNumero() public view returns (uint256) {
        return numero;
    }
}

Para probar el código debemos ir a remix.ethereum.org:

1. Crear el programa Contador.sol. 
2. Pegar el código. 
3. En Solidity Compiler: Selecciona la versión del compilador (0.8.x). 
4. Hacer clic en Compile HolaMundo.sol 
5. En la pestaña Deploy & Run Transactions: Selecciona el entorno "JavaScript VM" (una blockchain simulada) y hacer clic en "Deploy". 
6. Una vez desplegado: Usa el botón numero. Hacer clic en incrementar y luego consulta numero otra vez (debería ser 1). Usa obtenerNumero para verificar el valor sin modificar el estado. Cada vez que llames a incrementar(), el valor aumentará en 1.

Continuaremos con este tema en próximas entregas.

Enlaces:

https://alquimistadecodigo.blogspot.com/2025/03/solidity-un-lenguaje-de-programacion.html