Cours Blockchain et Web3 · Module 4: ethers.js & viem

Ethers.js - Ton marteau dans la Forge à Outils

3 min de lecture ·
Dans cette leçon5

Bienvenue à la Forge à Outils ! Atlas ici. Aujourd'hui nous allons forger ton premier marteau - ethers.js - la bibliothèque la plus puissante pour interagir avec Ethereum.

Qu'est-ce qu'Ethers.js ?

Ethers.js est une bibliothèque JavaScript/TypeScript pour interagir avec la blockchain Ethereum. C'est comme une clé universelle pour tous les tunnels et chambres de la Crypte.

┌─────────────────────────────────────────────────────────────────┐
│                    ARCHITECTURE D'ETHERS.JS                      │
├─────────────────────────────────────────────────────────────────┤
│                                                                  │
│   ┌─────────────┐     ┌─────────────┐     ┌─────────────┐       │
│   │    Ton      │────▶│  Provider   │────▶│   Réseau    │       │
│   │ Application │     │  (Portail)  │     │  Ethereum   │       │
│   └─────────────┘     └─────────────┘     └─────────────┘       │
│          │                                                       │
│          │            ┌─────────────┐                           │
│          └───────────▶│   Signer    │ (signature des TX)        │
│                       │ (Guerrier)  │                           │
│                       └─────────────┘                           │
│                              │                                   │
│                              ▼                                   │
│                       ┌─────────────┐                           │
│                       │   Wallet    │ (Signer + Provider)       │
│                       │  (Coffre)   │                           │
│                       └─────────────┘                           │
│                                                                  │
└─────────────────────────────────────────────────────────────────┘

Installation

# npm
npm install ethers

# yarn
yarn add ethers

# pnpm
pnpm add ethers

Concepts fondamentaux

1. Provider - Passerelle vers le réseau

Un Provider est une connexion au réseau Ethereum (lecture seule) :

import { ethers } from "ethers";

// Connexion via un RPC public
const provider = new ethers.JsonRpcProvider("https://eth-mainnet.g.alchemy.com/v2/YOUR-API-KEY");

// Infura
const infuraProvider = new ethers.InfuraProvider("mainnet", "YOUR-API-KEY");

// Alchemy
const alchemyProvider = new ethers.AlchemyProvider("mainnet", "YOUR-API-KEY");

// Pour le testnet Sepolia
const sepoliaProvider = new ethers.JsonRpcProvider("https://eth-sepolia.g.alchemy.com/v2/YOUR-API-KEY");

2. Signer - Guerrier avec un sceau

Un Signer peut signer des transactions :

// Signer avec une clé privée
const privateKey = "0x...";
const signer = new ethers.Wallet(privateKey, provider);

// Adresse du Signer
console.log("Address:", signer.address);

3. Wallet - Coffre (Signer + Provider)

Un Wallet est une combinaison de Signer + Provider :

// Création d'un nouveau wallet
const newWallet = ethers.Wallet.createRandom();
console.log("Address:", newWallet.address);
console.log("Private Key:", newWallet.privateKey);
console.log("Mnemonic:", newWallet.mnemonic.phrase);

// Import depuis une clé privée
const wallet = new ethers.Wallet(privateKey, provider);

// Import depuis une phrase mnémonique
const walletFromMnemonic = ethers.Wallet.fromPhrase("word1 word2 word3...", provider);

Opérations de base

Vérifier le solde :

const balance = await provider.getBalance("0x742d35Cc6634C0532925a3b844Bc9e7595f8fE8c");
console.log("Balance:", ethers.formatEther(balance), "ETH");

Récupérer les informations d'un bloc :

const blockNumber = await provider.getBlockNumber();
const block = await provider.getBlock(blockNumber);
console.log("Block:", block);

Envoyer de l'ETH :

const tx = await wallet.sendTransaction({
  to: "0x...",
  value: ethers.parseEther("0.1")
});
await tx.wait();
console.log("TX Hash:", tx.hash);

Résumé

  • Ethers.js - la bibliothèque Web3 principale
  • Provider - connexion au réseau (lecture seule)
  • Signer - signature des transactions
  • Wallet - Provider + Signer
  • Opérations de base : solde, bloc, envoi
Code de cette leçon : index.js
// ethers.js - les bases
// Dans un vrai projet : import { ethers } from "ethers";

// Simulation d'ethers.js
const ethers = {
  // Formatage
  formatEther: (wei) => (Number(wei) / 1e18).toString(),
  parseEther: (eth) => BigInt(Math.floor(Number(eth) * 1e18)),
  formatUnits: (value, decimals) => (Number(value) / Math.pow(10, decimals)).toString(),
  parseUnits: (value, decimals) => BigInt(Math.floor(Number(value) * Math.pow(10, decimals))),

  // Adresses
  isAddress: (address) => /^0x[a-fA-F0-9]{40}$/.test(address),
  getAddress: (address) => {
    if (!ethers.isAddress(address)) throw new Error("Adresse invalide");
    return address.toLowerCase();
  },

  // Utilitaires
  id: (text) => "0x" + Array.from(text).reduce((h, c) =>
    ((h << 5) - h + c.charCodeAt(0)) & 0xffffffff, 0
  ).toString(16).padStart(64, '0'),

  keccak256: (data) => ethers.id(data)
};

console.log("=== LES BASES D'ETHERS.JS ===\n");

// Formatage
console.log("Formatage :");
const weiAmount = "1500000000000000000"; // 1.5 ETH
console.log(`  Wei: ${weiAmount}`);
console.log(`  ETH: ${ethers.formatEther(weiAmount)}`);

const ethAmount = "2.5";
console.log(`\n  ETH: ${ethAmount}`);
console.log(`  Wei: ${ethers.parseEther(ethAmount).toString()}`);

// Tokens (l'USDC a 6 décimales)
console.log("\nTokens (USDC, 6 décimales) :");
const usdcAmount = "1000000"; // 1 USDC
console.log(`  Brut: ${usdcAmount}`);
console.log(`  Formaté: ${ethers.formatUnits(usdcAmount, 6)} USDC`);

// Adresses
console.log("\nAdresses :");
const addr = "0x742d35Cc6634C0532925a3b844Bc9e7595f1dE3a";
console.log(`  Adresse: ${addr}`);
console.log(`  isAddress: ${ethers.isAddress(addr)}`);
console.log(`  Checksummée: ${ethers.getAddress(addr)}`);

// Keccak256
console.log("\nKeccak256 :");
console.log(`  keccak256("hello"): ${ethers.keccak256("hello")}`);

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. Quelle commande installe correctement ethers.js dans un projet ?

  2. 2. Quel est le rôle principal du Provider dans ethers.js ?

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

Tâches pratiques dans le jeu

  • Tri vertical

    Ordonne les étapes de création d'une connexion au réseau Ethereum avec ethers.js :

  • Éditeur de code

    Implémente la connexion au réseau via Infura ou Alchemy

  • Clique dans l'ordre

    Ordonne l'import correct de la bibliothèque ethers.js

  • Tri horizontal

    Ordonne correctement la création de JsonRpcProvider :

  • Éditeur de code

    Implémente une fonction qui lit le solde d'un compte

  • Éditeur de code

    Crée un Wallet et connecte-le au réseau

  • Tri vertical

    Ordonne les unités Ethereum de la plus petite à la plus grande :

  • Éditeur de code

    Implémente les conversions d'unités

  • Clique dans l'ordre

    Ordonne l'appel correct de parseEther pour 1 ETH

  • Tri vertical

    Ordonne les étapes d'envoi d'une transaction ETH :

  • Éditeur de code

    Implémente l'envoi d'ETH

  • Tri horizontal

    Ordonne les éléments nécessaires à la création d'une instance de contrat :

  • Éditeur de code

    Implémente la lecture du solde d'un token

  • Éditeur de code

    Implémente le transfert de tokens ERC20

  • Clique dans l'ordre

    Ordonne l'écoute correcte de l'événement Transfer

  • Éditeur de code

    Implémente un listener pour l'événement Transfer

  • Tri vertical

    Ordonne les étapes pour interroger des événements passés :

  • Éditeur de code

    Implémente createPublicClient

  • Tri horizontal

    Que faut-il pour créer un Wallet Client dans viem ?

  • Éditeur de code

    Implémente getBalance dans viem

  • Tri vertical

    Ordonne la structure de gestion des erreurs dans une transaction :

  • Clique dans l'ordre

    Ordonne la condition qui vérifie l'erreur de fonds insuffisants

  • Tri horizontal

    Ordonne la fonction de validation d'une adresse Ethereum :

  1. QuestionInstallation d'ethers.js
  2. QuestionLe rôle du Provider dans ethers.js
  3. QuestionJsonRpcProvider
  4. QuestionDifférence entre Provider et Signer
  5. Remets dans l'ordreCréer un Provider
  6. Exercice de codeProvider de base
  7. Clique dans l'ordreImporter ethers.js
  8. Remets dans l'ordreSyntaxe de JsonRpcProvider
  9. Exercice de codeLecture du solde
  10. QuestionMéthodes du Provider
  11. QuestionCréer un Wallet
  12. Exercice de codeWallet avec Private Key
  13. Remets dans l'ordreConversion des unités ETH
  14. QuestionparseEther
  15. Exercice de codeConversion des unités
  16. Clique dans l'ordreSyntaxe de parseEther
  17. QuestionEnvoyer une transaction
  18. Remets dans l'ordreStructure d'une transaction
  19. Exercice de codeEnvoyer de l'ETH
  20. QuestionQu'est-ce que l'ABI ?
  21. Remets dans l'ordreCréer une instance de Contract
  22. Exercice de codeLecture depuis un contrat
  23. QuestionFonctions Read vs Write
  24. Exercice de codeÉcriture dans un contrat
  25. QuestionÉcouter les événements
  26. Clique dans l'ordreSyntaxe de l'écoute
  27. Exercice de codeEvent listener
  28. Remets dans l'ordreInterroger des événements historiques
  29. QuestionIntroduction à viem
  30. QuestionClient dans viem
  31. Exercice de codeCréer un Public Client
  32. Remets dans l'ordreWallet Client dans viem
  33. Exercice de codeLecture du solde dans viem
  34. QuestionGestion des erreurs
  35. Remets dans l'ordreTry-catch dans les transactions
  36. Clique dans l'ordreTypes d'erreurs
  37. QuestionComparaison des bibliothèques
  38. QuestionestimateGas
  39. Remets dans l'ordreValidation des adresses
  40. QuestionSignature de messages
  41. Projet à envoyerProjet final
  42. QuestionBonnes pratiques
  43. DialogueFin du Laboratoire