Kurs Blockchain i Web3 · Moduł 11: dApp Development

Budowanie dApp - Aplikacje zdecentralizowane

3 min czytania ·
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. 1. dApp (Decentralized Application) to:

  2. 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:

  1. PytanieQuiz: dApp
  2. PytanieQuiz: MetaMask
  3. PytanieQuiz: window.ethereum
  4. PytanieQuiz: eth_requestAccounts
  5. PytanieQuiz: wagmi
  6. PytanieQuiz: useAccount
  7. Ułóż w kolejnościSortowanie poziome: dApp Stack
  8. Kliknij w kolejnościSortowanie: Biblioteki Web3
  9. PytanieQuiz: useConnect
  10. PytanieQuiz: useReadContract
  11. PytanieQuiz: useWriteContract
  12. PytanieQuiz: RainbowKit
  13. Ułóż w kolejnościSortowanie: Flow transakcji
  14. Zadanie z kodemGap: Połączenie portfela
  15. Zadanie z kodemGap: useReadContract dla ERC-20
  16. PytanieQuiz: ConnectKit
  17. PytanieQuiz: useSwitchChain
  18. PytanieQuiz: useBalance
  19. PytanieQuiz: viem
  20. Ułóż w kolejnościSortowanie poziome: wagmi config
  21. Zadanie z kodemGap: useWriteContract dla transferu
  22. Zadanie z kodemGap: RainbowKit Integration
  23. Kliknij w kolejnościSortowanie: Transaction States
  24. PytanieQuiz: The Graph
  25. PytanieQuiz: Subgraph
  26. PytanieQuiz: ENS
  27. PytanieQuiz: Web3Modal
  28. Ułóż w kolejnościSortowanie: dApp Setup Flow
  29. Zadanie z kodemGap: Chain Switching
  30. Zadanie z kodemGap: ENS Display
  31. Ułóż w kolejnościSortowanie poziome: useReadContract config
  32. Kliknij w kolejnościSortowanie: Chain Operations
  33. PytanieQuiz: Account Abstraction (ERC-4337)
  34. PytanieQuiz: GraphQL w The Graph
  35. PytanieQuiz: useWaitForTransactionReceipt
  36. Zadanie z kodemGap: useBalance Hook
  37. Zadanie z kodemGap: ConnectKit Setup
  38. Ułóż w kolejnościSortowanie: Chain Switch Flow
  39. Kliknij w kolejnościSortowanie: wagmi Ecosystem
  40. Zadanie z kodemGap: The Graph Query
  41. Zadanie z kodemGap: Full Wallet Component
  42. Ułóż w kolejnościSortowanie poziome: useWriteContract config
  43. Projekt do wysłaniaWyślij projekt do mentora
  44. RozmowaZakończenie modułu 11