Kurs Blockchain i Web3 · Moduł 8: ERC-20 & Token Creation

Tokeny ERC-20 - Złoto Krypty

3 min czytania ·
W tej lekcji7

Witaj w Mennicy! Atlas tutaj. Dziś poznasz ERC-20 - standard tworzenia zamiennych tokenów, czyli "podziemnego złota" Krypty.

Czym jest ERC-20?

ERC-20 to standard definiujący interfejs dla zamiennych (fungible) tokenów na Ethereum. Każdy token ERC-20 ma identyczne funkcje, co ułatwia integrację z portfelami i giełdami.

┌─────────────────────────────────────────────────────────────────┐
│                    STANDARD ERC-20                               │
├─────────────────────────────────────────────────────────────────┤
│                                                                  │
│  FUNKCJE WYMAGANE:                                              │
│  ├── totalSupply()      - całkowita podaż                       │
│  ├── balanceOf(address) - saldo adresu                          │
│  ├── transfer(to, amount) - transfer tokenów                    │
│  ├── allowance(owner, spender) - dozwolone do wydania           │
│  ├── approve(spender, amount) - zatwierdzenie wydatków          │
│  └── transferFrom(from, to, amount) - transfer w imieniu        │
│                                                                  │
│  EVENTY WYMAGANE:                                               │
│  ├── Transfer(from, to, amount)                                 │
│  └── Approval(owner, spender, amount)                           │
│                                                                  │
│  OPCJONALNE:                                                     │
│  ├── name()     - nazwa tokena (np. "Tether USD")               │
│  ├── symbol()   - symbol (np. "USDT")                           │
│  └── decimals() - miejsca dziesiętne (zwykle 18)                │
│                                                                  │
└─────────────────────────────────────────────────────────────────┘

Popularne tokeny ERC-20

Token      │ Symbol │ Decimals │ Użycie
───────────┼────────┼──────────┼──────────────────
USDT       │ USDT   │ 6        │ Stablecoin (USD)
USDC       │ USDC   │ 6        │ Stablecoin (USD)
DAI        │ DAI    │ 18       │ Stablecoin (zdecentralizowany)
WETH       │ WETH   │ 18       │ Wrapped Ether
UNI        │ UNI    │ 18       │ Governance (Uniswap)
LINK       │ LINK   │ 18       │ Oracle (Chainlink)

Interakcja z tokenem ERC-20

import { ethers } from "ethers";

const ERC20_ABI = [
  "function name() view returns (string)",
  "function symbol() view returns (string)",
  "function decimals() view returns (uint8)",
  "function totalSupply() view returns (uint256)",
  "function balanceOf(address) view returns (uint256)",
  "function transfer(address to, uint256 amount) returns (bool)",
  "function approve(address spender, uint256 amount) returns (bool)",
  "function allowance(address owner, address spender) view returns (uint256)",
  "function transferFrom(address from, address to, uint256 amount) returns (bool)",
  "event Transfer(address indexed from, address indexed to, uint256 amount)",
  "event Approval(address indexed owner, address indexed spender, uint256 amount)"
];

const provider = new ethers.JsonRpcProvider("https://...");
const usdtAddress = "0xdAC17F958D2ee523a2206206994597C13D831ec7";
const token = new ethers.Contract(usdtAddress, ERC20_ABI, provider);

// Odczyt danych
const name = await token.name();
const symbol = await token.symbol();
const decimals = await token.decimals();
const balance = await token.balanceOf("0x...");

console.log(`${name} (${symbol})`);
console.log(`Balance: ${ethers.formatUnits(balance, decimals)}`);

Transfer tokenów

const wallet = new ethers.Wallet(privateKey, provider);
const tokenWithSigner = token.connect(wallet);

// Transfer
const tx = await tokenWithSigner.transfer(
  "0x...", // odbiorca
  ethers.parseUnits("100", decimals) // ilość
);
await tx.wait();

Approve i TransferFrom

// 1. Właściciel zatwierdza (approve)
const approveTx = await tokenWithSigner.approve(
  spenderAddress,
  ethers.parseUnits("1000", decimals)
);
await approveTx.wait();

// 2. Spender może teraz użyć transferFrom
const transferTx = await tokenAsSpender.transferFrom(
  ownerAddress,
  recipientAddress,
  ethers.parseUnits("100", decimals)
);
await transferTx.wait();

Tworzenie własnego tokena

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

import "@openzeppelin/contracts/token/ERC20/ERC20.sol";

contract KryptaCoin is ERC20 {
    constructor(uint256 initialSupply) ERC20("Krypta Coin", "KRYPTA") {
        _mint(msg.sender, initialSupply * 10**decimals());
    }
}

Podsumowanie

  • ERC-20 - standard tokenów zamiennych
  • Funkcje: transfer, approve, transferFrom
  • Interakcja z ethers.js
  • Decimals i formatowanie
  • Tworzenie własnego tokena
Kod do tej lekcji: index.js
// ERC-20 Standard - podstawy

class ERC20Token {
  constructor(name, symbol, decimals, initialSupply, owner) {
    // Token metadata
    this._name = name;
    this._symbol = symbol;
    this._decimals = decimals;

    // State
    this._totalSupply = BigInt(initialSupply) * BigInt(10 ** decimals);
    this._balances = new Map();
    this._allowances = new Map();

    // Initial mint to owner
    this._balances.set(owner, this._totalSupply);

    console.log(`Deployed ${name} (${symbol})`);
    console.log(`   Total Supply: ${this.formatAmount(this._totalSupply)} ${symbol}`);
    console.log(`   Owner: ${owner}\n`);
  }

  // === ERC-20 Required Functions ===

  name() { return this._name; }
  symbol() { return this._symbol; }
  decimals() { return this._decimals; }
  totalSupply() { return this._totalSupply; }

  balanceOf(account) {
    return this._balances.get(account) || BigInt(0);
  }

  transfer(from, to, amount) {
    const amountBN = BigInt(amount);
    const fromBalance = this.balanceOf(from);

    if (fromBalance < amountBN) {
      throw new Error("ERC20: transfer amount exceeds balance");
    }

    this._balances.set(from, fromBalance - amountBN);
    this._balances.set(to, this.balanceOf(to) + amountBN);

    console.log(`Transfer: ${from.slice(0,8)}... → ${to.slice(0,8)}...`);
    console.log(`   Amount: ${this.formatAmount(amountBN)} ${this._symbol}`);

    return true;
  }

  approve(owner, spender, amount) {
    if (!this._allowances.has(owner)) {
      this._allowances.set(owner, new Map());
    }
    this._allowances.get(owner).set(spender, BigInt(amount));

    console.log(`Approval: ${owner.slice(0,8)}... → ${spender.slice(0,8)}...`);
    console.log(`   Amount: ${this.formatAmount(BigInt(amount))} ${this._symbol}`);

    return true;
  }

  allowance(owner, spender) {
    return this._allowances.get(owner)?.get(spender) || BigInt(0);
  }

  transferFrom(spender, from, to, amount) {
    const amountBN = BigInt(amount);
    const currentAllowance = this.allowance(from, spender);

    if (currentAllowance < amountBN) {
      throw new Error("ERC20: insufficient allowance");
    }

    // Decrease allowance
    this._allowances.get(from).set(spender, currentAllowance - amountBN);

    // Transfer
    return this.transfer(from, to, amount);
  }

  // Helper
  formatAmount(amount) {
    return (Number(amount) / (10 ** this._decimals)).toLocaleString();
  }
}

console.log("=== ERC-20 TOKEN STANDARD ===\n");

// Deploy token
const token = new ERC20Token(
  "Atlas Coin",
  "ATLAS",
  18,
  1000000, // 1M tokens
  "0xOwner123"
);

// Check balances
console.log("--- Balances ---");
console.log(`Owner: ${token.formatAmount(token.balanceOf("0xOwner123"))} ATLAS`);
console.log(`Alice: ${token.formatAmount(token.balanceOf("0xAlice456"))} ATLAS\n`);

// Transfer
console.log("--- Transfer ---");
token.transfer("0xOwner123", "0xAlice456", "100000000000000000000000"); // 100k

// Approve & TransferFrom (typowy flow dla DEX)
console.log("\n--- Approve for DEX ---");
token.approve("0xAlice456", "0xUniswapRouter", "50000000000000000000000"); // 50k

console.log("\n--- DEX executes transferFrom ---");
token.transferFrom(
  "0xUniswapRouter",
  "0xAlice456",
  "0xLiquidityPool",
  "50000000000000000000000"
);

console.log("\n--- Final Balances ---");
console.log(`Owner: ${token.formatAmount(token.balanceOf("0xOwner123"))} ATLAS`);
console.log(`Alice: ${token.formatAmount(token.balanceOf("0xAlice456"))} ATLAS`);
console.log(`Pool:  ${token.formatAmount(token.balanceOf("0xLiquidityPool"))} ATLAS`);

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. ERC-20 to:

  2. 2. Funkcja transfer(to, amount) w ERC-20:

To 2 z 15 pytań do tej lekcji. Pozostałe rozwiążesz w grze.

Zadania praktyczne w grze

  • Układanie w pionie

    Ułóż kroki użycia approve/transferFrom:

  • Edytor kodu

    Uzupełnij kod odczytu danych tokena

  • Edytor kodu

    Uzupełnij kod transferu

  • Układanie w poziomie

    Jak wygląda wywołanie funkcji transfer?

  • Klikanie w kolejności

    Kliknij w przyciski w odpowiedniej kolejności, aby zbudować event Transfer

  • Edytor kodu

    Uzupełnij kod approve

  • Układanie w pionie

    Ułóż etapy vesting schedule (harmonogramu przekazywania tokenów):

  • Klikanie w kolejności

    Kliknij w przyciski w odpowiedniej kolejności, aby zbudować deklarację balanceOf

  • Edytor kodu

    Uzupełnij kod sprawdzania salda

  • Układanie w poziomie

    Jak wygląda wywołanie funkcji approve?

  • Edytor kodu

    Uzupełnij kod funkcji mint

  • Edytor kodu

    Uzupełnij kod funkcji burn

  • Układanie w pionie

    Ułóż kroki pełnego permit flow:

  • Układanie w poziomie

    Jak wygląda wywołanie funkcji permit?

  • Klikanie w kolejności

    Kliknij w przyciski w odpowiedniej kolejności, aby zbudować event Approval

  • Edytor kodu

    Uzupełnij kod sprawdzania allowance

  • Układanie w pionie

    Ułóż kroki stakingu tokenów ERC-20:

  • Edytor kodu

    Uzupełnij kod sprawdzania maksymalnej podaży

  • Układanie w poziomie

    Jak wygląda deklaracja funkcji mint w Solidity?

  • Klikanie w kolejności

    Kliknij w przyciski w odpowiedniej kolejności, aby sprawdzić saldo kontraktu

  • Edytor kodu

    Uzupełnij kod pausable

  • Układanie w pionie

    Ułóż proces odblokowywania tokenów w vesting:

  • Edytor kodu

    Uzupełnij kod snapshot

  • Układanie w poziomie

    Jak wygląda emitowanie eventu Approval?

  • Układanie w pionie

    Ułóż kroki spalania tokenów (burn):

  1. PytanieQuiz: ERC-20
  2. PytanieQuiz: transfer()
  3. PytanieQuiz: approve()
  4. PytanieQuiz: transferFrom()
  5. PytanieQuiz: decimals
  6. PytanieQuiz: USDT decimals
  7. PytanieQuiz: allowance()
  8. Ułóż w kolejnościSortowanie: Flow approve + transferFrom
  9. Zadanie z kodemGap: Odczyt danych tokena
  10. Zadanie z kodemGap: Transfer tokenów
  11. Ułóż w kolejnościSortowanie poziome: składnia transfer
  12. Kliknij w kolejnościSortowanie: budowanie event Transfer
  13. Zadanie z kodemGap: Approve flow
  14. Ułóż w kolejnościSortowanie: Vesting schedule
  15. Kliknij w kolejnościSortowanie: budowanie ERC-20 interface
  16. Zadanie z kodemGap: Sprawdzanie salda
  17. Ułóż w kolejnościSortowanie poziome: składnia approve
  18. PytanieQuiz: totalSupply()
  19. PytanieQuiz: permit()
  20. PytanieQuiz: EIP-2612 deadline
  21. PytanieQuiz: mint vs transfer
  22. PytanieQuiz: cap - maksymalna podaż
  23. PytanieQuiz: snapshots
  24. PytanieQuiz: wrapped tokens
  25. PytanieQuiz: fee on transfer
  26. Zadanie z kodemGap: Funkcja mint
  27. Zadanie z kodemGap: Funkcja burn
  28. Ułóż w kolejnościSortowanie: Full permit flow
  29. Ułóż w kolejnościSortowanie poziome: permit call
  30. Kliknij w kolejnościSortowanie: budowanie event Approval
  31. Zadanie z kodemGap: Sprawdzanie allowance
  32. Ułóż w kolejnościSortowanie: Staking deposit
  33. Zadanie z kodemGap: Implementacja cap
  34. Ułóż w kolejnościSortowanie poziome: mint function
  35. Kliknij w kolejnościSortowanie: balanceOf + transfer
  36. Zadanie z kodemGap: Pausable toggle
  37. Ułóż w kolejnościSortowanie: Token vesting release
  38. Zadanie z kodemGap: Snapshot mechanism
  39. Ułóż w kolejnościSortowanie poziome: event Approval
  40. Ułóż w kolejnościSortowanie: Burning process
  41. Projekt do wysłaniaWyślij projekt do mentora
  42. RozmowaZakończenie modułu 8