Cours Blockchain et Web3 · Module 11: Développement de dApps

Construire des dApps - Applications décentralisées

3 min de lecture ·
Dans cette leçon6

Bienvenue au Cœur de la Ville ! Atlas ici. Aujourd'hui nous allons combiner tout ce que tu as appris - nous allons construire une véritable application décentralisée (dApp) !

Architecture d'une dApp

┌─────────────────────────────────────────────────────────────────┐
│                    ARCHITECTURE dApp                              │
├─────────────────────────────────────────────────────────────────┤
│                                                                  │
│   ┌─────────────────────────────────────────────────────────┐   │
│   │                    FRONTEND                              │   │
│   │  React / Next.js / Vue                                  │   │
│   │  + ethers.js / wagmi / viem                             │   │
│   └─────────────────────────────────────────────────────────┘   │
│                              │                                   │
│                              │ JSON-RPC                          │
│                              ▼                                   │
│   ┌─────────────────────────────────────────────────────────┐   │
│   │                    WALLET                                │   │
│   │  MetaMask / WalletConnect / Coinbase Wallet             │   │
│   └─────────────────────────────────────────────────────────┘   │
│                              │                                   │
│                              │ Transactions                      │
│                              ▼                                   │
│   ┌─────────────────────────────────────────────────────────┐   │
│   │                    BLOCKCHAIN                            │   │
│   │  Ethereum / Polygon / Arbitrum                          │   │
│   │  Smart Contracts                                        │   │
│   └─────────────────────────────────────────────────────────┘   │
│                                                                  │
└─────────────────────────────────────────────────────────────────┘

Connexion à MetaMask

import { ethers } from "ethers";

// Vérifier si MetaMask est installé
if (typeof window.ethereum === "undefined") {
  throw new Error("MetaMask n'est pas installé !");
}

// Demander la connexion
const accounts = await window.ethereum.request({
  method: "eth_requestAccounts"
});
const userAddress = accounts[0];

// Créer le provider et le signer
const provider = new ethers.BrowserProvider(window.ethereum);
const signer = await provider.getSigner();

console.log("Connecté :", userAddress);

Wagmi - Hooks React pour le Web3

// wagmi est la bibliothèque React la plus populaire pour le Web3
import { useAccount, useConnect, useDisconnect, useBalance } from "wagmi";
import { injected } from "wagmi/connectors";

function WalletConnect() {
  const { address, isConnected } = useAccount();
  const { connect } = useConnect();
  const { disconnect } = useDisconnect();
  const { data: balance } = useBalance({ address });

  if (isConnected) {
    return (
      <div>
        <p>Connecté : {address}</p>
        <p>Solde : {balance?.formatted} ETH</p>
        <button onClick={() => disconnect()}>Déconnecter</button>
      </div>
    );
  }

  return (
    <button onClick={() => connect({ connector: injected() })}>
      Connecter le Wallet
    </button>
  );
}

Configuration wagmi

import { createConfig, http } from "wagmi";
import { mainnet, sepolia } from "wagmi/chains";
import { injected, walletConnect } from "wagmi/connectors";

const config = createConfig({
  chains: [mainnet, sepolia],
  connectors: [
    injected(),
    walletConnect({ projectId: "YOUR_PROJECT_ID" }),
  ],
  transports: {
    [mainnet.id]: http(),
    [sepolia.id]: http(),
  },
});

Interagir avec un contrat (wagmi)

import { useReadContract, useWriteContract } from "wagmi";

const CONTRACT_ADDRESS = "0x...";
const CONTRACT_ABI = [...];

function TokenBalance() {
  const { data: balance } = useReadContract({
    address: CONTRACT_ADDRESS,
    abi: CONTRACT_ABI,
    functionName: "balanceOf",
    args: [userAddress],
  });

  const { writeContract, isPending } = useWriteContract();

  const handleTransfer = () => {
    writeContract({
      address: CONTRACT_ADDRESS,
      abi: CONTRACT_ABI,
      functionName: "transfer",
      args: [recipientAddress, amount],
    });
  };

  return (
    <div>
      <p>Solde : {balance?.toString()}</p>
      <button onClick={handleTransfer} disabled={isPending}>
        {isPending ? "Envoi..." : "Transférer"}
      </button>
    </div>
  );
}

Résumé

  • Architecture d'une dApp (Frontend + Wallet + Blockchain)
  • Connexion à MetaMask
  • wagmi - hooks React pour le Web3
  • useAccount, useConnect, useBalance
  • useReadContract, useWriteContract
  • WalletConnect
Code de cette leçon : index.js
// Aperçu de l'architecture d'une dApp

console.log("=== ARCHITECTURE dApp ===\n");

const architecture = {
  "Frontend": {
    tech: ["Next.js 14", "React", "TypeScript", "Tailwind CSS"],
    role: "UI, connexion du wallet, construction des transactions",
    libraries: ["wagmi", "viem", "RainbowKit", "ethers.js"]
  },
  "Smart Contracts": {
    tech: ["Solidity", "Hardhat/Foundry"],
    role: "Logique métier on-chain",
    networks: ["Ethereum", "Arbitrum", "Base", "Polygon"]
  },
  "Indexer": {
    tech: ["The Graph", "Ponder", "Envio"],
    role: "Interroger les données historiques de la blockchain",
    why: "Les requêtes RPC directes sont lentes/limitées"
  },
  "Backend (optionnel)": {
    tech: ["Node.js", "Vercel Functions", "Supabase"],
    role: "Données off-chain, comptes utilisateurs, notifications",
    examples: ["Notifications e-mail", "Préférences utilisateur", "Analytics"]
  },
  "Storage": {
    tech: ["IPFS", "Arweave", "Pinata"],
    role: "Métadonnées NFT, gros fichiers",
    why: "Le stockage on-chain est coûteux"
  }
};

Object.entries(architecture).forEach(([layer, data]) => {
  console.log(`${layer}`);
  console.log(`   Tech : ${data.tech.join(", ")}`);
  console.log(`   Rôle : ${data.role}`);
  if (data.libraries) console.log(`   Bibliothèques : ${data.libraries.join(", ")}`);
  if (data.networks) console.log(`   Réseaux : ${data.networks.join(", ")}`);
  if (data.why) console.log(`   Pourquoi : ${data.why}`);
  console.log();
});

console.log("=== FLUX TYPIQUE D'UNE dApp ===\n");

const flow = [
  "1. L'utilisateur connecte son wallet (RainbowKit/WalletConnect)",
  "2. Le frontend lit l'état du contrat (hooks viem/wagmi)",
  "3. L'utilisateur initie une action (ex. swap, mint)",
  "4. Le frontend construit la transaction",
  "5. Le wallet demande une signature",
  "6. La transaction est envoyée au réseau",
  "7. Attente de la confirmation",
  "8. Mise à jour de l'UI avec le nouvel état",
  "9. L'indexer se met à jour pour les requêtes historiques"
];

flow.forEach(step => console.log(`  ${step}`));

console.log("\n=== STRUCTURE DU PROJET ===\n");

const structure = `
my-dapp/
├── contracts/              # Contrats Solidity
│   ├── src/
│   │   └── MyContract.sol
│   ├── test/
│   ├── script/
│   └── foundry.toml
├── frontend/               # Application Next.js
│   ├── app/
│   │   ├── layout.tsx
│   │   ├── page.tsx
│   │   └── providers.tsx
│   ├── components/
│   │   ├── ConnectButton.tsx
│   │   └── ContractInteraction.tsx
│   ├── hooks/
│   │   └── useContract.ts
│   ├── lib/
│   │   ├── contracts.ts    # ABI + adresses
│   │   └── wagmi.ts        # Config Wagmi
│   └── package.json
├── subgraph/               # Indexer The Graph
│   ├── schema.graphql
│   ├── subgraph.yaml
│   └── src/mapping.ts
└── README.md
`;

console.log(structure);

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. Une dApp (Decentralized Application) est :

  2. 2. MetaMask est :

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

Tâches pratiques dans le jeu

  • Tri horizontal

    Ordonne les couches du stack dApp de l'utilisateur vers la blockchain :

  • Clique dans l'ordre

    Ordonne les bibliothèques du plus haut niveau d'abstraction au plus bas :

  • Tri vertical

    Ordonne les états d'une transaction blockchain :

  • Éditeur de code

    Complète le code du composant

  • Éditeur de code

    Complète le code de lecture de balanceOf

  • Tri horizontal

    Ordonne les éléments de configuration wagmi dans le bon ordre :

  • Éditeur de code

    Complète le code de la fonction de transfert

  • Éditeur de code

    Complète le setup de RainbowKit

  • Clique dans l'ordre

    Clique sur les états d'une transaction dans l'ordre où ils apparaissent :

  • Tri vertical

    Ordonne les étapes du setup d'une dApp dans le bon ordre :

  • Éditeur de code

    Complète le code de switch chain

  • Éditeur de code

    Complète le code de résolution ENS

  • Tri horizontal

    Ordonne les paramètres clés de useReadContract :

  • Clique dans l'ordre

    Clique sur les opérations liées aux chains dans l'ordre logique d'utilisation dans une dApp :

  • Éditeur de code

    Complète le code d'affichage du solde

  • Éditeur de code

    Complète le setup de ConnectKit

  • Tri vertical

    Ordonne le flow de changement de réseau dans une dApp :

  • Clique dans l'ordre

    Clique sur les composants de l'écosystème wagmi du core vers l'UI :

  • Éditeur de code

    Complète la requête GraphQL

  • Éditeur de code

    Complète le composant complet

  • Tri horizontal

    Ordonne les paramètres de useWriteContract dans l'ordre d'utilisation :

  1. QuestionQuiz : dApp
  2. QuestionQuiz : MetaMask
  3. QuestionQuiz : window.ethereum
  4. QuestionQuiz : eth_requestAccounts
  5. QuestionQuiz : wagmi
  6. QuestionQuiz : useAccount
  7. Remets dans l'ordreTri horizontal : Stack dApp
  8. Clique dans l'ordreTri : Bibliothèques Web3
  9. QuestionQuiz : useConnect
  10. QuestionQuiz : useReadContract
  11. QuestionQuiz : useWriteContract
  12. QuestionQuiz : RainbowKit
  13. Remets dans l'ordreTri : Flow d'une transaction
  14. Exercice de codeGap : Connexion du wallet
  15. Exercice de codeGap : useReadContract pour ERC-20
  16. QuestionQuiz : ConnectKit
  17. QuestionQuiz : useSwitchChain
  18. QuestionQuiz : useBalance
  19. QuestionQuiz : viem
  20. Remets dans l'ordreTri horizontal : config wagmi
  21. Exercice de codeGap : useWriteContract pour un transfert
  22. Exercice de codeGap : Intégration de RainbowKit
  23. Clique dans l'ordreTri : Transaction States
  24. QuestionQuiz : The Graph
  25. QuestionQuiz : Subgraph
  26. QuestionQuiz : ENS
  27. QuestionQuiz : Web3Modal
  28. Remets dans l'ordreTri : dApp Setup Flow
  29. Exercice de codeGap : Chain Switching
  30. Exercice de codeGap : Affichage ENS
  31. Remets dans l'ordreTri horizontal : config useReadContract
  32. Clique dans l'ordreTri : Chain Operations
  33. QuestionQuiz : Account Abstraction (ERC-4337)
  34. QuestionQuiz : GraphQL dans The Graph
  35. QuestionQuiz : useWaitForTransactionReceipt
  36. Exercice de codeGap : Hook useBalance
  37. Exercice de codeGap : Setup de ConnectKit
  38. Remets dans l'ordreTri : Chain Switch Flow
  39. Clique dans l'ordreTri : Écosystème wagmi
  40. Exercice de codeGap : Requête The Graph
  41. Exercice de codeGap : Composant wallet complet
  42. Remets dans l'ordreTri horizontal : config useWriteContract
  43. Projet à envoyerEnvoie ton projet au mentor
  44. DialogueFin du module 11