ERC-20 vs ERC-721 vs ERC-1155 — Quel Standard de Token Utiliser

# ERC-20 vs ERC-721 vs ERC-1155 — Quel Standard de Token Utiliser

Choisir le bon standard de token est une décision cruciale pour tout projet blockchain. Les trois standards ERC dominent l'écosystème Ethereum, chacun avec ses caractéristiques uniques et cas d'usage spécifiques.

Vue d'Ensemble des Standards

ERC-20 : Tokens Fongibles

Le standard ERC-20, proposé en 2015, reste le plus utilisé pour les tokens fongibles. Chaque token est identique et interchangeable, comme des pièces de monnaie.

Caractéristiques principales :

• Tokens interchangeables (1 token = 1 token)

• Supply totale ou illimitée

• Interface simple avec 6 fonctions obligatoires

• Idéal pour les cryptomonnaies, stablecoins, tokens de gouvernance

Interface minimale :

interface IERC20 {
    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);
}

ERC-721 : NFTs (Non-Fungible Tokens)

Introduit en 2018, l'ERC-721 révolutionne la propriété numérique en rendant chaque token unique et non-interchangeable.

Caractéristiques principales :

• Chaque token possède un ID unique

• Métadonnées associées (nom, image, propriétés)

• Parfait pour l'art numérique, objets de collection, immobilier tokenisé

• Interface plus complexe avec ownership tracking

Interface core :

interface IERC721 {
    function balanceOf(address owner) external view returns (uint256);
    function ownerOf(uint256 tokenId) external view returns (address);
    function safeTransferFrom(address from, address to, uint256 tokenId) external;
    function transferFrom(address from, address to, uint256 tokenId) external;
    function approve(address to, uint256 tokenId) external;
    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);
}

ERC-1155 : Multi-Token Standard

Le standard ERC-1155, créé par Enjin en 2019, combine le meilleur des deux mondes en permettant des tokens fongibles ET non-fongibles dans un seul contrat.

Caractéristiques principales :

• Gestion de multiples types de tokens dans un contrat

• Batch transfers (réduisant drastiquement le gas)

• Fongible et non-fongible dans la même collection

• Parfait pour les jeux vidéo, plateformes multi-actifs

Interface batch-optimisée :

interface IERC1155 {
    function balanceOf(address account, uint256 id) external view returns (uint256);
    function balanceOfBatch(address[] calldata accounts, uint256[] calldata ids)
        external view returns (uint256[] memory);
    function safeTransferFrom(address from, address to, uint256 id, uint256 amount, bytes calldata data) external;
    function safeBatchTransferFrom(address from, address to, uint256[] calldata ids,
        uint256[] calldata amounts, bytes calldata data) external;
    function setApprovalForAll(address operator, bool approved) external;
    function isApprovedForAll(address account, address operator) external view returns (bool);
}

Comparaison des Coûts en Gas

Le coût en gas varie significativement selon le standard et l'opération.

Déploiement

| Standard | Gas de Déploiement | Commentaire |

|----------|------------------|-------------|

| ERC-20 | ~1,200,000 | Le plus léger |

| ERC-721 | ~2,500,000 | Logique d'ownership complexe |

| ERC-1155 | ~2,800,000 | Support multi-token |

Minting

| Standard | Mint Simple | Mint 10 Tokens |

|----------|------------|----------------|

| ERC-20 | ~50,000 | ~50,000 (batch natif) |

| ERC-721 | ~80,000 | ~800,000 (10 tx) |

| ERC-1155 | ~85,000 | ~200,000 (batch) |

Avantage ERC-1155 : Le batch minting réduit le coût de 60-70% pour des opérations multiples.

Transfers

| Standard | Transfer Simple | Transfer 10 Items |

|----------|----------------|------------------|

| ERC-20 | ~65,000 | ~650,000 (10 tx) |

| ERC-721 | ~85,000 | ~850,000 (10 tx) |

| ERC-1155 | ~90,000 | ~180,000 (batch) |

Cas d'Usage par Standard

Quand Utiliser ERC-20

Idéal pour :

• Cryptomonnaies et tokens de projet

• Stablecoins (USDC, DAI)

• Tokens de gouvernance (UNI, AAVE)

• Rewards et points de fidélité

• Tokens de liquidité (LP tokens)

Exemple concret :

// Token de gouvernance simple
contract GovernanceToken is ERC20 {
    constructor() ERC20("MyDAO Token", "MDAO") {
        _mint(msg.sender, 1_000_000 * 10**18);
    }

    function mint(address to, uint256 amount) external onlyOwner {
        _mint(to, amount);
    }
}

Quand Utiliser ERC-721

Idéal pour :

• Art numérique et NFT collectibles

• Immobilier tokenisé

• Certificats d'authenticité

• Tickets d'événements uniques

• Noms de domaine (ENS)

• Identité numérique

Exemple concret :

// Collection NFT avec metadata
contract ArtCollection is ERC721URIStorage {
    uint256 private _tokenIds;

    constructor() ERC721("CryptoArt", "CART") {}

    function mint(address to, string memory tokenURI) external returns (uint256) {
        _tokenIds++;
        _mint(to, _tokenIds);
        _setTokenURI(_tokenIds, tokenURI);
        return _tokenIds;
    }
}

Quand Utiliser ERC-1155

Idéal pour :

• Jeux vidéo (objets, armes, skins)

• Plateformes multi-actifs (marketplace)

• Fractionalized NFTs

• Tickets d'événements (multiples catégories)

• Collections avec variantes (ex: cartes à collectionner)

Exemple concret :

// Système d'objets de jeu
contract GameItems is ERC1155 {
    uint256 public constant SWORD = 0;
    uint256 public constant SHIELD = 1;
    uint256 public constant POTION = 2;

    constructor() ERC1155("https://game.com/api/item/{id}.json") {}

    function craftItem(uint256 itemId, uint256 amount) external {
        require(itemId <= POTION, "Invalid item");
        _mint(msg.sender, itemId, amount, "");
    }

    function batchCraft(uint256[] memory ids, uint256[] memory amounts) external {
        _mintBatch(msg.sender, ids, amounts, "");
    }
}

Complexité de Développement

ERC-20 : Simplicité

• Courbe d'apprentissage : Faible

• Lignes de code : ~100-200

• Time to market : 1-2 jours

• Extensions courantes : Burnable, Mintable, Pausable, Snapshot

ERC-721 : Moyenne

• Courbe d'apprentissage : Moyenne

• Lignes de code : ~300-500

• Time to market : 3-5 jours

• Extensions courantes : URIStorage, Enumerable, Royalties (EIP-2981)

ERC-1155 : Avancée

• Courbe d'apprentissage : Élevée

• Lignes de code : ~400-700

• Time to market : 5-10 jours

• Extensions courantes : Supply tracking, URI per token, Access control

Écosystème et Support

ERC-20

• Wallets : Support universel (MetaMask, Ledger, tous)

• Exchanges : Listing facile sur CEX et DEX

• Tools : Uniswap, 1inch, CoinGecko, Etherscan

• Maturité : Très mature, best practices établies

ERC-721

• Marketplaces : OpenSea, Blur, LooksRare, Rarible

• Tools : NFTScan, Icy.tools, Reservoir

• Standards : Nombreuses extensions (royalties, metadata)

• Maturité : Mature, en évolution constante

ERC-1155

• Marketplaces : OpenSea (support complet), Rarible

• Tools : Moins d'outils spécialisés

• Gaming : Adoption forte (Enjin, Immutable)

• Maturité : En croissance rapide

Migration Entre Standards

Il est parfois nécessaire de migrer ou de wrapper des tokens.

ERC-20 → ERC-721 (Fractionalization)

// Wrapper un NFT en tokens ERC-20 fractionnaires
contract NFTFractionalizer {
    mapping(uint256 => address) public nftToToken;

    function fractionalize(address nft, uint256 tokenId, uint256 supply) external {
        IERC721(nft).transferFrom(msg.sender, address(this), tokenId);

        ERC20FractionalToken token = new ERC20FractionalToken("Fractional NFT", "fNFT", supply);
        token.transfer(msg.sender, supply);

        nftToToken[tokenId] = address(token);
    }
}

ERC-721 → ERC-1155 (Batch Optimization)

Certains projets migrent de 721 vers 1155 pour bénéficier des batch transfers.

Matrice de Décision

| Critère | ERC-20 | ERC-721 | ERC-1155 |

|---------|--------|---------|----------|

| Tokens identiques | ✅ | ❌ | ✅ (par ID) |

| Tokens uniques | ❌ | ✅ | ✅ |

| Batch operations | ⚠️ (custom) | ❌ | ✅ |

| Gas efficiency | ✅ | ⚠️ | ✅ (batch) |

| Simplicité | ✅ | ⚠️ | ❌ |

| Support ecosystème | ✅ | ✅ | ⚠️ |

| Gaming | ❌ | ⚠️ | ✅ |

| DeFi | ✅ | ⚠️ | ❌ |

Recommandations Finales

Choisissez ERC-20 si :

• Vous créez une monnaie, stablecoin ou token de gouvernance

• La fongibilité est essentielle

• Vous voulez la plus large compatibilité DeFi

• Vous privilégiez la simplicité

Choisissez ERC-721 si :

• Chaque token doit être unique

• Vous créez de l'art, des collectibles ou de l'immobilier tokenisé

• Vous voulez le meilleur support marketplace NFT

• Les métadonnées riches sont importantes

Choisissez ERC-1155 si :

• Vous développez un jeu ou une plateforme multi-actifs

• Vous avez besoin de fongible ET non-fongible

• Le batch processing est critique pour votre économie

• Vous voulez optimiser les coûts gas sur de gros volumes

Conseil pro : Pour un projet complexe, vous pouvez utiliser plusieurs standards. Par exemple, un jeu peut avoir un token ERC-20 pour la monnaie in-game et un ERC-1155 pour les objets.

Conclusion

Le choix du standard de token dépend de votre use case spécifique. L'ERC-20 reste le roi de la fongibilité et de la DeFi, l'ERC-721 domine les NFT et collectibles, tandis que l'ERC-1155 s'impose dans le gaming et les applications nécessitant flexibilité et efficacité gas.

Commencez par bien définir votre besoin, puis testez votre implémentation sur un testnet avant le déploiement. Sur Solingo, vous pouvez expérimenter avec les trois standards dans un environnement interactif et apprendre les best practices de chacun.