Własny token ERC20

Witam,

W ostatnim czasie zainteresowałem się tym, jak stworzyć własny token personalny. Na stronach internetowych jest wiele tutoriali, lecz nie wszystkie działają, czasami wyskakują błędy składniowe w skopiowanym kodzie.

Doszedłem do wniosku że stworzę mały tutorial jak to zrobić. Do tego celu posłużę się narzędziami:

- Metamask https://metamask.io/

- EtherScan https://etherscan.io/

- remix ethereum (SDK) http://remix.ethereum.org/

Zabawę zaczynamy od zainstalowania wtyczki Metamask w przeglądarce(w przeglądarce Brave jest już pre-instalowana tylko trzeba ją włączyć). Samego zakładania konta oraz transferowania środków nie będę tłumaczył :) mam nadzieje że ten kto, robi swój własny token potrafi to zrobić :).

Na adresie w metamasku musi być jakaś minimalna kwota eth, aby kod który zostanie skompilowany przez remix, mógł zostać wysłany oraz przetworzony przez sieć Ethereum.

Całość tutorialu będzie przeprowadzona na sieci testowej Ethereum, Ropsten. Aby sie przełączyć na siec testową należy w metamasku kliknąć w lewym górnym rogu aplikacji na "Main Network" i przełączyć na TestNet.

Aby wszystkie testy były możliwe, należy kupić eth w sieci Testowej Ropsten. W tym celu trzeba kliknąć na przycisk BUY a następnie ROPSTEN TEST FAUCET.

Zostaniemy przeniesieni na stronę https://faucet.metamask.io/ gdzie po kliknięciu na request dostaniemy darmowy ether w sieci ropsten.

W tym momencie można przejść na stronę http://remix.ethereum.org/ 

W oknie gdzie znajduje się kod, usuwamy wszystko co się tam jest zawarte, a następnie wklejamy to:

----------------------------------------------------------------------------------------------------------

contract Token {

    function totalSupply() constant returns (uint256 supply) {}

    function balanceOf(address _owner) constant returns (uint256 balance) {}

    function transfer(address _to, uint256 _value) returns (bool success) {}

    function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {}

    function approve(address _spender, uint256 _value) returns (bool success) {}

    function allowance(address _owner, address _spender) constant returns (uint256 remaining) {}

    event Transfer(address indexed _from, address indexed _to, uint256 _value);

    event Approval(address indexed _owner, address indexed _spender, uint256 _value);

}

contract StandardToken is Token {

    function transfer(address _to, uint256 _value) returns (bool success) {

        if (balances[msg.sender] >= _value && _value > 0) {

            balances[msg.sender] -= _value;

            balances[_to] += _value;

            Transfer(msg.sender, _to, _value);

            return true;

        } else { return false; }

    }

    function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {

        if (balances[_from] >= _value && allowed[_from][msg.sender] >= _value && _value > 0) {

            balances[_to] += _value;

            balances[_from] -= _value;

            allowed[_from][msg.sender] -= _value;

            Transfer(_from, _to, _value);

            return true;

        } else { return false; }

    }

    function balanceOf(address _owner) constant returns (uint256 balance) {

        return balances[_owner];

    }

    function approve(address _spender, uint256 _value) returns (bool success) {

        allowed[msg.sender][_spender] = _value;

        Approval(msg.sender, _spender, _value);

        return true;

    }

    function allowance(address _owner, address _spender) constant returns (uint256 remaining) {

      return allowed[_owner][_spender];

    }

    mapping (address => uint256) balances;

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

    uint256 public totalSupply;

}

contract HumanStandardToken is StandardToken {

    function () {

        throw;

    }

    string public name;                   

    uint8 public decimals;               

    string public symbol;               

    string public version = 'H0.1';      

    function HumanStandardToken(

        uint256 _initialAmount,

        string _tokenName,

        uint8 _decimalUnits,

        string _tokenSymbol

        ) {

        balances[msg.sender] = _initialAmount;               

        totalSupply = _initialAmount;                       

        name = _tokenName;                                   

        decimals = _decimalUnits;                            

        symbol = _tokenSymbol;                               

    }

    function approveAndCall(address _spender, uint256 _value, bytes _extraData) returns (bool success) {

        allowed[msg.sender][_spender] = _value;

        Approval(msg.sender, _spender, _value);

        if(!_spender.call(bytes4(bytes32(sha3("receiveApproval(address,uint256,address,bytes)"))), msg.sender, _value, this, _extraData)) { throw; }

        return true;

    }

}

----------------------------------------------------------------------------------------------------------

Jest to kod który pozwala wygenerować token personalny.

Następnym krokiem jest ustawienie kompilatora. W tym celu przechodzimy w zakładkę settings oraz wybieramy najnowszy kompilator.

Po wyborze kompilatora przechodzimy do zakładki "RUN".

Jeżeli metamask został  prawidłowo zainstalowany, to zakładka run powinna wyglądać w ten sposób:

W polu deploy należy wpisać parametry naszego kontraktu.

uint256 _initialAmount, string _tokenName, uint8 _decimalUnits, string _tokenSymbol

- uint256 _initialAmount --->  Ilość tokenów

- string _tokenName ---> Nazwa tokenu

- uint8 _decimalUnits ---> ilość miejsc po przecinku

- string _tokenSymbol ---> Symbol tokenu

Powinno to wyglądać tak: 

21000000, "token testowy", 0, "Test" 

W przypadku większej liczby miejsc po przecinku należy dopisać tyle zer do initialAmount, ile jest miejsc po przecinku.

np.

210000000000, "token testowy", 4, "Test" 

Po wpisaniu wartości do pola deploy można już wysłać kontrakt do sieci Ethereum. Aby tego dokonać klikamy Daploy. W tym momencie SDK poprosi nas o zaakceptowanie kontraktu oraz Metamask poprosi o zatwierdzenie transakcji.

SDK wysłało kontrakt i czeka na potwierdzenie z sieci.

Po zatwierdzeniu kontraktu przez Ethereum nasz token już istnieje i można z niego korzystać :)

Aby sprawdzić czy faktycznie tak jest należy dodać token do Metamaska. W tym celu kopiujemy adres kontraktu i wklejamy do metamaska.

Dobrą praktyką jest sprawdzenie poprawności oraz publikacja kodu na stronie etherscan.io.

Aby to zrobić wchodzimy na stronę etherscan.io, następnie wklejamy adres naszego kontraktu w wyszukiwarce.

 

Następnie klikamy na zakładkę Code, a następnie  Verify And Publish.

W tym miejscu wpisujemy adres kontraktu, nazwa kontraktu w naszym przypadku jest to "HumanStandardToken", wybieramy kompilator który wykorzystaliśmy, zaznaczymy bez optymalizacji oraz wklejamy cały użyty kod.

Po wypełnieniu wszystkich potrzebnych pól można zatwierdzić " nie jestem robotem" :) i kliknąc weryfikuj.

Jeżeli wszystko poszło prawidłowo to etherscan wyświetli coś takiego: 

Myślę że chociaż trochę pomogłem, oraz rozjaśniłem proces tworzenia własnego Tokenu. Oczywiści jest kilka innych sposobów chociażby przez portfel ethereum.org, jednakże ten wydaje mi się najprostszy.

Jeżeli uda Ci się stworzyć własny token, to zachęcam do podzielenia się nim :) w ramach podziękowania.

To mój adres ethereum:    0x92128aCf3b291c588C7a6727D6d69e922E4Fe70b 

Pozdrawiam,

RS.