Cours Blockchain et Web3 · Module 11: Développement de dApps
Construire des dApps - Applications décentralisées
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. Une dApp (Decentralized Application) est :
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 :
Exercices après cette leçon
- QuestionQuiz : dApp
- QuestionQuiz : MetaMask
- QuestionQuiz : window.ethereum
- QuestionQuiz : eth_requestAccounts
- QuestionQuiz : wagmi
- QuestionQuiz : useAccount
- Remets dans l'ordreTri horizontal : Stack dApp
- Clique dans l'ordreTri : Bibliothèques Web3
- QuestionQuiz : useConnect
- QuestionQuiz : useReadContract
- QuestionQuiz : useWriteContract
- QuestionQuiz : RainbowKit
- Remets dans l'ordreTri : Flow d'une transaction
- Exercice de codeGap : Connexion du wallet
- Exercice de codeGap : useReadContract pour ERC-20
- QuestionQuiz : ConnectKit
- QuestionQuiz : useSwitchChain
- QuestionQuiz : useBalance
- QuestionQuiz : viem
- Remets dans l'ordreTri horizontal : config wagmi
- Exercice de codeGap : useWriteContract pour un transfert
- Exercice de codeGap : Intégration de RainbowKit
- Clique dans l'ordreTri : Transaction States
- QuestionQuiz : The Graph
- QuestionQuiz : Subgraph
- QuestionQuiz : ENS
- QuestionQuiz : Web3Modal
- Remets dans l'ordreTri : dApp Setup Flow
- Exercice de codeGap : Chain Switching
- Exercice de codeGap : Affichage ENS
- Remets dans l'ordreTri horizontal : config useReadContract
- Clique dans l'ordreTri : Chain Operations
- QuestionQuiz : Account Abstraction (ERC-4337)
- QuestionQuiz : GraphQL dans The Graph
- QuestionQuiz : useWaitForTransactionReceipt
- Exercice de codeGap : Hook useBalance
- Exercice de codeGap : Setup de ConnectKit
- Remets dans l'ordreTri : Chain Switch Flow
- Clique dans l'ordreTri : Écosystème wagmi
- Exercice de codeGap : Requête The Graph
- Exercice de codeGap : Composant wallet complet
- Remets dans l'ordreTri horizontal : config useWriteContract
- Projet à envoyerEnvoie ton projet au mentor
- DialogueFin du module 11