Guía de Solidity Nivel Medio: Funciones, Estado, Seguridad, Patrones y Estándares ERC por Santiago Soñora

“Hola, mundo” en Solidity

Un contrato inteligente simple en Solidity que almacena y devuelve una cadena de texto.

📋 Copiar

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

contract Greeting {
    string private greeting = "Hola Mundo"; // Variable de estado privada

    function setGreeting(string memory _greeting) public {
        greeting = _greeting;
    }

    function getGreeting() public view returns (string memory) {
        return greeting;
    }
}

Resultado:

Output

Compilado correctamente. Puedes desplegar este contrato en una EVM y llamar `getGreeting()` para obtener 'Hola Mundo' o `setGreeting('Nuevo mensaje')` para cambiarlo.

Comandos básicos

Familiarizarse con estos comandos es esencial para interactuar eficientemente con Solidity:

Declarar variable de estado y tipo de dato básico

📋 Copiar

uint256 public myNumber = 100; // Entero público sin signo
address private owner = msg.sender; // Dirección privada del desplegador
bool isPaused = false; // Booleano por defecto false

Define variables que almacenan datos de forma persistente en la blockchain y especifica su tipo y visibilidad.

Declarar un Mapping
📋 Copiar
```
mapping(address => uint256) public balances; // Mapea direcciones a enteros sin signo
mapping(uint256 => string) private tokenNames; // Mapea IDs de token a nombres
```
Crea una estructura de datos clave-valor (hash table) para asociar un tipo de dato con otro. Útil para saldos, permisos, etc. No es iterable directamente.
Declarar un Array dinámico y un Struct
📋 Copiar
```
struct User { // Define una estructura de datos personalizada
    address userAddress;
    uint256 userId;
    string name;
}

User[] public users; // Array dinámico de structs User
```
Define una estructura de datos personalizada (`struct`) para agrupar variables, y cómo crear un array (`array[]`) que puede crecer para almacenar múltiples instancias de esa estructura o de otros tipos de datos.
Función `view` (solo lectura de estado)
📋 Copiar
```
function getBalance(address _user) public view returns (uint256) {
    return balances[_user];
}
```
Define una función que solo lee variables de estado y no modifica el estado de la blockchain. Llamarla 'off-chain' (sin enviar una transacción) no cuesta gas.
Función `pure` (sin interacción con estado)
📋 Copiar
```
function calculateTax(uint256 amount, uint256 rate) public pure returns (uint256) {
    return amount * rate / 100;
}
```
Define una función que no lee ni escribe en ninguna variable de estado. Sus resultados solo dependen de los parámetros de entrada.
Usar un Modificador de Función
📋 Copiar
```
modifier onlyOwner() { // Define un modificador
    require(msg.sender == owner, "Solo el propietario puede llamar a esta funcion");
    _;
}

function restrictedAction() public onlyOwner { // Aplica el modificador
    // Lógica que solo el propietario puede ejecutar
}
```
Define y aplica un modificador. El código dentro del modificador se ejecuta ANTES (si `_;` está al final) o DESPUÉS (si `_;` está al principio) de la lógica de la función. Útil para validar condiciones (ej: control de acceso) de forma reutilizable.
Emitir un Evento
📋 Copiar
```
event ItemAdded(address indexed by, uint256 itemId, string name); // Define un evento

function addItem(uint256 _itemId, string memory _name) public {
    // Lógica para agregar item
    emit ItemAdded(msg.sender, _itemId, _name); // Emite el evento
}
```
Define un evento (`event`) y lo emite (`emit`) desde una función. Los eventos registran información en el log de la blockchain de forma económica, y las aplicaciones off-chain (dApps, exploradores) pueden escuchar estos logs para reaccionar.
Manejo de Errores con `require`
📋 Copiar
```
function buyItem(uint256 itemId) public payable {
    require(msg.value >= itemPrice[itemId], "Ether insuficiente"); // Valida si el usuario envió suficiente Ether
    require(itemStock[itemId] > 0, "Item agotado"); // Valida si hay stock
    // Lógica para comprar item
}
```
Utiliza `require` para validar condiciones (precondiciones o parámetros de entrada). Si la condición es falsa, la ejecución se revierte (se cancela la transacción) y se devuelve el gas restante, opcionalmente con un mensaje de error.
Manejo de Errores con `revert`
📋 Copiar
```
function processOrder(uint256 orderId) public {
    if (!isValidOrder(orderId)) {
        revert("La orden no es valida o ya ha sido procesada"); // Revertir con mensaje explícito
    }
    // Lógica para procesar la orden
}
```
Similar a `require`, `revert` revierte la transacción. Es útil para lógica de validación más compleja (ej: dentro de un `if`/`else`) y permite devolver un mensaje de error específico.
Enviar Ether desde un Contrato
📋 Copiar
```
// Enviar 1 Ether al propietario
function withdrawFunds() public onlyOwner {
    (bool success, ) = payable(owner).call{value: 1 ether}(""); // Método recomendado con manejo de error
    require(success, "Fallo al enviar Ether");
}
```
Muestra cómo un contrato puede enviar Ether a una dirección. El método `call{value: ...}` es el más flexible y recomendado, permitiendo manejar el resultado (`success`). `transfer` y `send` son menos recomendados o están deprecados.

Interactuar con Otro Contrato (llamada a función)

📋 Copiar

// Define una Interfaz para el contrato con el que interactuarás
interface ITargetContract {
    function targetFunction(uint256 param) external; // Solo declara las funciones externas a llamar
    function readData() external view returns (uint256);
}

contract CallerContract {
    function callTarget(address _targetAddress, uint256 _value) public {
        // Crea una instancia tipada del contrato objetivo
        ITargetContract target = ITargetContract(_targetAddress);
        
        // Llamada de escritura (envía transacción)
        target.targetFunction(_value);
        
        // Llamada de lectura (view, no envía transacción si se llama off-chain del Caller)
        uint256 result = target.readData();
        // ... usar result ...
    }
}

Cómo un contrato inteligente puede llamar funciones de otro contrato inteligente. Requiere definir una `interface` con las funciones que vas a llamar en el contrato objetivo y luego usar la dirección del contrato objetivo para interactuar.

Ejemplo de implementación básica de función ERC-20 (`transfer`) y Evento

📋 Copiar

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

contract SimpleToken {
    mapping(address => uint256) private _balances;
    
    event Transfer(address indexed from, address indexed to, uint256 value);

    constructor(uint256 initialSupply) {
        _balances[msg.sender] = initialSupply;
    }

    function transfer(address to, uint256 amount) public returns (bool) {
        require(_balances[msg.sender] >= amount, "Saldo insuficiente");
        _balances[msg.sender] -= amount;
        _balances[to] += amount;
        emit Transfer(msg.sender, to, amount); // Emite el evento estándar
        return true;
    }

    function balanceOf(address account) public view returns (uint256) {
        return _balances[account];
    }
}

Muestra la implementación básica de la función `transfer` y el evento `Transfer` del estándar ERC-20. Implementaciones completas usan librerías como OpenZeppelin.

Conceptos Clave

Comprender estos conceptos fundamentales te ayudará a dominar Solidity de forma más organizada y eficiente:

Variables de Estado y Tipos de Datos:

Variables que almacenan información de forma persistente en el almacenamiento de la blockchain del contrato. Su visibilidad (`public`, `private`, `internal`) controla el acceso. Comprender los tipos de datos disponibles (enteros, booleanos, direcciones, bytes, cadenas, enums) y los tipos complejos (arrays, mappings, structs).
Funciones: Definición, Mutabilidad y Visibilidad:

Bloques de código ejecutable dentro de un contrato. Su 'mutabilidad de estado' (`view`, `pure`, o por defecto) indica si leen o modifican el estado. Su 'visibilidad' (`public`, `private`, `internal`, `external`) controla si pueden ser llamadas desde fuera, desde contratos que heredan, o solo internamente.
Modificadores de Funciones:

Código reutilizable que se aplica a las definiciones de funciones para modificar su comportamiento, típicamente para verificar precondiciones (ej: que el llamador sea el propietario, que un valor sea mayor a cero) o para ejecutar lógica antes o después de la función principal. Reducen la duplicación y mejoran la seguridad.
Eventos:

Una forma eficiente de comunicar información desde el contrato a las aplicaciones off-chain (dApps, servicios de monitoreo, exploradores de bloques). Los eventos no almacenan datos en el estado del contrato, sino que los escriben en los logs de transacciones. Son económicos y permiten que las aplicaciones reaccionen a lo que sucede en la blockchain.
Manejo de Errores (`require`, `revert`, `assert`):

Mecanismos para gestionar condiciones de error. `require(condicion, mensaje)` se usa para validar precondiciones o parámetros de entrada; si la condición es falsa, revierte la transacción y devuelve el gas restante (y el mensaje). `revert(mensaje)` revierte la transacción explícitamente con un mensaje. `assert(condicion)` verifica invariantes que *nunca* deberían ser falsas (si falla, consume todo el gas).
Mappings, Arrays y Structs:

Tipos de datos complejos para organizar información estructurada. `mapping` es una tabla hash no enumerable. `array` es una lista de elementos (fija o dinámica). `struct` permite crear tipos de datos personalizados agrupando variables. Comprender cómo usarlos y sus limitaciones (ej: iterar sobre mappings).
Herencia:

Permite que un contrato (contrato hijo) reutilice código, variables de estado y modificadores de otro(s) contrato(s) (contrato(s) padre). Útil para modularidad, reutilización de código y para implementar estándares (ej: heredar de `ERC20` de OpenZeppelin).
Librerías e Interfaces:

`library` son contratos desplegados una vez que contienen código reutilizable (típicamente funciones puras o vistas, o que operan sobre tipos de datos personalizados) que otros contratos pueden llamar sin copiar el bytecode. Ahorran gas de despliegue. `interface` es una definición abstracta de un contrato que solo declara las funciones externas. Se usan para interactuar con otros contratos tipados.
Interacción entre Contratos:

Cómo un contrato inteligente puede llamar funciones o enviar Ether a otros contratos inteligentes. Comprender los mecanismos de llamada de bajo nivel (`call`, `delegatecall`, `staticcall`) y las llamadas tipadas usando interfaces.
Gas y Optimización de Gas:

El costo computacional de ejecutar código Solidity en la EVM, pagado en la moneda nativa de la red. Aprender qué operaciones consumen más gas (especialmente el almacenamiento en variables de estado) y técnicas para escribir código más eficiente en gas (optimizar loops, usar tipos de datos correctos, minimizar escrituras en almacenamiento).
Patrones de Seguridad y Vulnerabilidades Comunes:

Ser consciente de los riesgos al escribir contratos. Vulnerabilidades comunes incluyen Reentrancy, Integer Overflow/Underflow, problemas de control de acceso, DoS (Denial of Service), etc. Aprender a escribir código seguro, seguir patrones recomendados (ej: Checks-Effects-Interactions para pagos) y usar herramientas de análisis estático/dinámico y auditorías.
Implementación Básica de Estándares ERC (ERC-20, ERC-721, ERC-1155):

Comprender la estructura y las funciones clave definidas en los estándares de tokens más comunes (ERC-20 para fungibles, ERC-721 para NFTs, ERC-1155 para multi-estándar). Ser capaz de implementar las funciones básicas de estos estándares o, más comúnmente, heredar de implementaciones estándar de librerías auditadas como OpenZeppelin.

Casos de uso

Algunos ejemplos de aplicaciones prácticas donde se utiliza Solidity:

Implementar lógica de control de acceso granular en contratos inteligentes:

Escribir contratos que restringen quién puede llamar a ciertas funciones o modificar ciertas variables de estado basándose en roles, listas blancas, o propiedades (ej: solo el creador del contrato, miembros de un DAO), utilizando modificadores y lógica condicional.
Crear sistemas de contratos donde múltiples contratos interactúan para proporcionar funcionalidades complejas:

Diseñar arquitecturas de dApps donde diferentes partes de la lógica están en contratos separados que se llaman entre sí, utilizando interfaces para interactuar de forma tipada y segura.
Desarrollar contratos que emiten eventos para permitir la creación de interfaces de usuario reactivas o servicios de monitoreo:

Diseñar contratos para emitir eventos clave cuando ocurren acciones importantes (ej: una transferencia de token, un cambio de estado crítico), permitiendo a los frontends de dApps o servicios externos escuchar estos eventos y actualizar su visualización o reaccionar en tiempo real.
Implementar mecanismos de manejo de errores robustos y claros en la lógica del contrato:

Utilizar `require`, `revert` y `assert` de forma efectiva para validar entradas de usuario, verificar el estado interno del contrato y revertir transacciones con mensajes de error significativos que ayuden a los usuarios o a otras dApps a entender por qué falló una operación.
Crear contratos que gestionan colecciones de datos estructurados utilizando mappings, arrays y structs:

Desarrollar contratos para almacenar y gestionar información compleja on-chain, como registros de usuarios, inventarios de activos, configuraciones, utilizando estructuras de datos adecuadas para organizar la información.
Implementar lógica básica de staking, vesting o distribución de recompensas en contratos:

Codificar mecanismos donde los usuarios pueden bloquear tokens por un tiempo para ganar recompensas (staking), recibir tokens gradualmente a lo largo del tiempo (vesting) o reclamar recompensas basándose en ciertas condiciones.
Construir componentes básicos para mercados descentralizados, registros de activos o sistemas de votación:

Desarrollar contratos que implementan la lógica central para plataformas descentralizadas, como contratos para listar y comprar/vender activos, registrar elementos únicos, o gestionar un proceso de votación on-chain.
Aplicar patrones de diseño de contratos inteligentes y seguir las mejores prácticas de seguridad:

Escribir código Solidity que no solo sea funcional, sino también eficiente en gas, seguro y auditable, utilizando patrones de diseño recomendados (ej: Pull over Push for payments) y siendo consciente de las vulnerabilidades comunes.
Implementar contratos que heredan de librerías estándar (ej: OpenZeppelin) para reutilizar funcionalidades comunes y seguras:

Extender contratos base auditados para añadir funcionalidades como manejo de propiedad (`Ownable`), control de acceso (`AccessControl`), o implementaciones completas de estándares ERC (`ERC20`, `ERC721`, `ERC1155`), reduciendo el riesgo de errores de seguridad.

Consejos para Principiantes

Aquí tienes algunas recomendaciones para facilitar tus inicios en Solidity:

Practica Mucho Escribiendo Código Solidity y Testeándolo Exhaustivamente:

La única forma de dominar Solidity es escribiendo código. Empieza con contratos simples y avanza gradualmente. Más importante aún: ¡escribe tests! Utiliza los frameworks de testing (Hardhat, Foundry) para verificar cada función y cada escenario posible de tu contrato. Los tests son tu red de seguridad.
Entiende el Modelo de Gas Profundamente:

El gas es el costo de ejecutar tu código. Aprende qué operaciones de Solidity consumen más gas (el almacenamiento en variables de estado es típicamente lo más caro). Escribir código eficiente en gas es crucial para reducir los costos de transacción para los usuarios de tu dApp.
Enfócate en la Seguridad como Prioridad Número Uno:

Los contratos inteligentes son inmutables una vez desplegados, y un solo bug puede ser muy costoso. Aprende sobre las vulnerabilidades comunes (Reentrancy, overflows/underflows, control de acceso) y los patrones de seguridad básicos (ej: Checks-Effects-Interactions). Usa herramientas de análisis estático y considera auditorías para contratos críticos.
Utiliza Librerías Estándar Auditadas como OpenZeppelin:

No reinventes la rueda para funcionalidades comunes como manejo de propiedad, control de acceso o implementaciones de tokens. Usa y hereda de las implementaciones de OpenZeppelin. Son auditadas por la comunidad y mucho más seguras que un código escrito desde cero si no tienes experiencia.
Lee el Código Fuente Verificado de Contratos Existentes en Exploradores:

Explora contratos populares y auditados en Etherscan (o exploradores de otras cadenas) que han verificado su código fuente. Ver cómo otros desarrolladores han implementado funcionalidades y patrones de seguridad es una excelente forma de aprender.
Domina el Uso de Modificadores para Código Limpio y Seguro:

Los modificadores son una herramienta poderosa para reutilizar la lógica de validación (ej: `onlyOwner`, `whenNotPaused`). Hacen tu código más legible y reducen la posibilidad de olvidar una validación importante.
Usa `require` y `revert` para un Manejo Claro y Efectivo de Errores:

Utiliza `require` para validar precondiciones al inicio de tus funciones y `revert` para manejar errores más complejos dentro de la lógica. Proporciona mensajes de error útiles para que los usuarios o las dApps que interactúan entiendan por qué falló la transacción.
Entiende la Diferencia entre `view`, `pure` y Funciones que Modifican Estado:

Comprende cuándo usar `view` (solo leer estado), `pure` (sin estado) y cuándo necesitas una función que modifique el estado. Recuerda que solo las llamadas a funciones que modifican estado envían una transacción y cuestan gas.
Practica la Interacción entre Contratos:

Aprender cómo un contrato llama a funciones de otro (usando interfaces) es fundamental para construir sistemas de contratos más complejos. Sé consciente de los riesgos de seguridad asociados (ej: reentrancy) y usa patrones seguros.
Recuerda Siempre la Inmutabilidad Después del Despliegue:

Una vez que un contrato se despliega en la blockchain, su código no puede ser cambiado (a menos que uses patrones de upgradeability avanzados). Esto subraya la importancia de probar A FONDO tu contrato antes de desplegar en redes públicas.

Herramientas relacionadas

Si te interesa Solidity, también podrías explorar estas herramientas:

Recursos útiles

Amplía tus conocimientos con estos enlaces y materiales: