Fundamentos de Solidity

Solidity es el lenguaje estándar de la industria para construir aplicaciones descentralizadas en la máquina virtual compatible con EVM de TRON. Este manual introduce los conceptos básicos de los contratos inteligentes, desde variables de estado y mappings hasta la inmutabilidad y la ejecución atómica, diseñados específicamente para desarrolladores que se integran al ecosistema de TRON.

¿Por Qué Aprender Solidity?

Si eres nuevo en el desarrollo blockchain, puede que te preguntes: ¿Es Solidity el único lenguaje para contratos inteligentes?

No, no es el único. Quizás hayas escuchado sobre Rust (usado en Solana), Vyper (una alternativa pythónica para EVM) o Move (usado en Aptos/Sui). Sin embargo, Solidity es el estándar indiscutible de la industria.

Aprender Solidity es la habilidad más estratégica en Web3. Dado que la gran mayoría de las blockchains —incluyendo TRON, Ethereum, Polygon, Binance Smart Chain y Avalanche— usan entornos compatibles con EVM, escribir Solidity permite que tu código se ejecute en casi cualquier red importante.

Si estás eligiendo un lenguaje para comenzar tu camino en el desarrollo blockchain, Solidity es sin duda el mejor punto de partida.

---

El Panorama General: Cómo se Conectan Web2 y Web3

Antes de entrar en el código, conviene entender la arquitectura. ¿Cómo se comunica realmente una aplicación web con un contrato inteligente?

1. El Contrato Inteligente (Backend): Escribes la lógica en Solidity. Una vez compilado y desplegado, vive permanentemente en la blockchain de TRON.
2. El ABI (El Puente): Cuando compilas Solidity, se genera una Interfaz Binaria de Aplicación (ABI). Es simplemente un archivo JSON que le dice a tu frontend en JavaScript qué funciones existen en el contrato y cómo dar formato a los datos para ellas.
3. La Billetera (Identidad y Seguridad): Los usuarios instalan una extensión de navegador como TronLink. Esta almacena sus claves privadas y firma transacciones de forma segura sin exponer sus secretos a tu frontend.
4. TronWeb (La API): Tu frontend usa la biblioteca JavaScript tronweb para pedirle a la billetera que firme una transacción, que luego se transmite a la red de TRON para activar tus funciones de Solidity.

(Si quieres profundizar en el lado JavaScript más adelante, guarda en favoritos nuestra Guía del SDK tronweb.)

---

Solidity vs. Programación Tradicional

Solidity se parece mucho a JavaScript, C++ y Python en su sintaxis, y es de tipo estático (debes definir el tipo de dato de cada variable). Sin embargo, el entorno en el que se ejecuta lo hace fundamentalmente diferente.

Si vienes de Web2, estos son los momentos “¡Ajá!” que cambiarán tu forma de pensar sobre el código:

1. El Código es Inmutable

Cuando despliegas un script de Python en un servidor, siempre puedes conectarte por SSH y corregir un error. En Solidity, una vez que un contrato es desplegado, no se puede modificar. Si hay un error, es permanente. (Los desarrolladores usan “patrones proxy” avanzados para actualizar contratos, pero el despliegue base es inmutable).

2. El Almacenamiento Cuesta Dinero

En JavaScript, creas arrays y objetos sin pensarlo dos veces. En Solidity, escribir datos en el almacenamiento permanente de la blockchain consume recursos de red. En TRON, esto consume Energía. Los desarrolladores dedican mucho tiempo a optimizar los tipos de datos para ahorrarle dinero a los usuarios. (¿Tienes curiosidad sobre cómo funciona la Energía? Consulta nuestra Guía del Modelo de Comisiones.)

3. La Ejecución Revierte en Caso de Fallo

Si un script de Python falla a mitad de una actualización de base de datos, puede que tengas datos parcialmente actualizados. En Solidity, los cambios de estado son atómicos. Si una función falla o una declaración require() no se cumple, toda la transacción se revierte. Es como si nada hubiera ocurrido, aunque el usuario sigue pagando el costo de Energía por la ejecución fallida.

4. Sin Números de Punto Flotante

Las blockchains deben ser completamente deterministas (cada nodo debe calcular exactamente el mismo resultado). Dado que la aritmética de punto flotante (0.1 + 0.2 = 0.30000000000000004) puede variar ligeramente entre arquitecturas de CPU, Solidity no admite decimales.

Para representar 1.5 TRX, se usa como entero grande su unidad mínima (SUN): 1500000. No te preocupes por hacer esta conversión manualmente — tu frontend simplemente usará tronWeb.toSun(1.5) y tronWeb.fromSun(1500000) para gestionar las conversiones por el usuario.

---

Los Conceptos Fundamentales

Estos son los bloques de construcción esenciales que usarás al escribir contratos inteligentes en TRON.

1. Variables de Estado y Propiedades Globales

Las variables de estado se almacenan permanentemente en la blockchain. Solidity también provee “Variables Globales” que te dan información sobre la blockchain y la persona que llama al contrato.

pragma solidity ^0.8.18;

contract TypesExample {
    // Variables de estado (almacenadas permanentemente en la blockchain de TRON)
    uint256 public myNumber = 42;       // Entero sin signo (sin negativos)
    address public myAddress;           // Direcciones TRON (comienzan con T)
    bool public isActive = true;        // Booleano
    string public greeting = "Hello!";  // Texto

    function getCallerInfo() public view returns (address, uint256) {
        // Variables globales disponibles en cada función
        // msg.sender es inyectado automáticamente por la billetera TronLink del usuario
        address caller = msg.sender;
        uint256 timestamp = block.timestamp; // El tiempo del bloque actual

        return (caller, timestamp);
    }
}

2. Mappings (Diccionarios)

Si conoces los diccionarios de Python o los objetos de JavaScript, ya conoces los Mappings. Son la forma más eficiente en términos de Energía de almacenar datos clave-valor en la blockchain.

pragma solidity ^0.8.18;

contract MappingExample {
    // Un mapping de una dirección TRON a un saldo uint256
    mapping(address => uint256) public balances;

    function addBalance() public {
        // msg.sender es la billetera que ejecuta la transacción
        balances[msg.sender] += 100;
    }
}

3. Funciones, Modificadores y Payable

Las funciones son donde ocurre la lógica real. Puedes controlar quién puede llamar a una función usando modifiers. De forma única, las funciones pueden marcarse como payable, lo que significa que pueden recibir TRX directamente dentro de la transacción.

pragma solidity ^0.8.18;

contract FunctionsExample {
    address public owner;

    constructor() {
        // Se ejecuta una sola vez cuando el contrato es desplegado
        owner = msg.sender;
    }

    // Un modifier verifica una condición antes de que una función se ejecute
    modifier onlyOwner() {
        require(msg.sender == owner, "Only the owner can do this!");
        _; // Continuar ejecutando la función
    }

    // Una función que modifica el estado (consume Energía)
    function changeOwner(address newOwner) public onlyOwner {
        owner = newOwner;
    }

    // La palabra clave 'payable' permite que esta función reciba TRX
    function deposit() public payable {
        // msg.value se puebla automáticamente con la cantidad de TRX (en SUN) enviada por el usuario
        require(msg.value > 0, "Must send TRX!");
    }
}

4. Eventos

Los contratos inteligentes no pueden “comunicarse” fácilmente con el mundo exterior. En su lugar, emiten Eventos. Una aplicación frontend (usando tronweb) puede escuchar estos eventos y actualizar la interfaz de usuario cuando ocurren, lo que permite que las DApps estén sincronizadas en tiempo real.

pragma solidity ^0.8.18;

contract EventExample {
    // Declarar el evento
    event DataUpdated(address indexed user, uint256 newValue);

    function updateData(uint256 _value) public {
        // ... realizar lógica ...

        // Transmitir el evento a la red
        emit DataUpdated(msg.sender, _value);
    }
}

---

Plantillas Estándar (No Reinventes la Rueda)

En el desarrollo de software tradicional, usas paquetes y bibliotecas. En Web3, la seguridad es primordial, por lo que los desarrolladores dependen de contratos estándar auditados.

Si quieres crear un token TRC-20, no lo escribes desde cero. Importas código auditado de bibliotecas como OpenZeppelin. Dado que la TVM es compatible con EVM, los contratos estándar de Ethereum de OpenZeppelin funcionan perfectamente en TRON. (Para aprender más sobre la mecánica específica de los tokens de TRON, consulta nuestra Guía de Estándares de Tokens.)

---

Cómo Aprender Más

Solidity es un tema enorme, y esta página es solo el comienzo. A medida que construyas DApps más complejas en TRON, inevitablemente necesitarás buscar soluciones, patrones y tutoriales en línea.

Términos de Búsqueda para el Autoestudio

Cuando busques ayuda, no necesariamente tienes que añadir “TRON” a tus búsquedas. Las búsquedas generales de Solidity funcionan perfectamente. Prueba buscando:

• “Solidity mappings vs arrays”
• “OpenZeppelin ERC-20 tutorial” (¡Recuerda, el código ERC-20 es idéntico al código TRC-20!)
• “Solidity reentrancy guard example”
• “Solidity interface and abstract contracts”

Una Nota sobre las Guías de Ethereum

Encontrarás que el 99% de los tutoriales de Solidity, foros y respuestas en StackOverflow que encuentres en línea están escritos para Ethereum. Esto está perfectamente bien. Puedes copiar, pegar y aprender del código de Solidity de Ethereum directamente.

Sin embargo, hay algunas diferencias menores en cómo TRON maneja las cosas internamente (por ejemplo, TRON usa Energía y Ancho de banda en lugar del sistema de Gas unificado de Ethereum, y los bloques de TRON son más rápidos).

Traduciendo a TRON

Si estás siguiendo una guía de Ethereum y encuentras términos como Gas, Gwei o MetaMask, ¡no te preocupes! Hemos creado guías de mapeo dedicadas para ayudarte a traducir estos conceptos a TRON sin dificultad.

• Para un resumen general de conceptos entre las principales blockchains (Ethereum, Solana, BSC, Bitcoin), consulta nuestro Mapa de Conceptos entre Cadenas.
• Para una traducción detallada y profunda específicamente del EVM de Ethereum al TVM de TRON, consulta nuestra Guía de Ethereum a TRON.

Ahora que tienes una base en el lenguaje, guarda en favoritos nuestra página de Referencia Rápida. Contiene todos los endpoints de red de TRON, IDs de cadena y fragmentos de inicialización esenciales que necesitarás al empezar a construir tu DApp.