Kurs Blockchain i Web3 · Moduł 11: dApp Development
Budowanie dApp - Aplikacje zdecentralizowane
W tej lekcji6
Witaj w Sercu Miasta! Atlas tutaj. Dziś połączymy wszystko, co poznałeś - zbudujemy prawdziwą zdecentralizowaną aplikację (dApp)!
Architektura dApp
┌─────────────────────────────────────────────────────────────────┐
│ ARCHITEKTURA dApp │
├─────────────────────────────────────────────────────────────────┤
│ │
│ ┌─────────────────────────────────────────────────────────┐ │
│ │ FRONTEND │ │
│ │ React / Next.js / Vue │ │
│ │ + ethers.js / wagmi / viem │ │
│ └─────────────────────────────────────────────────────────┘ │
│ │ │
│ │ JSON-RPC │
│ ▼ │
│ ┌─────────────────────────────────────────────────────────┐ │
│ │ WALLET │ │
│ │ MetaMask / WalletConnect / Coinbase Wallet │ │
│ └─────────────────────────────────────────────────────────┘ │
│ │ │
│ │ Transactions │
│ ▼ │
│ ┌─────────────────────────────────────────────────────────┐ │
│ │ BLOCKCHAIN │ │
│ │ Ethereum / Polygon / Arbitrum │ │
│ │ Smart Contracts │ │
│ └─────────────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────┘Połączenie z MetaMask
import { ethers } from "ethers";
// Sprawdź czy MetaMask jest zainstalowany
if (typeof window.ethereum === "undefined") {
throw new Error("MetaMask nie jest zainstalowany!");
}
// Poproś o połączenie
const accounts = await window.ethereum.request({
method: "eth_requestAccounts"
});
const userAddress = accounts[0];
// Utwórz provider i signer
const provider = new ethers.BrowserProvider(window.ethereum);
const signer = await provider.getSigner();
console.log("Connected:", userAddress);Wagmi - React Hooks dla Web3
// wagmi to najpopularniejsza biblioteka React dla 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>Connected: {address}</p>
<p>Balance: {balance?.formatted} ETH</p>
<button onClick={() => disconnect()}>Disconnect</button>
</div>
);
}
return (
<button onClick={() => connect({ connector: injected() })}>
Connect Wallet
</button>
);
}Konfiguracja 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(),
},
});Interakcja z kontraktem (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>Balance: {balance?.toString()}</p>
<button onClick={handleTransfer} disabled={isPending}>
{isPending ? "Sending..." : "Transfer"}
</button>
</div>
);
}Podsumowanie
- Architektura dApp (Frontend + Wallet + Blockchain)
- Połączenie z MetaMask
- wagmi - React hooks dla Web3
- useAccount, useConnect, useBalance
- useReadContract, useWriteContract
- WalletConnect
Kod do tej lekcji: index.js
// dApp Architecture Overview
console.log("=== DAPP ARCHITECTURE ===\n");
const architecture = {
"Frontend": {
tech: ["Next.js 14", "React", "TypeScript", "Tailwind CSS"],
role: "UI, wallet connection, transaction building",
libraries: ["wagmi", "viem", "RainbowKit", "ethers.js"]
},
"Smart Contracts": {
tech: ["Solidity", "Hardhat/Foundry"],
role: "Business logic on-chain",
networks: ["Ethereum", "Arbitrum", "Base", "Polygon"]
},
"Indexer": {
tech: ["The Graph", "Ponder", "Envio"],
role: "Query historical blockchain data",
why: "Direct RPC queries are slow/limited"
},
"Backend (optional)": {
tech: ["Node.js", "Vercel Functions", "Supabase"],
role: "Off-chain data, user accounts, notifications",
examples: ["Email notifications", "User preferences", "Analytics"]
},
"Storage": {
tech: ["IPFS", "Arweave", "Pinata"],
role: "NFT metadata, large files",
why: "On-chain storage is expensive"
}
};
Object.entries(architecture).forEach(([layer, data]) => {
console.log(`${layer}`);
console.log(` Tech: ${data.tech.join(", ")}`);
console.log(` Role: ${data.role}`);
if (data.libraries) console.log(` Libraries: ${data.libraries.join(", ")}`);
if (data.networks) console.log(` Networks: ${data.networks.join(", ")}`);
if (data.why) console.log(` Why: ${data.why}`);
console.log();
});
console.log("=== TYPICAL DAPP FLOW ===\n");
const flow = [
"1. User connects wallet (RainbowKit/WalletConnect)",
"2. Frontend reads contract state (viem/wagmi hooks)",
"3. User initiates action (e.g., swap, mint)",
"4. Frontend builds transaction",
"5. Wallet prompts for signature",
"6. Transaction sent to network",
"7. Wait for confirmation",
"8. Update UI with new state",
"9. Indexer updates for historical queries"
];
flow.forEach(step => console.log(` ${step}`));
console.log("\n=== PROJECT STRUCTURE ===\n");
const structure = `
my-dapp/
├── contracts/ # Solidity contracts
│ ├── src/
│ │ └── MyContract.sol
│ ├── test/
│ ├── script/
│ └── foundry.toml
├── frontend/ # Next.js app
│ ├── app/
│ │ ├── layout.tsx
│ │ ├── page.tsx
│ │ └── providers.tsx
│ ├── components/
│ │ ├── ConnectButton.tsx
│ │ └── ContractInteraction.tsx
│ ├── hooks/
│ │ └── useContract.ts
│ ├── lib/
│ │ ├── contracts.ts # ABI + addresses
│ │ └── wagmi.ts # Wagmi config
│ └── package.json
├── subgraph/ # The Graph indexer
│ ├── schema.graphql
│ ├── subgraph.yaml
│ └── src/mapping.ts
└── README.md
`;
console.log(structure);
Widzisz błąd w tej lekcji?
Sprawdź się
Odpowiedz na pytania z tej lekcji. Wybierz odpowiedź, a od razu zobaczysz, czy jest poprawna.
1. dApp (Decentralized Application) to:
2. MetaMask to:
To 2 z 21 pytań do tej lekcji. Pozostałe rozwiążesz w grze.
Zadania praktyczne w grze
- Układanie w poziomie
Ułóż warstwy stosu dApp od użytkownika do blockchain:
- Klikanie w kolejności
Ułóż biblioteki od najwyższego poziomu abstrakcji do najniższego:
- Układanie w pionie
Ułóż stany transakcji blockchain w kolejności:
- Edytor kodu
Uzupełnij kod komponentu
- Edytor kodu
Uzupełnij kod odczytu balanceOf
- Układanie w poziomie
Ułóż elementy konfiguracji wagmi w prawidłowej kolejności:
- Edytor kodu
Uzupełnij kod funkcji transferu
- Edytor kodu
Uzupełnij setup RainbowKit
- Klikanie w kolejności
Kliknij stany transakcji w kolejności ich występowania:
- Układanie w pionie
Ułóż kroki setupu dApp w prawidłowej kolejności:
- Edytor kodu
Uzupełnij kod switch chain
- Edytor kodu
Uzupełnij kod ENS resolution
- Układanie w poziomie
Ułóż kluczowe parametry useReadContract:
- Klikanie w kolejności
Kliknij operacje związane z chains w logicznej kolejności użycia w dApp:
- Edytor kodu
Uzupełnij kod wyświetlania salda
- Edytor kodu
Uzupełnij setup ConnectKit
- Układanie w pionie
Ułóż flow zmiany sieci w dApp:
- Klikanie w kolejności
Kliknij komponenty ekosystemu wagmi od core do UI:
- Edytor kodu
Uzupełnij GraphQL query
- Edytor kodu
Uzupełnij kompletny komponent
- Układanie w poziomie
Ułóż parametry useWriteContract w kolejności użycia:
Zadania po tej lekcji
- PytanieQuiz: dApp
- PytanieQuiz: MetaMask
- PytanieQuiz: window.ethereum
- PytanieQuiz: eth_requestAccounts
- PytanieQuiz: wagmi
- PytanieQuiz: useAccount
- Ułóż w kolejnościSortowanie poziome: dApp Stack
- Kliknij w kolejnościSortowanie: Biblioteki Web3
- PytanieQuiz: useConnect
- PytanieQuiz: useReadContract
- PytanieQuiz: useWriteContract
- PytanieQuiz: RainbowKit
- Ułóż w kolejnościSortowanie: Flow transakcji
- Zadanie z kodemGap: Połączenie portfela
- Zadanie z kodemGap: useReadContract dla ERC-20
- PytanieQuiz: ConnectKit
- PytanieQuiz: useSwitchChain
- PytanieQuiz: useBalance
- PytanieQuiz: viem
- Ułóż w kolejnościSortowanie poziome: wagmi config
- Zadanie z kodemGap: useWriteContract dla transferu
- Zadanie z kodemGap: RainbowKit Integration
- Kliknij w kolejnościSortowanie: Transaction States
- PytanieQuiz: The Graph
- PytanieQuiz: Subgraph
- PytanieQuiz: ENS
- PytanieQuiz: Web3Modal
- Ułóż w kolejnościSortowanie: dApp Setup Flow
- Zadanie z kodemGap: Chain Switching
- Zadanie z kodemGap: ENS Display
- Ułóż w kolejnościSortowanie poziome: useReadContract config
- Kliknij w kolejnościSortowanie: Chain Operations
- PytanieQuiz: Account Abstraction (ERC-4337)
- PytanieQuiz: GraphQL w The Graph
- PytanieQuiz: useWaitForTransactionReceipt
- Zadanie z kodemGap: useBalance Hook
- Zadanie z kodemGap: ConnectKit Setup
- Ułóż w kolejnościSortowanie: Chain Switch Flow
- Kliknij w kolejnościSortowanie: wagmi Ecosystem
- Zadanie z kodemGap: The Graph Query
- Zadanie z kodemGap: Full Wallet Component
- Ułóż w kolejnościSortowanie poziome: useWriteContract config
- Projekt do wysłaniaWyślij projekt do mentora
- RozmowaZakończenie modułu 11