ERC-20

ERC-20 (Ethereum Request for Comments 20) – to standard tokenów w sieci Ethereum, używany jest w inteligentnych kontraktach. Standard ten dyktuje listę zasad i kroków, które inteligentny kontrakt musi przestrzegać aby móc go zaimplementować. Dzięki niemu deweloperzy mają możliwość łatwiejszego oraz zestandaryzowanego tworzenia tokenów działających w sieci Ethereum.

Historia

Standard ERC-20 został zaproponowany przez Fabiana Vogelstellera w listopadzie 2015 a oficjalnie został rozpoznawany we wrześniu 2017. Stworzenie tego standardu poprzedził koncept do Ethereum Improvement Proposal (EIP). W EIP developerzy opisują nowe funkcje z protokołami i standardami, następnie komitet dokonuje analizy i zatwierdza dane EIP. Końcowa wersja została zatwierdzona w EIP-20, nazwa została przyjęta od tej wersji. Sam ERC (Ethereum request for comment) jest podobny do konceptu Request for comment (RFC) zaproponowanego przez Internet Engineering Task Force (IETF), miał on na celu przekazanie deweloperom i użytkownikom instrukcji oraz wymagań technicznych.

Popularność ERC-20

ERC-20 jest dominującą ścieżką tworzenia nowych wymienialnych tokenów. Standard ten zyskał duża popularność wśród firm crowdfundingowych dzięki Initial Coin Offering (ICO), dzięki któremu firmy wprowadzające np. nową kryptowalutę lub zdecentralizowaną aplikację mogą pozyskać fundusze od inwestorów. Popularny jest także ERC-721 do tworzenia niewymienialnych tokenów (NFT).

Wiele nowo powstałych projektów kryptowalut, po wprowadzeniu standardu zyskało miliony środków na rozwój właśnie dzięki ICO, najpopularniejszy z nich to EOS, który zebrał ponad 185 milionów dolarów.

Rodzaje tokenów

Utility Tokens

Utility tokens (pl. Tokeny użytkowe) to tokeny dzięki którym uzyskujemy dostęp do danej usługi lub produktu oferowanego przez konkretną firmę. Bardzo często można je kupić przez Initial Coin Offering (ICO) w celu wsparcia projektu, a następnie korzystania z jego usług. Cena tokena uzależniona jest w głównej mierze od powodzenia danego projektu.

Utility Tokens

Przykłady Utility Tokens

• Basic Attention Token (BAT)

• 0x (ZRX)
• Filecoin (FIL)
• Golem (GNT)
• Binance coin (BNB)
• Aurora (AOA)

Security Token

Posiadanie takiego tokenu odzwierciedla posiadanie akcji, udziałów, obligacji, własności danego aktywa. Tokeny te można traktować jako papiery wartościowe, są w pełni regulowane przez prawo. Zastosowanie tokenu w celu nabycia akcji wśród inwestorów można zaprojektować tak aby zapewniał prawo do głosu i dywidendy.

Przykłady tokenów ERC-20

Przykłady tokenów ERC-20

• VeChain
• Tron
• Binance Coin
• DigixDAO
• ICON
• RChain
• EOS
• Loopring
• IOStoken
• Basic Attention TokenBasic Attention Token
• Golem
• 0x
• OmiseGO
• Tether
• Chainlink
• Wrapped Bitcoin
• Augur

Implementacja ERC-20

Aby token był w standardzie ERC-20, jego inteligenty kontrakt musi zawierać poniższe metody i wydarzenia.

Metody

• Name – Nazwa tokenu
• Symbol – Symbol/Skrót tokenu
• Decimals – Punkty dziesiętne tokenu
• TotalSupply – Całkowita podaż tokenów
• BalanceOf – Informuje o stanie konta użytkownika
• Transfer – Przelewa tokeny na określony adres
• TransferFrom – Przelewa tokeny z określonego adresu
• Approve – Zezwala na wypłatę tokenów z konta
• Allowance – Zwraca tokeny do właściciela konta

function name() public view returns (string)
function symbol() public view returns (string)
function decimals() public view returns (uint8)
function totalSupply() public view returns (uint256)
function balanceOf(address _owner) public view returns (uint256 balance)
function transfer(address _to, uint256 _value) public returns (bool success)
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success)
function approve(address _spender, uint256 _value) public returns (bool success)
function allowance(address _owner, address _spender) public view returns (uint256 remaining)

Wydarzenia

event Transfer(address indexed _from, address indexed _to, uint256 _value)
event Approval(address indexed _owner, address indexed _spender, uint256 _value)

Inne standardy

Pomimo szerokiego wsparcia dla standardu ERC-20 oraz powstawania nowych tokenów, niektórzy tworzą nowe standardy z racji na myśl o ograniczeniach ERC-20.

Przykładowe standardy oparte na ERC-20:

• ERC-621
• ERC-827
• ERC-223

Dla przykładu, standard ERC223 rozwiązuje problemy takie jak:

• Przypadkowe wysłanie tokenów – Przypadkowe wywołanie funkcji transfer bez transferFrom w ERC-20 spowoduje utratę tokenów w kontrakcie odbiorcy
• Brak obsługi przychodzących transakcji – ERC-20 nie informuje odbiorcy o transakcji która się odbyła. Brak obsługi przychodzących transakcji tokenów oraz zablokowania niewspieranych tokenów
• Optymalizacja komunikacji – W ERC-20 aby wykonać transakcję address-to-contract należy wykonać dwie funkcje, approve oraz transferFrom. W ERC-223 jest to pojedyncza transakcja, która zużywa 2 razy mniej gasu
• Różnica w zachowaniu – Upodobnienie funkcjonowania do transakcji Ethereum, dzięki temu unikamy błędów podczas przesyłania tokenów oraz ułatwiamy pracę deweloperom kontraktów.

Przykładowa implementacja tokena ERC-20

Każdy może stworzyć swojego tokena w prosty sposób za pomocą platform internetowych z wirtualna maszyną Ethereum (EVM – Ethereum Virtual Machine) takich jak ethfiddle czy remix.ethereum.

Istnieją również biblioteki do bezpiecznej implementacji smart kontraktów takie jak OpenZeppelin.

Do implementacji na powyższych stronach potrzebny jest poniższy kod w języku Solidity, który odpowiada za tworzenie tokenu.

pragma solidity ^0.6.0;

interface IERC20 {

    function totalSupply() external view returns (uint256);
    function balanceOf(address account) external view returns (uint256);
    function allowance(address owner, address spender) external view returns (uint256);

    function transfer(address recipient, uint256 amount) external returns (bool);
    function approve(address spender, uint256 amount) external returns (bool);
    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);

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

contract ERC20Basic is IERC20 {

    string public constant name = "ERC20Basic";
    string public constant symbol = "ERC";
    uint8 public constant decimals = 18;

    event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
    event Transfer(address indexed from, address indexed to, uint tokens);

    mapping(address => uint256) balances;

    mapping(address => mapping (address => uint256)) allowed;

    uint256 totalSupply_;

    using SafeMath for uint256;

   constructor(uint256 total) public {
    totalSupply_ = total;
    balances[msg.sender] = totalSupply_;
    }

    function totalSupply() public override view returns (uint256) {
    return totalSupply_;
    }

    function balanceOf(address tokenOwner) public override view returns (uint256) {
        return balances[tokenOwner];
    }

    function transfer(address receiver, uint256 numTokens) public override returns (bool) {
        require(numTokens <= balances[msg.sender]);
        balances[msg.sender] = balances[msg.sender].sub(numTokens);
        balances[receiver] = balances[receiver].add(numTokens);
        emit Transfer(msg.sender, receiver, numTokens);
        return true;
    }

    function approve(address delegate, uint256 numTokens) public override returns (bool) {
        allowed[msg.sender][delegate] = numTokens;
        emit Approval(msg.sender, delegate, numTokens);
        return true;
    }

    function allowance(address owner, address delegate) public override view returns (uint) {
        return allowed[owner][delegate];
    }

    function transferFrom(address owner, address buyer, uint256 numTokens) public override returns (bool) {
        require(numTokens <= balances[owner]);
        require(numTokens <= allowed[owner][msg.sender]);

        balances[owner] = balances[owner].sub(numTokens);
        allowed[owner][msg.sender] = allowed[owner][msg.sender].sub(numTokens);
        balances[buyer] = balances[buyer].add(numTokens);
        emit Transfer(owner, buyer, numTokens);
        return true;
    }
}

library SafeMath {
    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
      assert(b <= a);
      return a - b;
    }

    function add(uint256 a, uint256 b) internal pure returns (uint256) {
      uint256 c = a + b;
      assert(c >= a);
      return c;
    }
}