Cours Blockchain et Web3 · Module 8: ERC-20 et création de tokens
Jetons ERC-20 - L'or de la Crypte
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. L'ERC-20 est :
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) :
Exercices après cette leçon
- QuestionQuiz : ERC-20
- QuestionQuiz : transfer()
- QuestionQuiz : approve()
- QuestionQuiz : transferFrom()
- QuestionQuiz : decimals
- QuestionQuiz : décimales USDT
- QuestionQuiz : allowance()
- Remets dans l'ordreTri : Flux approve + transferFrom
- Exercice de codeGap : Lecture des données du jeton
- Exercice de codeGap : Transfert de jetons
- Remets dans l'ordreTri horizontal : syntaxe de transfer
- Clique dans l'ordreTri : construire l'event Transfer
- Exercice de codeGap : Flux approve
- Remets dans l'ordreTri : Vesting schedule
- Clique dans l'ordreTri : construire l'interface ERC-20
- Exercice de codeGap : Vérification du solde
- Remets dans l'ordreTri horizontal : syntaxe d'approve
- QuestionQuiz : totalSupply()
- QuestionQuiz : permit()
- QuestionQuiz : deadline EIP-2612
- QuestionQuiz : mint vs transfer
- QuestionQuiz : cap - offre maximale
- QuestionQuiz : snapshots
- QuestionQuiz : wrapped tokens
- QuestionQuiz : fee on transfer
- Exercice de codeGap : Fonction mint
- Exercice de codeGap : Fonction burn
- Remets dans l'ordreTri : Flux permit complet
- Remets dans l'ordreTri horizontal : appel de permit
- Clique dans l'ordreTri : construire l'event Approval
- Exercice de codeGap : Vérification de l'allowance
- Remets dans l'ordreTri : Dépôt de staking
- Exercice de codeGap : Implémentation du cap
- Remets dans l'ordreTri horizontal : fonction mint
- Clique dans l'ordreTri : balanceOf + transfer
- Exercice de codeGap : Bascule Pausable
- Remets dans l'ordreTri : Libération du token vesting
- Exercice de codeGap : Mécanisme de snapshot
- Remets dans l'ordreTri horizontal : event Approval
- Remets dans l'ordreTri : Processus de burn
- Projet à envoyerEnvoie le projet au mentor
- DialogueFin du module 8