Tokeny ERC20

Dzisiaj poruszę temat tokenów (np. personalnych) w standardzie ERC20. Stworzymy kod przykładowego tokena po czym wgramy go na lokalną sieć ethereum. O tym jak ją uruchomić pisałem tutaj.

Jeżeli nie wiesz czym są tokeny personalne i co w tym chodzi to w jednym z pierwszych wpisów wyjaśniałem w tym wpisie.

Wymagania wstępne

Oto czego użyjemy w przykładzie:

  • truffle npm install truffle -g pamiętaj żeby z niego korzystać wymagany jest NodeJs w wersji przynajmniej 8.9.4 (update node z konsoli: npm i npm@latest -g lub zwyczajnie pobierzcie z oficjalnej strony node najnowszą wersję i zainstalujcie)
  • openzeppelin – ale to zainstalujemy w następnym akapicie

Konfiguracja projektu

Po zainstalowaniu tych dwóch rzeczy pora na edycję pliku truffle-config.js.

Zaczynamy od zainicjowania struktury projektu:
truffle init
Następnie pobieramy bibliotekę @openzeppelin/contracts
npm install @openzeppelin/contracts

module.exports = {
  /**
   * Networks define how you connect to your ethereum client and let you set the
   * defaults web3 uses to send transactions. If you don't specify one truffle
   * will spin up a development blockchain for you on port 9545 when you
   * run `develop` or `test`. You can ask a truffle command to use a specific
   * network from the command line, e.g
   *
   * $ truffle test --network 
   */

  networks: {
    genache: {
      host: "127.0.0.1",
      port: 7545,
      network_id: "*"
    }
  },

  // Set default mocha options here, use special reporters etc.
  mocha: {
    // timeout: 100000
  },

  // Configure your compilers
  compilers: {
    solc: {
      // version: "0.5.1",    // Fetch exact version from solc-bin (default: truffle's version)
      // docker: true,        // Use "0.5.1" you've installed locally with docker (default: false)
      // settings: {          // See the solidity docs for advice about optimization and evmVersion
      //  optimizer: {
      //    enabled: false,
      //    runs: 200
      //  },
      //  evmVersion: "byzantium"
      // }
    }
  }
}

W specyfikacji standardu ERC20 jest określone jakie metody/funkcje musi udostępniać nasz token:

  • name – pełna nazwa naszego tokenu
  • symbol – nazwa skrótowa tokenu
  • decimals – liczba miejsc po przecinku do jakich token będzie podzielny
  • balanceOf – ilość tokenów na koncie wskazanym w paramterze metody
  • totalSupply – maksymalna liczba naszego tokena (najpopularniejsze 21 000 000)
  • transfer – metoda do przesyłania tokenów na podane konto
  • transferFrom – pozwala na przesyłanie tokenów z jednego konta na drugie przez adres osoby trzeciej
  • approve – funkcja określająca ile naszego tokena będzie mógł przesłać w naszym imieniu podany adres
  • allowance – metoda pozwalająca sprawdzić ilość tokenów, którą może przesłać w naszym imieniu dany adres

Oprócz metod wymagane są 2 eventy:

  • Transfer – wywoływany przy przelewaniu środków
  • Approval – wywoływany po pomyślnym wywołaniu metody/funkcji approve

W tym momencie trzeba podkreślić, że wymienione metody to minimalne wymaganie. Możemy rozbudować swój kontrakt o dodatkowe metody np. wyliczanie ilości tokenów do wypłaty w zamian za określoną liczbę ETH.
Pełną specyfikację i opis standardu ERC20 możecie znaleźć i przeczytać tutaj.

Implementacja

Przykład implementacji inteligentnego kontraktu będzie z życia wzięty, a będzie to przykładowa implementacja mojego tokena personalnego . Zaznaczam, że implementacja prawdziwego tokena może być inna od tej prezentowanej w tym wpisie, gdyż nigdy nie widziałem implementacji produkcyjnej 😉

pragma solidity >=0.4.21 <0.6.0;

import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/token/ERC20/ERC20Mintable.sol";
import "@openzeppelin/contracts/token/ERC20/ERC20Pausable.sol";
import "@openzeppelin/contracts/token/ERC20/ERC20Detailed.sol";

contract CHARToken is ERC20, ERC20Mintable, ERC20Pausable, ERC20Detailed {
  constructor() ERC20Detailed("Lukasz Charubin Token", "CHAR", 8) public {
    mint(msg.sender, 21000000 * (10 ** uint256(decimals())));
  }
}

Następnie tworzę dodatkowy plik z migracją odpowiedzialną za deployment inteligentnego kontraktu. W folderze migrations tworzę plik o nazwie 2_initial_CHARToken.js, nazywam go zgodnie z konwencją nazewnictwa. (Służy ona do sortowania kolejnych migracji). A tutaj implementacja do skopiowania w nowym pliku migracji

const CHARToken = artifacts.require("CHARToken");

module.exports = function(deployer) {
  deployer.deploy(CHARToken);
};

Deployment

Czas na zdeploy-owanie napisanego inteligentnego kontraktu na lokalną sieć blockchain. W tym celu w głównym folderze truffle uruchamiamy komendę truffle migrate --network genache. Poniżej wynik wykonania:

hint: Oczywiście ten kontrakt będzie widoczny tylko na mojej prywatnej lokalnej sieci Ethereum.

Próbowałem streścić jak najbardziej to co było potrzebne do pokazania działania i sposobu implementacji inteligentnego kontraktu przez co mogłem pominąć coś co może być nie oczywiste. Gdyby tak się zdażyło to daj mi proszę znać, a postaram się rozwinąć temat, który pominąłem.


Do następnego!
Łukasz

Dołącz do newslettera i otrzymuj informacje o nowych wpisach jako pierwszy

Podane dane będą przetwarzane w celu informowania o nowych wpisach jak i w celach marketingowych. Możesz wypisać się w dowolnym momencie jeżeli uznasz, że nie chcesz dłużej dostawać ode mnie wiadomości.

Dodaj komentarz

Twój adres email nie zostanie opublikowany. Pola, których wypełnienie jest wymagane, są oznaczone symbolem *