TRC-20 La norme de jeton fongible sur Tron

TRC-20 est la norme de jeton fongible de Tron, analogue à ERC-20 sur [Ethereum](https://onekey.so/blog/fr/ecosystem/what-is-ethereum/), et la colonne vertébrale de la plupart des stablecoins, jetons d'échange et actifs de paiement dans l'écosystème Tron. Avec des frais constamment bas, une finalité instantanée et une large base d'utilisateurs particuliers, Tron est devenu un lieu privilégié pour le transfert de valeur quotidien—en particulier pour les stablecoins—faisant de TRC-20 une primitive essentielle pour les développeurs comme pour les utilisateurs. Cet article explique le fonctionnement de la norme, ce qui la différencie et comment l'utiliser en toute sécurité en 2025.

## Qu'est-ce que TRC-20 ?

TRC-20 définit une interface minimale pour les jetons fongibles sur les contrats intelligents compatibles avec la Tron Virtual Machine (TVM). Il spécifie des fonctions de base comme `totalSupply`, `balanceOf`, `transfer`, `allowance`, et `transferFrom`, ainsi que des événements standard pour les transferts et les approbations. La spécification canonique est publiée sous la forme d'une proposition d'amélioration de Tron : [TIP-20 : Norme de jeton TRC-20](https://github.com/tronprotocol/tips/blob/master/tip-20.md).

Pour les développeurs, TRC-20 est familier si vous avez déjà développé sur [Ethereum](https://onekey.so/blog/fr/ecosystem/what-is-ethereum/) : Solidity est utilisé pour écrire les contrats, et la TVM maintient la compatibilité avec une grande partie de l'ensemble d'instructions de l'EVM. Vous pouvez en apprendre davantage sur la TVM et la pile de développement Tron dans la documentation officielle : [Tron Virtual Machine](https://developers.tron.network/docs/tron-vm).

## Pourquoi TRC-20 est important aujourd'hui

- Rail de stablecoin pour les paiements : L'USDT émis nativement sur Tron est largement utilisé pour les transferts et les règlements en raison de sa vitesse et de ses faibles coûts. Vous pouvez vérifier la distribution sur la chaîne sur la page de transparence de Tether : [Transparence Tether](https://tether.to/en/transparency).
- Modèle de coûts et débit : Le modèle de ressources de Tron (bande passante et énergie) maintient les coûts de transaction prévisibles et généralement bas, ce qui profite aux transferts fréquents et de petite taille. Voir les détails ici : [Modèle de ressources de Tron](https://developers.tron.network/docs/resource-model).
- Croissance et activité des utilisateurs : Tron a maintenu une activité quotidienne et des transferts de jetons élevés ; vous pouvez consulter les statistiques quasi en temps réel sur [TRONSCAN Analytics](https://tronscan.org/#/data/stats).

Note sur les changements du marché : Circle a mis fin au support de l'[USDC](https://onekey.so/blog/fr/ecosystem/what-is-usd-coin-usdc/) natif sur Tron en 2024 ; les équipes et les utilisateurs doivent en tenir compte lors du choix des rails de stablecoin. Référence : [Fin du support de l'USDC sur le réseau TRON (Circle)](https://www.circle.com/blog/usdc-on-tron-network-ends).

## Comparaison de TRC-20 à ERC-20

- Parité d'interface : TRC-20 reflète ERC-20 au niveau des fonctions/événements, ce qui facilite la portabilité des contrats.
- Environnement d'exécution : TVM vs EVM — la TVM de Tron est compatible avec Solidity, mais pas identique. Testez toujours les cas limites.
- Frais et ressources : Tron remplace le gaz par transaction par la bande passante et l'énergie. Les utilisateurs peuvent staker des TRX pour obtenir ces ressources ou payer à la demande. Les développeurs doivent concevoir l'UX en tenant compte de l'estimation des ressources. Voir : [Modèle de ressources](https://developers.tron.network/docs/resource-model).

## Le parcours du développeur : du contrat au mainnet

1. Concevez et implémentez votre contrat de jeton.
2. Testez localement dans un environnement compatible TVM.
3. Déployez en utilisant TronWeb ou des SDK similaires.
4. Vérifiez le contrat sur TRONSCAN et publiez vos métadonnées.
5. Développez les flux de transfert, d'autorisation et d'administration de manière réfléchie (rôles de mint/burn/propriétaire) pour atténuer les risques.

Ressources utiles :
- Documentation standard TRON : [TIP-20](https://github.com/tronprotocol/tips/blob/master/tip-20.md)
- Aperçu du SDK : [Introduction à TronWeb](https://developers.tron.network/docs/tronweb-introduction)
- Vérification de contrat : [Comment vérifier un contrat sur TRONSCAN](https://support.tronscan.org/hc/en-us/articles/900005666986-How-to-verify-contract)
- Explorer les jetons TRC-20 : [Répertoire des jetons TRONSCAN](https://tronscan.org/#/tokens/trc20)

### Exemple TRC-20 minimal (Solidity)

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

// Note : La TVM est compatible avec Solidity, mais toujours tester sur Tron.
// Ceci est un exemple minimal et omet les modèles de sécurité avancés.

[contract](https://onekey.so/blog/fr/ecosystem/what-is-a-smart-contract/) ExampleTRC20 {
    string public name = "Example Token";
    string public symbol = "EXM";
    uint8 public decimals = 6; // Les jetons Tron utilisent souvent 6 décimales
    uint256 public totalSupply;

    mapping(address => uint256) private _balance;
    mapping(address => mapping(address => uint256)) private _allowance;

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

    constructor(uint256 initialSupply) {
        _mint(msg.sender, initialSupply);
    }

    function balanceOf(address account) external view returns (uint256) {
        return _balance[account];
    }

    function transfer(address to, uint256 amount) external returns (bool) {
        _transfer(msg.sender, to, amount);
        return true;
    }

    function allowance(address owner, address spender) external view returns (uint256) {
        return _allowance[owner][spender];
    }

    function approve(address spender, uint256 amount) external returns (bool) {
        _allowance[msg.sender][spender] = amount;
        emit Approval(msg.sender, spender, amount);
        return true;
    }

    function transferFrom(address from, address to, uint256 amount) external returns (bool) {
        uint256 allowed = _allowance[from][msg.sender];
        require(allowed >= amount, "Allowance exceeded");
        _allowance[from][msg.sender] = allowed - amount;
        _transfer(from, to, amount);
        return true;
    }

    // Mint/burn optionnels (être explicite sur le contrôle d'accès en production)
    function _mint(address to, uint256 amount) internal {
        totalSupply += amount;
        _balance[to] += amount;
        emit Transfer(address(0), to, amount);
    }

    function _burn(address from, uint256 amount) internal {
        require(_balance[from] >= amount, "Insufficient balance");
        _balance[from] -= amount;
        totalSupply -= amount;
        emit Transfer(from, address(0), amount);
    }

    function _transfer([address](https://onekey.so/blog/fr/ecosystem/what-is-a-crypto-wallet-address/) from, [address](https://onekey.so/blog/fr/ecosystem/what-is-a-crypto-wallet-address/) to, uint256 amount) internal {
        require(_balance[from] >= amount, "Insufficient balance");
        require(to != [address](https://onekey.so/blog/fr/ecosystem/what-is-a-crypto-wallet-address/)(0), "Invalid recipient");
        _balance[from] -= amount;
        _balance[to] += amount;
        emit Transfer(from, to, amount);
    }
}