PricingLoginStart free
Blokkjede-smartkontrakter med Solidity · leksjon

Implementering av en ERC-20-token

Utvikle og distribuer din egen ERC-20-kompatible token, inkludert funksjonene transfer, approve og allowance.

Leksjon 2 av 411 trinn

Implementering av en ERC-20-token er en gratis leksjon i Blokkjede-smartkontrakter med Solidity på CoddyKit. Dette er leksjon 2 av 4. Du kan lese hele leksjonen gratis nedenfor – og deretter øve praktisk i nettleseren med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i Blokkjede-smartkontrakter med Solidity, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i Blokkjede-smartkontrakter med Solidity inneholder totalt 4 leksjoner.

Bygg ditt eget ERC-20-token

Velkommen! I denne leksjonen lærer du å implementere ditt helt eget ERC-20-kompatible token. Vi går gjennom de viktigste funksjonene og variablene som utgjør denne mye brukte standarden.

Ved slutten vil du ha en grunnleggende forståelse av hvordan disse tokenene fungerer på Ethereum-blokkjeden.

Tokenidentitet: navn, symbol, desimaler

Alle ERC-20-tokener trenger grunnleggende identifiserende informasjon: et name, et symbol og decimals. Dette er ofte offentlige tilstandsvariabler.

  • name: Det fullstendige navnet på tokenet ditt (f.eks. "MyCoddyToken").
  • symbol: Et kort ticker-symbol (f.eks. "MCT").
  • decimals: Hvor mange desimaler tokenet kan deles inn i (vanligvis 18, som Ether).

La oss begynne kontrakten med disse egenskapene:

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

contract MyToken {
  string public name = "MyCoddyToken";
  string public symbol = "MCT";
  uint8 public decimals = 18; // Common for ERC-20
}

Total forsyning og opprinnelig oppretting

Variabelen totalSupply holder oversikt over alle eksisterende tokener. Vi trenger også en måte å lagre hver brukers beholdning på, vanligvis ved hjelp av en mapping.

Constructor er en spesiell funksjon som bare kjøres én gang når kontrakten distribueres. Vi bruker den til å angi den opprinnelige totalSupply og tildele alle de opprinnelige tokenene til adressen som distribuerte kontrakten.

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

contract MyToken {
  string public name = "MyCoddyToken";
  string public symbol = "MCT";
  uint8 public decimals = 18;

  uint256 public totalSupply; // Total tokens in existence
  mapping(address => uint256) private _balances; // User balances

  constructor(uint256 initialSupply) {
    totalSupply = initialSupply;
    _balances[msg.sender] = initialSupply; // Mints to deployer
  }
}

Kontrollere beholdninger: `balanceOf`

Funksjonen balanceOf lar hvem som helst spørre etter tokenbeholdningen til en bestemt adresse. Det er en view-funksjon, noe som betyr at den ikke endrer tilstanden til kontrakten og ikke koster gas å kalle utenfor blokkjeden.

Vi henter beholdningen fra _balances-tilordningen vår.

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

contract MyToken {
  string public name = "MyCoddyToken";
  string public symbol = "MCT";
  uint8 public decimals = 18;

  uint256 public totalSupply;
  mapping(address => uint256) private _balances;

  constructor(uint256 initialSupply) {
    totalSupply = initialSupply;
    _balances[msg.sender] = initialSupply;
  }

  function balanceOf(address account) public view returns (uint256) {
    return _balances[account];
  }
}

Direkte overføringer: `transfer`

Funksjonen transfer gjør det mulig for en tokeninnehaver å sende tokener direkte til en annen adresse. Det er en kjernefunksjon i ERC-20-standarden.

Før overføringen må vi kontrollere at avsenderen har tilstrekkelig beholdning. Etter overføringen genererer vi en Transfer-hendelse, som er avgjørende for at blokkjedeutforskere og dApps skal kunne spore tokenbevegelser.

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

contract MyToken {
  string public name = "MyCoddyToken";
  string public symbol = "MCT";
  uint8 public decimals = 18;

  uint256 public totalSupply;
  mapping(address => uint256) private _balances;

  // ERC-20 events
  event Transfer(address indexed from, address indexed to, uint256 value);
  event Approval(address indexed owner, address indexed spender, uint256 value);

  constructor(uint256 initialSupply) {
    totalSupply = initialSupply;
    _balances[msg.sender] = initialSupply;
    emit Transfer(address(0), msg.sender, initialSupply); // Minting event
  }

  function balanceOf(address account) public view returns (uint256) {
    return _balances[account];
  }

  function transfer(address recipient, uint256 amount) public returns (bool) {
    require(_balances[msg.sender] >= amount, "Insufficient balance");

    _balances[msg.sender] -= amount;
    _balances[recipient] += amount;
    emit Transfer(msg.sender, recipient, amount);
    return true;
  }
}

Delegert bruk: `approve`

Funksjonen approve lar en tokeninnehaver (owner) gi en annen adresse (spender) tillatelse til å bruke en bestemt mengde av tokenene sine på sine vegne.

Dette er avgjørende for samhandling med desentraliserte applikasjoner (dApps), der du kanskje vil at en smartkontrakt skal administrere tokenene dine (f.eks. ved staking eller handel). Vi sporer disse godkjenningene i en _allowances-tilordning.

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

contract MyToken {
  string public name = "MyCoddyToken";
  string public symbol = "MCT";
  uint8 public decimals = 18;

  uint256 public totalSupply;
  mapping(address => uint256) private _balances;
  mapping(address => mapping(address => uint256)) private _allowances; // New: owner => (spender => amount)

  event Transfer(address indexed from, address indexed to, uint256 value);
  event Approval(address indexed owner, address indexed spender, uint256 value);

  constructor(uint256 initialSupply) {
    totalSupply = initialSupply;
    _balances[msg.sender] = initialSupply;
    emit Transfer(address(0), msg.sender, initialSupply);
  }

  function balanceOf(address account) public view returns (uint256) {
    return _balances[account];
  }

  function transfer(address recipient, uint256 amount) public returns (bool) {
    require(_balances[msg.sender] >= amount, "Insufficient balance");
    _balances[msg.sender] -= amount;
    _balances[recipient] += amount;
    emit Transfer(msg.sender, recipient, amount);
    return true;
  }

  function approve(address spender, uint256 amount) public returns (bool) {
    _allowances[msg.sender][spender] = amount;
    emit Approval(msg.sender, spender, amount);
    return true;
  }
}

Kontrollere tillatelse: `allowance`

Funksjonen allowance lar deg kontrollere hvor mange tokener en bestemt spender for øyeblikket har tillatelse til å overføre fra beholdningen til en owner.

Dette er en view-funksjon, på samme måte som balanceOf, og hjelper eksterne applikasjoner med å forstå bruksgrensene som brukerne har satt.

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

contract MyToken {
  string public name = "MyCoddyToken";
  string public symbol = "MCT";
  uint8 public decimals = 18;

  uint256 public totalSupply;
  mapping(address => uint256) private _balances;
  mapping(address => mapping(address => uint256)) private _allowances;

  event Transfer(address indexed from, address indexed to, uint256 value);
  event Approval(address indexed owner, address indexed spender, uint256 value);

  constructor(uint256 initialSupply) {
    totalSupply = initialSupply;
    _balances[msg.sender] = initialSupply;
    emit Transfer(address(0), msg.sender, initialSupply);
  }

  function balanceOf(address account) public view returns (uint256) {
    return _balances[account];
  }

  function allowance(address owner, address spender) public view returns (uint256) {
    return _allowances[owner][spender];
  }

  function transfer(address recipient, uint256 amount) public returns (bool) {
    require(_balances[msg.sender] >= amount, "Insufficient balance");
    _balances[msg.sender] -= amount;
    _balances[recipient] += amount;
    emit Transfer(msg.sender, recipient, amount);
    return true;
  }

  function approve(address spender, uint256 amount) public returns (bool) {
    _allowances[msg.sender][spender] = amount;
    emit Approval(msg.sender, spender, amount);
    return true;
  }
}

Bruk på andres vegne: `transferFrom`

Funksjonen transferFrom brukes av en spender (som har fått godkjenning) til å flytte tokener fra beholdningen til en owner til en recipient.

Den krever kontroller av både avsenderens beholdning og den tildelte tillatelsen. Etter en vellykket overføring reduseres tillatelsen med det overførte beløpet.

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

contract MyToken {
  string public name = "MyCoddyToken";
  string public symbol = "MCT";
  uint8 public decimals = 18;

  uint256 public totalSupply;
  mapping(address => uint256) private _balances;
  mapping(address => mapping(address => uint256)) private _allowances;

  event Transfer(address indexed from, address indexed to, uint256 value);
  event Approval(address indexed owner, address indexed spender, uint256 value);

  constructor(uint256 initialSupply) {
    totalSupply = initialSupply;
    _balances[msg.sender] = initialSupply;
    emit Transfer(address(0), msg.sender, initialSupply);
  }

  function balanceOf(address account) public view returns (uint256) {
    return _balances[account];
  }

  function allowance(address owner, address spender) public view returns (uint256) {
    return _allowances[owner][spender];
  }

  function transfer(address recipient, uint256 amount) public returns (bool) {
    require(_balances[msg.sender] >= amount, "Insufficient balance");
    _balances[msg.sender] -= amount;
    _balances[recipient] += amount;
    emit Transfer(msg.sender, recipient, amount);
    return true;
  }

  function approve(address spender, uint256 amount) public returns (bool) {
    _allowances[msg.sender][spender] = amount;
    emit Approval(msg.sender, spender, amount);
    return true;
  }

  function transferFrom(
    address sender,
    address recipient,
    uint256 amount
  ) public returns (bool) {
    require(_balances[sender] >= amount, "Insufficient balance from sender");
    require(_allowances[sender][msg.sender] >= amount, "Insufficient allowance");

    _allowances[sender][msg.sender] -= amount;
    _balances[sender] -= amount;
    _balances[recipient] += amount;
    emit Transfer(sender, recipient, amount);
    return true;
  }
}

Full minimal ERC-20-implementasjon

Her er en komplett, minimal ERC-20-tokenkontrakt. Selv om mer avanserte implementasjoner (som OpenZeppelin sine) har flere funksjoner og sikkerhetskontroller, dekker denne koden alle kjernefunksjonene som kreves av standarden.

Du kan distribuere denne kontrakten til et testnettverk for å opprette ditt eget fungerende token!

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

contract MyToken {
  string public name = "MyCoddyToken";
  string public symbol = "MCT";
  uint8 public decimals = 18;

  uint256 public totalSupply;
  mapping(address => uint256) private _balances;
  mapping(address => mapping(address => uint256)) private _allowances;

  event Transfer(address indexed from, address indexed to, uint256 value);
  event Approval(address indexed owner, address indexed spender, uint256 value);

  constructor(uint256 initialSupply) {
    totalSupply = initialSupply;
    _balances[msg.sender] = initialSupply;
    emit Transfer(address(0), msg.sender, initialSupply);
  }

  function balanceOf(address account) public view returns (uint256) {
    return _balances[account];
  }

  function allowance(address owner, address spender) public view returns (uint256) {
    return _allowances[owner][spender];
  }

  function transfer(address recipient, uint256 amount) public returns (bool) {
    require(_balances[msg.sender] >= amount, "Insufficient balance");
    _balances[msg.sender] -= amount;
    _balances[recipient] += amount;
    emit Transfer(msg.sender, recipient, amount);
    return true;
  }

  function approve(address spender, uint256 amount) public returns (bool) {
    _allowances[msg.sender][spender] = amount;
    emit Approval(msg.sender, spender, amount);
    return true;
  }

  function transferFrom(
    address sender,
    address recipient,
    uint256 amount
  ) public returns (bool) {
    require(_balances[sender] >= amount, "Insufficient balance from sender");
    require(_allowances[sender][msg.sender] >= amount, "Insufficient allowance");

    _allowances[sender][msg.sender] -= amount;
    _balances[sender] -= amount;
    _balances[recipient] += amount;
    emit Transfer(sender, recipient, amount);
    return true;
  }
}

Sjekk av ERC-20-kjernefunksjoner

Du har lært om de viktigste funksjonene i et ERC-20-token. Nå skal vi teste kunnskapene dine!

Besvar den i den interaktive leksjonen

Oppsummering: Ditt eget token

Gratulerer! Du har nå implementert kjernelogikken for et ERC-20-token. Du har lært å definere egenskapene, administrere total forsyning og individuelle beholdninger, og aktivere både direkte og delegerte tokenoverføringer.

Det er viktig å forstå disse grunnleggende byggeklossene for å kunne arbeide med alle typer tokener på Ethereum-blokkjeden. Deretter kan du utforske hvordan du integrerer eksisterende ERC-20-biblioteker eller legger til mer avanserte funksjoner!

Gratis å komme i gang

Lær deg Blokkjede-smartkontrakter med Solidity med en AI-veileder – gratis

Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.

Kurs
12
Leksjoner
48
Start læringen gratisSe hele kurset

Ofte stilte spørsmål

Er leksjonen «Implementering av en ERC-20-token» gratis?

Ja – hele teksten i «Implementering av en ERC-20-token» er gratis å lese her på nettet. For å øve interaktivt med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt, og for å låse opp resten av Blokkjede-smartkontrakter med Solidity-kurset, kan du oppgradere til CoddyKit PRO. Kurset i Blokkjede-smartkontrakter med Solidity inneholder totalt 4 leksjoner.

Hva lærer jeg i «Implementering av en ERC-20-token»?

Utvikle og distribuer din egen ERC-20-kompatible token, inkludert funksjonene transfer, approve og allowance. Du øver på Blokkjede-smartkontrakter med Solidity med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.

Trenger jeg erfaring for å begynne med Blokkjede-smartkontrakter med Solidity?

Ingen tidligere erfaring er nødvendig. Blokkjede-smartkontrakter med Solidity på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 2 av 4.

Hvor lang tid tar leksjonen «Implementering av en ERC-20-token»?

De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.

Kan jeg skrive og kjøre kode i denne Blokkjede-smartkontrakter med Solidity-leksjonen?

Ja. Alle Blokkjede-smartkontrakter med Solidity-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.

Alle leksjonene i dette kurset

  1. ERC-20-standarden for fungible tokens
  2. Implementering av en ERC-20-token
  3. ERC-721-ikke-fungible tokens (NFT-er)
  4. ERC-1155-standarden for flere token-typer
← Tilbake til Blokkjede-smartkontrakter med Solidity