Estándares de Tokens

TRON admite una amplia gama de estándares de tokens para potenciar tus aplicaciones descentralizadas, desde activos nativos TRC-10 hasta tokens TRC-20 y TRC-721 compatibles con la EVM. Explora las especificaciones técnicas, los patrones de implementación y las diferencias clave entre los estándares fungibles, no fungibles y multi-token.

TRON tiene cuatro estándares de tokens. Tres son contratos inteligentes en la TVM (TRC-20, TRC-721, TRC-1155); uno es un sistema nativo del protocolo (TRC-10) que es anterior a la TVM y no requiere ningún código de contrato.

Comparación

Estándar	Tipo	Equivalente EVM	Contrato inteligente	Recursos requeridos
TRC-10	Nativo fungible	—	No	Solo Ancho de banda
TRC-20	Contrato fungible	ERC-20	Sí	Ancho de banda + Energía
TRC-721	NFT de contrato	ERC-721	Sí	Ancho de banda + Energía
TRC-1155	Multi-token de contrato	ERC-1155	Sí	Ancho de banda + Energía

TRC-10 — Tokens Nativos del Protocolo

Los tokens TRC-10 son emitidos directamente por el protocolo de TRON sin desplegar un contrato inteligente. Las transferencias usan transacciones del sistema en lugar de la ejecución de la TVM, por lo que solo cuestan Ancho de banda — no se requiere Energía.

Emitir un Token TRC-10

Emite a través de la API AssetIssueContract o mediante la interfaz de emisión de tokens de TRONSCAN.

Costo: Comisión de emisión de 1,024 TRX
Límite: Un token TRC-10 por cuenta

Parámetros clave:

name — nombre del token (se muestra en las billeteras)
abbr — símbolo del ticker
total_supply — suministro total fijo
precision — decimales (0–6)
start_time / end_time — ventana de venta pública opcional
trx_num / num — tasa de cambio para la venta pública (TRX por token)

Transferir Tokens TRC-10

// Tarea: Enviar tokens TRC-10 nativos usando su ID numérico.
await tronWeb.trx.sendToken(
  'TRecipientAddress...',
  1000,                   // monto
  '1000001',              // ID del token (cadena numérica)
);

Limitaciones de TRC-10

Sin lógica de contrato personalizada — libro de saldos puro
Sin mecanismo approve/transferFrom
No se puede usar directamente en la mayoría de los protocolos DeFi, que requieren TRC-20
No se puede componer con contratos inteligentes

TRC-10 no se recomienda para proyectos nuevos. Usa TRC-20 a menos que tengas una razón específica para evitar los costos de ejecución de contratos inteligentes (por ejemplo, micro-transferencias de muy alta frecuencia donde los costos de Energía son prohibitivos).

TRC-20 — Tokens Fungibles

TRC-20 es el estándar de token fungible de contrato inteligente de TRON, funcionalmente idéntico al ERC-20 de Ethereum. Las implementaciones estándar ERC-20 de OpenZeppelin se compilan y despliegan en TRON sin cambios en la interfaz — revisa solo las diferencias específicas de la TVM (marcas de tiempo, comportamiento actualizado de SELFDESTRUCT) antes de desplegar.

(Para desarrolladores de Web2: Un token no es una moneda física que se mueve por la red. Un token TRC-20 es simplemente un contrato inteligente que contiene un gran diccionario o “libro de contabilidad” que rastrea cuántos tokens posee cada dirección. Una “transferencia” es solo una llamada a función que deduce del saldo del remitente y añade al saldo del destinatario dentro de la base de datos interna de este contrato).

Interfaz

// Tarea: Definir la interfaz estándar del token fungible TRC-20.
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.18;

interface ITRC20 {
    function totalSupply() external view returns (uint256);
    function balanceOf(address account) external view returns (uint256);
    function transfer(address to, uint256 amount) external returns (bool);
    function allowance(address owner, address spender) external view returns (uint256);
    function approve(address spender, uint256 amount) external returns (bool);
    function transferFrom(address from, address to, uint256 amount) external returns (bool);

    event Transfer(address indexed from, address indexed to, uint256 value);
    event Approval(address indexed owner, address indexed spender, uint256 value);
}

Interactuar con TRC-20 mediante tronweb

// Tarea: Realizar operaciones comunes con TRC-20: saldo, transferencia, aprobación.
const contract = await tronWeb.contract().at('TContractAddress...');

// Leer saldo (llamada view — sin costo de Energía)
const raw = await contract.balanceOf('TUserAddress...').call();
const amount = raw / 1e6; // ajustar por los decimales del token

// Transferir (cambia estado — consume Energía)
await contract.transfer('TRecipient...', 10_000_000).send({
  feeLimit: 150_000_000,  // máximo 150 TRX
  shouldPollResponse: true,
});

// Aprobar un gastador
await contract.approve('TSpender...', 1_000_000_000).send({
  feeLimit: 50_000_000,
});

Direcciones TRC-20 Principales en la Red Principal

USDT:  TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t
USDD:  TPYmHEhy5n8TCEfYGqW2rPxsghSfzghPDn
WTRX:  TNUC9Qb1rRpS5CbWLmNMxXBjyFoydXjWFR
SUN:   TSSMHYeV2uE9qYH95DqyoCuNCzEL1NvU3S
JST:   TCFLL5dx5ZJdKnWuesXxi1VPwjLVmWZZy9

Costo de Energía

El costo base de Energía para una transferencia de USDT es ~14,650 (titular existente) o ~29,650 (cuenta nueva con saldo cero). Bajo el Modelo de Energía Dinámica (DEM), se aplica una penalización por congestión de hasta el 340%, elevando el pico teórico a ~64,460 (titular existente) o ~130,460 de Energía (cuenta nueva). Configura los límites de comisiones en consecuencia — un valor seguro predeterminado es 20 TRX (feeLimit: 20_000_000).

TRC-721 — Tokens No Fungibles

TRC-721 es el estándar de NFTs de TRON, equivalente al ERC-721 de Ethereum. Las firmas de función son idénticas. Existe una diferencia crítica específica de TRON en el callback receptor de transferencia segura que causa fallos difíciles de depurar al migrar desde Ethereum.

Interfaz

// Tarea: Definir la interfaz estándar de NFT TRC-721.
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.18;

interface ITRC721 {
    function balanceOf(address _owner) external view returns (uint256);
    function ownerOf(uint256 _tokenId) external view returns (address);
    function transferFrom(address _from, address _to, uint256 _tokenId) external payable;
    function safeTransferFrom(address _from, address _to, uint256 _tokenId) external payable;
    function safeTransferFrom(address _from, address _to, uint256 _tokenId, bytes calldata _data) external payable;
    function approve(address _approved, uint256 _tokenId) external payable;
    function setApprovalForAll(address _operator, bool _approved) external;
    function getApproved(uint256 _tokenId) external view returns (address);
    function isApprovedForAll(address _owner, address _operator) external view returns (bool);

    event Transfer(address indexed _from, address indexed _to, uint256 indexed _tokenId);
    event Approval(address indexed _owner, address indexed _approved, uint256 indexed _tokenId);
    event ApprovalForAll(address indexed _owner, address indexed _operator, bool _approved);
}

Cuando safeTransferFrom envía a una dirección de contrato, la TVM llama a un callback receptor. El selector difiere de Ethereum — usar el callback de Ethereum hará que cada transferencia segura revierta silenciosamente.

Red	Función	Selector
Ethereum	`onERC721Received`	`0x150b7a02`
TRON	`onTRC721Received`	`0x5175f878`

Contrato Receptor TRC-721 Correcto

Todo contrato que reciba tokens TRC-721 mediante safeTransferFrom debe implementar:

// Tarea: Implementar el callback onTRC721Received con el selector correcto de TRON.
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.18;

contract TRC721Receiver {
    function onTRC721Received(
        address _operator,
        address _from,
        uint256 _tokenId,
        bytes calldata _data
    ) external returns (bytes4) {
        // Debe devolver el selector TRC-721: 0x5175f878
        return bytes4(keccak256("onTRC721Received(address,address,uint256,bytes)"));
    }
}

Extensiones Opcionales

Metadatos:

// Tarea: Definir la extensión de metadatos de NFT para nombres y URIs.
interface ITRC721Metadata {
    function name() external view returns (string memory);
    function symbol() external view returns (string memory);
    function tokenURI(uint256 _tokenId) external view returns (string memory);
}

Enumeración:

// Tarea: Definir la extensión de enumeración de NFT para indexación en cadena.
interface ITRC721Enumerable {
    function totalSupply() external view returns (uint256);
    function tokenByIndex(uint256 _index) external view returns (uint256);
    function tokenOfOwnerByIndex(address _owner, uint256 _index) external view returns (uint256);
}

Costo Mínimo de Despliegue

El despliegue de un contrato TRC-721 requiere un mínimo de aproximadamente 350 TRX en quema de Energía a las tarifas actuales de la red (más Ancho de banda por los bytes de la transacción). Usa la guía del Modelo de Comisiones para estimar los costos antes de desplegar.

TRC-1155 — Estándar Multi-Token

TRC-1155 es el estándar multi-token de TRON, equivalente al ERC-1155 de Ethereum. Un único contrato gestiona múltiples tipos de tokens — tanto fungibles como no fungibles — y admite operaciones por lotes que reducen el costo total de Energía al transferir muchos tokens en una sola llamada.

Interfaz

// Tarea: Definir la interfaz del estándar multi-token TRC-1155.
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.18;

interface ITRC1155 {
    function safeTransferFrom(address from, address to, uint256 id, uint256 value, bytes calldata data) external;
    function safeBatchTransferFrom(address from, address to, uint256[] calldata ids, uint256[] calldata values, bytes calldata data) external;
    function balanceOf(address owner, uint256 id) external view returns (uint256);
    function balanceOfBatch(address[] calldata owners, uint256[] calldata ids) external view returns (uint256[] memory);
    function setApprovalForAll(address operator, bool approved) external;
    function isApprovedForAll(address owner, address operator) external view returns (bool);

    event TransferSingle(address indexed operator, address indexed from, address indexed to, uint256 id, uint256 value);
    event TransferBatch(address indexed operator, address indexed from, address indexed to, uint256[] ids, uint256[] values);
    event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
    event URI(string value, uint256 indexed id);
}

Extensión de Metadatos Opcional

// Tarea: Definir la extensión de URI de metadatos para el multi-token.
interface ITRC1155MetadataURI {
    function uri(uint256 id) external view returns (string memory);
}

Transferencias por Lotes

La ventaja principal de TRC-1155 sobre múltiples llamadas TRC-721 es la eficiencia de Energía. Una llamada safeBatchTransferFrom transfiere N IDs de tokens en una sola transacción, pagando Ancho de banda y Energía una sola vez en lugar de N veces:

// Tarea: Realizar una transferencia por lotes eficiente de múltiples IDs de tokens.
contract.safeBatchTransferFrom(
    from,
    to,
    [tokenId1, tokenId2, tokenId3],     // IDs
    [amount1, amount2, amount3],         // montos
    "0x"
);

Guía de Decisión TRC-721 vs. TRC-1155

Caso de uso	Estándar
Colección de NFTs clásica con propiedad única	TRC-721
Inventario de juego: muchos tipos de ítems, algunos fungibles	TRC-1155
Minteo por lotes o transferencias por lotes	TRC-1155
Máxima compatibilidad con las herramientas de NFT existentes	TRC-721
Un único contrato que gestiona tokens fungibles y no fungibles	TRC-1155

Estándar de Token por Costo de Transacción

Operación	Costo aproximado de Energía
Desplegar TRC-20 (OpenZeppelin estándar)	200,000–400,000
Transferencia TRC-20	14,650–29,650 base (×4.4 pico DEM)
Aprobación TRC-20	20,000–30,000
Desplegar TRC-721	500,000–900,000
Minteo TRC-721	80,000–150,000
Transferencia segura TRC-721	60,000–100,000
Transferencia por lotes TRC-1155 (10 ítems)	100,000–180,000

Estas son estimaciones base con energy_factor = 0. El Modelo de Energía Dinámica puede multiplicar los costos hasta 3.4× para contratos de alta demanda. Siempre simula con triggerconstantcontract en la red principal antes de configurar los límites de comisiones.