Smarta blockkedjekontrakt med Solidity · Lektion

Implementera en ERC-20-token

Utveckla och driftsätt en egen ERC-20-kompatibel token, inklusive funktionerna transfer, approve och allowance.

Lektion 2 av 411 steg

Implementera en ERC-20-token är en gratis lektion i Smarta blockkedjekontrakt med Solidity på CoddyKit. Detta är lektion 2 av 4. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för Smarta blockkedjekontrakt med Solidity, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Smarta blockkedjekontrakt med Solidity innehåller totalt 4 lektioner.

Bygg er egen ERC-20-token

Välkomna! I den här lektionen lär ni er att implementera er egen ERC-20-kompatibla token. Vi går igenom de viktiga funktionerna och variablerna som utgör denna mycket använda standard.

Efter lektionen kommer ni att ha en grundläggande förståelse för hur dessa tokens fungerar på Ethereum-blockkedjan.

Tokenidentitet: namn, symbol och decimaler

Varje ERC-20-token behöver grundläggande identifierande information: ett namn, en symbol och decimaler. Dessa är ofta offentliga tillståndsvariabler.

name: Tokenens fullständiga namn (t.ex. "MyCoddyToken").
symbol: En kort tokensymbol (t.ex. "MCT").
decimals: Hur många decimaler tokenen kan delas upp i (vanligen 18, precis som Ether).

Låt oss börja vårt kontrakt med dessa egenskaper:

// 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
}

Totalt utbud och initial prägling

Variabeln totalSupply håller reda på alla befintliga tokens. Vi behöver också ett sätt att lagra varje användares saldo, vanligtvis med en mapping.

Konstruktorn är en särskild funktion som körs en gång när kontraktet distribueras. Vi använder den för att ange det initiala totalSupply och tilldela alla initiala tokens till den distribuerande adressen.

// 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
  }
}

Kontrollera saldon: `balanceOf`

Funktionen balanceOf gör det möjligt för vem som helst att fråga efter tokensaldot för en specifik adress. Det är en view-funktion, vilket innebär att den inte ändrar kontraktets tillstånd och inte kostar någon gas att anropa off-chain.

Vi hämtar saldot från vår _balances-mapping.

// 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];
  }
}

Direkta överföringar: `transfer`

Funktionen transfer gör det möjligt för en tokeninnehavare att skicka tokens direkt till en annan adress. Det är en kärnfunktion i ERC-20-standarden.

Före överföringen måste vi säkerställa att avsändaren har tillräckligt saldo. Efter överföringen genererar vi en Transfer-händelse, vilket är viktigt för att blockkedjeutforskare och dApps ska kunna spåra tokenöverföringar.

// 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;
  }
}

Delegerad användning: `approve`

Funktionen approve gör det möjligt för en tokeninnehavare ( owner ) att ge en annan adress ( spender ) tillstånd att använda en viss mängd av innehavarens tokens för dennes räkning.

Detta är avgörande vid interaktion med decentraliserade applikationer (dApps), där ni kanske vill att ett smart kontrakt ska hantera era tokens (t.ex. för staking eller handel). Vi spårar dessa godkännanden i en _allowances-mapping.

// 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;
  }
}

Kontrollera tillåtelse: `allowance`

Funktionen allowance låter er kontrollera hur många tokens en viss spender för närvarande har tillstånd att överföra från en owners saldo.

Detta är en view-funktion, ungefär som balanceOf, och hjälper externa applikationer att förstå de användningsgränser som användarna har angett.

// 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;
  }
}

Använda tokens för någon annans räkning: `transferFrom`

Funktionen transferFrom används av en spender (som har godkänts) för att flytta tokens från en owners saldo till en recipient.

Den kräver kontroller av både avsändarens saldo och den beviljade tillåtelsen. Efter en lyckad överföring minskas tillåtelsen med det överförda antalet.

// 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;
  }
}

Fullständig minimal ERC-20-implementation

Här är ett komplett, minimalt ERC-20-tokenkontrakt. Även om mer avancerade implementationer (som OpenZeppelins) innehåller ytterligare funktioner och säkerhetskontroller, täcker denna kod alla kärnfunktioner som standarden kräver.

Ni kan distribuera detta kontrakt till ett testnät för att skapa en egen fungerande 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;
  }
}

Kontroll av ERC-20-kärnfunktioner

Ni har lärt er om de viktigaste funktionerna för en ERC-20-token. Nu testar vi era kunskaper!

Besvara frågan i den interaktiva lektionen

Sammanfattning: er egen token

Grattis! Ni har nu implementerat kärnlogiken för en ERC-20-token. Ni har lärt er att definiera dess egenskaper, hantera totalt utbud och individuella saldon samt möjliggöra både direkta och delegerade tokenöverföringar.

Att förstå dessa grundläggande byggstenar är viktigt för att kunna arbeta med alla tokens på Ethereum-blockkedjan. Därefter kan ni utforska hur ni integrerar befintliga ERC-20-bibliotek eller lägger till mer avancerade funktioner!

Gratis att börja

Lär dig Smarta blockkedjekontrakt med Solidity med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 12
Lektioner: 48

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Implementera en ERC-20-token” gratis?

Ja – hela texten till ”Implementera en ERC-20-token” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i Smarta blockkedjekontrakt med Solidity, kan Ni uppgradera till CoddyKit PRO. Kursen i Smarta blockkedjekontrakt med Solidity innehåller totalt 4 lektioner.

Vad lär jag mig i ”Implementera en ERC-20-token”?

Utveckla och driftsätt en egen ERC-20-kompatibel token, inklusive funktionerna transfer, approve och allowance. Ni övar på Smarta blockkedjekontrakt med Solidity med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig Smarta blockkedjekontrakt med Solidity?

Du behöver inga förkunskaper. Utbildningen i Smarta blockkedjekontrakt med Solidity på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 2 av 4.

Hur lång tid tar lektionen ”Implementera en ERC-20-token”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här Smarta blockkedjekontrakt med Solidity-lektionen?

Ja. Varje Smarta blockkedjekontrakt med Solidity-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

Standarden ERC-20 för fungibla token
Implementera en ERC-20-token
Icke-fungibla token (NFT:er) enligt ERC-721
ERC-1155-standarden för flera token-typer

← Tillbaka till Smarta blockkedjekontrakt med Solidity