Cours Blockchain et Web3 · Module 8: ERC-20 et création de tokens

Jetons ERC-20 - L'or de la Crypte

3 min de lecture ·
Dans cette leçon7

Bienvenue à la Monnaie ! Atlas à ton service. Aujourd'hui tu vas découvrir l'ERC-20 - le standard pour créer des jetons fongibles, l'"or souterrain" de la Crypte.

Qu'est-ce que l'ERC-20 ?

L'ERC-20 est un standard définissant l'interface des jetons fongibles sur Ethereum. Chaque jeton ERC-20 possède des fonctions identiques, ce qui facilite l'intégration avec les portefeuilles et les plateformes d'échange.

┌─────────────────────────────────────────────────────────────────┐
│                    STANDARD ERC-20                               │
├─────────────────────────────────────────────────────────────────┤
│                                                                  │
│  FONCTIONS REQUISES :                                          │
│  ├── totalSupply()      - offre totale                          │
│  ├── balanceOf(address) - solde d'une adresse                   │
│  ├── transfer(to, amount) - transfert de jetons                 │
│  ├── allowance(owner, spender) - autorisation de dépense        │
│  ├── approve(spender, amount) - autoriser une dépense           │
│  └── transferFrom(from, to, amount) - transfert pour le compte  │
│                                                                  │
│  ÉVÉNEMENTS REQUIS :                                           │
│  ├── Transfer(from, to, amount)                                 │
│  └── Approval(owner, spender, amount)                           │
│                                                                  │
│  OPTIONNEL :                                                     │
│  ├── name()     - nom du jeton (ex. "Tether USD")              │
│  ├── symbol()   - symbole (ex. "USDT")                         │
│  └── decimals() - nombre de décimales (généralement 18)         │
│                                                                  │
└─────────────────────────────────────────────────────────────────┘

Jetons ERC-20 populaires

Jeton      │ Symbole│ Décimales│ Usage
───────────┼────────┼──────────┼──────────────────
USDT       │ USDT   │ 6        │ Stablecoin (USD)
USDC       │ USDC   │ 6        │ Stablecoin (USD)
DAI        │ DAI    │ 18       │ Stablecoin (décentralisé)
WETH       │ WETH   │ 18       │ Wrapped Ether
UNI        │ UNI    │ 18       │ Gouvernance (Uniswap)
LINK       │ LINK   │ 18       │ Oracle (Chainlink)

Interagir avec un jeton ERC-20

import { ethers } from "ethers";

const ERC20_ABI = [
  "function name() view returns (string)",
  "function symbol() view returns (string)",
  "function decimals() view returns (uint8)",
  "function totalSupply() view returns (uint256)",
  "function balanceOf(address) view returns (uint256)",
  "function transfer(address to, uint256 amount) returns (bool)",
  "function approve(address spender, uint256 amount) returns (bool)",
  "function allowance(address owner, address spender) view returns (uint256)",
  "function transferFrom(address from, address to, uint256 amount) returns (bool)",
  "event Transfer(address indexed from, address indexed to, uint256 amount)",
  "event Approval(address indexed owner, address indexed spender, uint256 amount)"
];

const provider = new ethers.JsonRpcProvider("https://...");
const usdtAddress = "0xdAC17F958D2ee523a2206206994597C13D831ec7";
const token = new ethers.Contract(usdtAddress, ERC20_ABI, provider);

// Lire les données
const name = await token.name();
const symbol = await token.symbol();
const decimals = await token.decimals();
const balance = await token.balanceOf("0x...");

console.log(`${name} (${symbol})`);
console.log(`Solde : ${ethers.formatUnits(balance, decimals)}`);

Transfert de jetons

const wallet = new ethers.Wallet(privateKey, provider);
const tokenWithSigner = token.connect(wallet);

// Transfert
const tx = await tokenWithSigner.transfer(
  "0x...", // destinataire
  ethers.parseUnits("100", decimals) // montant
);
await tx.wait();

Approve et TransferFrom

// 1. Le propriétaire autorise (approve)
const approveTx = await tokenWithSigner.approve(
  spenderAddress,
  ethers.parseUnits("1000", decimals)
);
await approveTx.wait();

// 2. Le spender peut maintenant utiliser transferFrom
const transferTx = await tokenAsSpender.transferFrom(
  ownerAddress,
  recipientAddress,
  ethers.parseUnits("100", decimals)
);
await transferTx.wait();

Créer ton propre jeton

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

import "@openzeppelin/contracts/token/ERC20/ERC20.sol";

contract KryptaCoin is ERC20 {
    constructor(uint256 initialSupply) ERC20("Krypta Coin", "KRYPTA") {
        _mint(msg.sender, initialSupply * 10**decimals());
    }
}

Résumé

  • ERC-20 - standard des jetons fongibles
  • Fonctions : transfer, approve, transferFrom
  • Interaction avec ethers.js
  • Décimales et formatage
  • Création de ton propre jeton
Code de cette leçon : index.js
// Standard ERC-20 - les bases

class ERC20Token {
  constructor(name, symbol, decimals, initialSupply, owner) {
    // Métadonnées du jeton
    this._name = name;
    this._symbol = symbol;
    this._decimals = decimals;

    // État
    this._totalSupply = BigInt(initialSupply) * BigInt(10 ** decimals);
    this._balances = new Map();
    this._allowances = new Map();

    // Frappe initiale pour le propriétaire
    this._balances.set(owner, this._totalSupply);

    console.log(`Déployé ${name} (${symbol})`);
    console.log(`   Offre totale : ${this.formatAmount(this._totalSupply)} ${symbol}`);
    console.log(`   Propriétaire : ${owner}\n`);
  }

  // === Fonctions requises ERC-20 ===

  name() { return this._name; }
  symbol() { return this._symbol; }
  decimals() { return this._decimals; }
  totalSupply() { return this._totalSupply; }

  balanceOf(account) {
    return this._balances.get(account) || BigInt(0);
  }

  transfer(from, to, amount) {
    const amountBN = BigInt(amount);
    const fromBalance = this.balanceOf(from);

    if (fromBalance < amountBN) {
      throw new Error("ERC20: transfer amount exceeds balance");
    }

    this._balances.set(from, fromBalance - amountBN);
    this._balances.set(to, this.balanceOf(to) + amountBN);

    console.log(`Transfert : ${from.slice(0,8)}... -> ${to.slice(0,8)}...`);
    console.log(`   Montant : ${this.formatAmount(amountBN)} ${this._symbol}`);

    return true;
  }

  approve(owner, spender, amount) {
    if (!this._allowances.has(owner)) {
      this._allowances.set(owner, new Map());
    }
    this._allowances.get(owner).set(spender, BigInt(amount));

    console.log(`Approbation : ${owner.slice(0,8)}... -> ${spender.slice(0,8)}...`);
    console.log(`   Montant : ${this.formatAmount(BigInt(amount))} ${this._symbol}`);

    return true;
  }

  allowance(owner, spender) {
    return this._allowances.get(owner)?.get(spender) || BigInt(0);
  }

  transferFrom(spender, from, to, amount) {
    const amountBN = BigInt(amount);
    const currentAllowance = this.allowance(from, spender);

    if (currentAllowance < amountBN) {
      throw new Error("ERC20: insufficient allowance");
    }

    // Diminuer l'allowance
    this._allowances.get(from).set(spender, currentAllowance - amountBN);

    // Transfert
    return this.transfer(from, to, amount);
  }

  // Utilitaire
  formatAmount(amount) {
    return (Number(amount) / (10 ** this._decimals)).toLocaleString();
  }
}

console.log("=== STANDARD DE JETON ERC-20 ===\n");

// Déployer le jeton
const token = new ERC20Token(
  "Atlas Coin",
  "ATLAS",
  18,
  1000000, // 1M jetons
  "0xOwner123"
);

// Vérifier les soldes
console.log("--- Soldes ---");
console.log(`Propriétaire : ${token.formatAmount(token.balanceOf("0xOwner123"))} ATLAS`);
console.log(`Alice : ${token.formatAmount(token.balanceOf("0xAlice456"))} ATLAS\n`);

// Transfert
console.log("--- Transfert ---");
token.transfer("0xOwner123", "0xAlice456", "100000000000000000000000"); // 100k

// Approve & TransferFrom (flux typique pour un DEX)
console.log("\n--- Approve pour un DEX ---");
token.approve("0xAlice456", "0xUniswapRouter", "50000000000000000000000"); // 50k

console.log("\n--- Le DEX exécute transferFrom ---");
token.transferFrom(
  "0xUniswapRouter",
  "0xAlice456",
  "0xLiquidityPool",
  "50000000000000000000000"
);

console.log("\n--- Soldes finaux ---");
console.log(`Propriétaire : ${token.formatAmount(token.balanceOf("0xOwner123"))} ATLAS`);
console.log(`Alice : ${token.formatAmount(token.balanceOf("0xAlice456"))} ATLAS`);
console.log(`Pool :  ${token.formatAmount(token.balanceOf("0xLiquidityPool"))} ATLAS`);

Tu as repéré une erreur dans cette leçon ?

Teste tes connaissances

Réponds aux questions de cette leçon. Choisis une réponse pour voir tout de suite si elle est correcte.

  1. 1. L'ERC-20 est :

  2. 2. La fonction transfer(to, amount) en ERC-20 :

Voici 2 des 15 questions de cette leçon. Réponds aux autres dans le jeu.

Tâches pratiques dans le jeu

  • Tri vertical

    Ordonne les étapes d'utilisation d'approve/transferFrom :

  • Éditeur de code

    Complète le code de lecture des données du jeton

  • Éditeur de code

    Complète le code du transfert

  • Tri horizontal

    À quoi ressemble l'appel de la fonction transfer ?

  • Clique dans l'ordre

    Clique sur les boutons dans le bon ordre pour construire l'event Transfer

  • Éditeur de code

    Complète le code d'approve

  • Tri vertical

    Ordonne les étapes du vesting schedule (calendrier de distribution des jetons) :

  • Clique dans l'ordre

    Clique sur les boutons dans le bon ordre pour construire la déclaration de balanceOf

  • Éditeur de code

    Complète le code de vérification du solde

  • Tri horizontal

    À quoi ressemble l'appel de la fonction approve ?

  • Éditeur de code

    Complète le code de la fonction mint

  • Éditeur de code

    Complète le code de la fonction burn

  • Tri vertical

    Ordonne les étapes du flux permit complet :

  • Tri horizontal

    À quoi ressemble l'appel de la fonction permit ?

  • Clique dans l'ordre

    Clique sur les boutons dans le bon ordre pour construire l'event Approval

  • Éditeur de code

    Complète le code de vérification de l'allowance

  • Tri vertical

    Ordonne les étapes du staking de jetons ERC-20 :

  • Éditeur de code

    Complète le code de vérification de l'offre maximale

  • Tri horizontal

    À quoi ressemble la déclaration de la fonction mint en Solidity ?

  • Clique dans l'ordre

    Clique sur les boutons dans le bon ordre pour vérifier le solde du contrat

  • Éditeur de code

    Complète le code pausable

  • Tri vertical

    Ordonne le processus de déblocage des jetons en vesting :

  • Éditeur de code

    Complète le code du snapshot

  • Tri horizontal

    À quoi ressemble l'émission de l'event Approval ?

  • Tri vertical

    Ordonne les étapes de la destruction de jetons (burn) :

  1. QuestionQuiz : ERC-20
  2. QuestionQuiz : transfer()
  3. QuestionQuiz : approve()
  4. QuestionQuiz : transferFrom()
  5. QuestionQuiz : decimals
  6. QuestionQuiz : décimales USDT
  7. QuestionQuiz : allowance()
  8. Remets dans l'ordreTri : Flux approve + transferFrom
  9. Exercice de codeGap : Lecture des données du jeton
  10. Exercice de codeGap : Transfert de jetons
  11. Remets dans l'ordreTri horizontal : syntaxe de transfer
  12. Clique dans l'ordreTri : construire l'event Transfer
  13. Exercice de codeGap : Flux approve
  14. Remets dans l'ordreTri : Vesting schedule
  15. Clique dans l'ordreTri : construire l'interface ERC-20
  16. Exercice de codeGap : Vérification du solde
  17. Remets dans l'ordreTri horizontal : syntaxe d'approve
  18. QuestionQuiz : totalSupply()
  19. QuestionQuiz : permit()
  20. QuestionQuiz : deadline EIP-2612
  21. QuestionQuiz : mint vs transfer
  22. QuestionQuiz : cap - offre maximale
  23. QuestionQuiz : snapshots
  24. QuestionQuiz : wrapped tokens
  25. QuestionQuiz : fee on transfer
  26. Exercice de codeGap : Fonction mint
  27. Exercice de codeGap : Fonction burn
  28. Remets dans l'ordreTri : Flux permit complet
  29. Remets dans l'ordreTri horizontal : appel de permit
  30. Clique dans l'ordreTri : construire l'event Approval
  31. Exercice de codeGap : Vérification de l'allowance
  32. Remets dans l'ordreTri : Dépôt de staking
  33. Exercice de codeGap : Implémentation du cap
  34. Remets dans l'ordreTri horizontal : fonction mint
  35. Clique dans l'ordreTri : balanceOf + transfer
  36. Exercice de codeGap : Bascule Pausable
  37. Remets dans l'ordreTri : Libération du token vesting
  38. Exercice de codeGap : Mécanisme de snapshot
  39. Remets dans l'ordreTri horizontal : event Approval
  40. Remets dans l'ordreTri : Processus de burn
  41. Projet à envoyerEnvoie le projet au mentor
  42. DialogueFin du module 8