Primeros Pasos

Esta guía es tu rampa de lanzamiento al ecosistema de TRON. Al finalizarla, no solo habrás desplegado un contrato inteligente, sino que comprenderás las herramientas subyacentes, la gestión de recursos y cómo conectar tu entorno local a la red de forma segura. Asumimos conocimientos básicos de JavaScript y Solidity — comencemos a construir.

Requisitos Previos: Tu Kit de Herramientas

Antes de escribir cualquier código, asegúrate de que tu entorno local tenga los elementos esenciales:

Node.js v18 o superior (node --version)
npm o yarn
Extensión de navegador TronLink (tu puente con la red)

Paso 1 — Crea tu Entorno de Desarrollo (Billetera)

Nunca debes mezclar tus fondos personales con el desarrollo. Las herramientas de desarrollo requieren acceso a claves privadas para firmar despliegues, y al crear una billetera “sandbox” dedicada y aislada, eliminas por completo el riesgo de quemar TRX real en un script de prueba fallido.

Abre TronLink y haz clic en el ícono de cuenta → Add Account → Create Account.
Asígnale un nombre claro, como “Dev - Testnet”.
Guarda la frase semilla. Sí, es una billetera de desarrollo, pero perder el acceso significa perder el historial de tu red de prueba y tener que configurar todo de nuevo.
Copia la dirección de la billetera (prefijo T, 34 caracteres). Esta es tu identidad en la red.

Paso 2 — Obtén TRX en la Red de Prueba

Cada operación que modifica la blockchain (como desplegar un contrato) consume recursos de red (Energía y Ancho de banda). En la red principal, esto cuesta TRX real. En una red de prueba, usas “TRX de Red de Prueba” gratuito y sin valor real para simular estos costos sin riesgo financiero.

TRON mantiene dos redes de prueba públicas principales:

Nile: La red de prueba de vanguardia. Generalmente contiene las últimas actualizaciones del protocolo, lo que la convierte en el mejor lugar para probar nuevas funciones.
Shasta: La red de prueba estable. Refleja perfectamente el entorno de la red principal, ideal para las pruebas finales de staging.

Para el desarrollo general y para seguir esta guía, usaremos Nile, el sandbox estándar para nuevos desarrolladores. Vamos a financiar tu billetera:

Ve al Faucet de Nile.
Pega la dirección de tu nueva billetera de desarrollo, completa el reCAPTCHA y haz clic en Obtain.
Verifica el depósito: Revisa tu saldo en el Explorador de Nile (TRONSCAN).

Paso 3 — Instala TronBox (Tu Centro de Control)

Compilar Solidity a bytecode y enviarlo manualmente a la blockchain mediante solicitudes HTTP sin procesar es tedioso y propenso a errores. TronBox es el framework estándar que automatiza el flujo de compilación, despliegue y pruebas, manteniendo tu proyecto organizado.

# Tarea: Instalar el framework TronBox de forma global para poder usarlo desde cualquier directorio.
npm install -g tronbox
tronbox --version

Inicializa Tu Proyecto

Vamos a crear un directorio de trabajo limpio:

# Tarea: Inicializar un nuevo proyecto TronBox para generar la estructura de directorios necesaria.
mkdir my-tron-project
cd my-tron-project
tronbox init

TronBox crea una estructura estándar:

/contracts/: Donde viven tus archivos Solidity.
/migrations/: Scripts que dictan exactamente cómo se deben desplegar tus contratos.
/test/: Donde escribirás las pruebas para garantizar que tu lógica sea sólida.
tronbox.js: El archivo de configuración principal.

Paso 4 — Configura la Red (tronbox.js)

TronBox necesita saber dónde desplegar tus contratos (los endpoints de red) y quién paga el despliegue (la clave privada de tu billetera de desarrollo). Usamos variables de entorno (.env) para inyectar la clave privada de forma dinámica, de modo que nunca quede escrita directamente en tus archivos fuente.

Reemplaza el contenido de tronbox.js con esta configuración:

// Tarea: Indicarle a TronBox cómo conectarse a la red de prueba Nile de forma segura.
module.exports = {
  networks: {
    nile: {
      privateKey: process.env.PRIVATE_KEY_NILE,
      userFeePercentage: 100,
      feeLimit: 1000000000,
      fullHost: 'https://nile.trongrid.io',
      network_id: '3',
    },
    mainnet: {
      privateKey: process.env.PRIVATE_KEY_MAINNET,
      userFeePercentage: 100,
      feeLimit: 1000000000,
      fullHost: 'https://api.trongrid.io',
      network_id: '1',
    },
  },
  compilers: {
    solc: {
      version: '0.8.18',
    },
  },
};

Crea un archivo .env en la raíz de tu proyecto (¡y agrégalo inmediatamente a tu .gitignore!):

# Tarea: Almacenar tu clave privada de la red de prueba de forma segura, fuera del control de versiones.
PRIVATE_KEY_NILE=your_nile_dev_wallet_private_key_here

(Para obtener tu clave privada: Abre TronLink → selecciona tu cuenta de desarrollo → haz clic en el menú de tres puntos → Export Account).

Paso 5 — Escribe y Compila Tu Primer Contrato

La Máquina Virtual de TRON (TVM) es altamente compatible con la Máquina Virtual de Ethereum (EVM). Esto significa que escribimos nuestros contratos en Solidity. Al compilar, TronBox traduce este Solidity legible por humanos a bytecode legible por máquinas y genera un ABI (Interfaz Binaria de Aplicación), que sirve como “manual” para que los frontends puedan interactuar con el contrato.

Crea un nuevo archivo en contracts/SimpleStorage.sol:

// Tarea: Definir un contrato mínimo que almacene y recupere un solo número.
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.18;

contract SimpleStorage {
    uint256 private value;

    // Los eventos permiten que los frontends escuchen cambios en la blockchain
    event ValueSet(uint256 indexed newValue, address indexed setter);

    // Las funciones 'external' pueden ser llamadas por usuarios u otros contratos
    function set(uint256 _value) external {
        value = _value;
        emit ValueSet(_value, msg.sender);
    }

    // 'view' significa que esta función lee datos pero no modifica la blockchain
    function get() external view returns (uint256) {
        return value;
    }
}

Ahora, ordénale a TronBox que lo compile:

# Tarea: Traducir el código Solidity a bytecode y ABI listos para la TVM.
tronbox compile

Revisa la carpeta build/contracts/. TronBox acaba de generar los artefactos necesarios para el despliegue.

Paso 6 — Define el Despliegue (Migración)

Una blockchain es una máquina de estados. “Migrar” simplemente significa llevar la blockchain de su estado actual a un nuevo estado que incluya tu contrato. El script de migración le dice a TronBox exactamente qué contratos desplegar y en qué orden.

Crea migrations/2_deploy_simple_storage.js:

// Tarea: Indicarle a TronBox que despliegue el artefacto del contrato SimpleStorage.
const SimpleStorage = artifacts.require('SimpleStorage');

module.exports = function (deployer) {
  deployer.deploy(SimpleStorage);
};

Paso 7 — Lanza a la Red de Prueba Nile

Es hora de hacerlo real. Al ejecutar el comando de migración, TronBox construirá una transacción de despliegue, la firmará con tu clave privada del .env y la transmitirá a la red Nile. La red deducirá TRX de Red de Prueba (Energía/Ancho de banda) para almacenar permanentemente el bytecode de tu contrato.

# Tarea: Transmitir tu contrato a la red para que esté activo.
source .env   # Carga tu clave privada en la sesión del terminal
tronbox migrate --network nile

Observa el terminal. TronBox mostrará la dirección del contrato desplegado (comenzando con T...). Copia esta dirección.

Verificación de éxito: Ve a nile.tronscan.org y busca la dirección de tu nuevo contrato. Verás la Energía exacta consumida y la transacción de despliegue verificada. Estás oficialmente en vivo en TRON.

Paso 8 — Interactúa Usando TronWeb

Un contrato inteligente no es muy útil si nadie puede comunicarse con él. tronweb es el SDK oficial de JavaScript. Lo usamos para conectar un script de Node.js (o un frontend en React) directamente a la blockchain y ejecutar nuestras funciones set() y get().

Primero, instala el SDK:

# Tarea: Añadir el SDK de TronWeb a tu proyecto para habilitar la comunicación con la blockchain.
npm install tronweb

Crea scripts/interact.js:

// Tarea: Usar TronWeb para leer y escribir en tu contrato en vivo.
import TronWeb from "tronweb"

// Inicializar TronWeb con el endpoint de Nile y tu clave de desarrollo
const tronWeb = new TronWeb({
  fullHost: 'https://nile.trongrid.io',
  privateKey: process.env.PRIVATE_KEY_NILE,
});

const CONTRACT_ADDRESS = 'T...'; // ¡Pega aquí tu dirección desplegada!

async function main() {
  // Cargar el ABI para que TronWeb sepa qué funciones existen
  const contract = await tronWeb.contract().at(CONTRACT_ADDRESS);

  console.log('Ejecutando operación de escritura...');
  // .send() crea una transacción, consume Energía y altera el estado de la blockchain
  const tx = await contract.set(42).send();
  console.log('Hash de la transacción:', tx);

  console.log('Ejecutando operación de lectura...');
  // .call() es una consulta local gratuita a un nodo. No altera el estado.
  const result = await contract.get().call();
  console.log('Valor almacenado actualmente en cadena:', result.toString());
}

main().catch(console.error);

Ejecuta tu script de interacción:

# Tarea: Ejecutar el script para comunicarse con la red de prueba Nile.
node scripts/interact.js

Estás Listo para Construir

¡Felicidades! Has completado con éxito el ciclo de vida completo del desarrollo de DApps en TRON. Ahora tienes:

Una billetera de desarrollo segura financiada con TRX de la red de prueba.
TronBox configurado para gestionar tus compilaciones y despliegues.
Un contrato inteligente en vivo funcionando en la red de prueba Nile.
Un script de Node.js que usa tronweb para leer y escribir en la blockchain.

Tienes los cimientos. Ahora es momento de construir algo complejo.

Próximos Pasos

Fundamentos de Solidity

¿Necesitas repasar el lenguaje? Revisa la sintaxis de Solidity, la compatibilidad con EVM y los patrones específicos de TRON.

Leer el Fundamento →

Contratos Inteligentes

¿Listo para escribir lógica compleja? Profundiza en los comportamientos específicos de la TVM y las técnicas de optimización de Energía.

Explorar los Contratos Inteligentes de la TVM →

SDK tronweb

¿Quieres crear un frontend? Consulta la referencia completa para gestión de cuentas, firma de transacciones y escucha de eventos.

Dominar el SDK →

Modelo de Comisiones y Recursos

¿Te preguntas por qué los despliegues consumen Energía? Aprende cómo el modelo de recursos de TRON difiere del gas tradicional.

Entender las Comisiones de TRON →