Comment créer un token Ethereum (ERC-20)

Comment créer un token Ethereum (ERC-20) crypto-monnaie blockchain

Créer son propre token ERC-20 sur le réseau Ethereum.

La blockchain Ethereum permet la création d'applications et de tokens ERC-20 par le biais des smart-contracts (contrats intelligents), il existe aujourd'hui sur le Mainnet Ethereum plus de 99.588 tokens dont la grande majorité ne sont pas utilisés. Si il existe un si grand nombre de tokens c'est avant parce que les cryptomonnaies et les tokens fascinent les curieux, les entreprises, les développeurs et le grand public. Il y a donc eue un grand nombre de tests, de tentatives et d'études sur la création de token qui ont été réalisées et seulement une partie infime à aboutie sur de véritables pièces numériques qui circulent et sont échangés sur des plateformes de crypto-monnaies.

Nous allons vous montrer comment créer votre propre token ERC-20 en quelques minutes et le déployer sur la blockchain Ethereum. Que vous soyez simplement curieux ou désireux de lancer une ICO ou même votre propre monnaie numérique la création d'un token ERC-20 est le point de départ. A noter que le déploiement d'un contrat (création d'un token ERC-20) sur Ethereum n'est pas le seul moyen de créer une crypto-monnaie : Vous pouvez aussi utiliser la plateforme NEO, ou bien réaliser un fork d'une crypto-monnaie open-source ou même développer votre propre blockchain.

Avant de commencer veuillez noter que la création d'un token ERC-20 n'est pas forcément très simple, de bonnes connaissances en web et en informatique sont nécessaires et quelques notions de code vous permettront de comprendre ce que vous faites, mais ce n'est pas obligatoire.

Les outils nécessaires pour la création du Token

Un wallet ERC-20

Pour commencer il va vous falloir un portefeuille crypto compatible ERC-20, lors de la création du token, il faudra fournir une adresse qui recevra tout ou partie des tokens générés. Etant donné que ces tokens utiliseront Ethereum et la technologie ERC-20 il vous faut obligatoirement un wallet compatible ERC-20.

Nous vous conseillions d'installer MetaMask qui est un plugin intégré à Chrome. Il intègre toutes les fonctionnalités nécessaire à la création de pièce ERC-20 et vous permettra en plus d'être avertit si vous visiter un site peu fiable qui pourrait pratiquer le phising pour voler vos crypto-monnaies.

Le générateur de contrat / token Ethereum

Le deuxième outils à utiliser est remix.ethereum.org qui vous permet d'éditer vos contrats (token) et de les publier sur le réseau Ethereum. Les contrats ETH ERC 20 se présentent sous la forme de code. C'est ce code source qui va définir le nom de votre token, son symbol ainsi que le nombre de tokens que vous souhaitez mettre en circulation.

Pas d'inquiétude ! Nous vous fournissons plus bas le code source prêt à l'emploi, il vous suffira de modifier quelques lignes pour pouvoir créer vous même votre token sur le réseau Ethereum :)

Utiliser le réseau test d'Ethereum pour ne pas payer des GAS

La blockchain Ethereum utilise les GAS pour fonctionner, ainsi si vous souhaitez publier votre token en déployant un contrat, il vous sera demandé un certains nombre de GAS. Le coût de publication d'un nouveau token est de 10€ environ à l'heure actuelle. Aussi pour ne pas avoir à débourser de la monnaie réelle pour nos tests nous allons utiliser un réseau secondaire qui fonctionne exactement comme le réseau Mainnet mais avec la possibilité de recevoir des GAS gratuitement via un faucet.

Cela vous permettra de vérifier gratuiement que la procédure de création de votre token fonctionne bien avant de reproduire cette démarche sur le réseau principal.

Se positionner sur le réseau Ropsten test

Metamask fonctionne de manière synchronisé avec l'outil remix sur le site ethereum.com, par défaut Metamask fonctionne comme un portefeuille classique et est donc relié directement au réseau principal Ethereum (le Mainnet), pour faire vos tests vous allez vous brancher sur le réseau Ropsten.

Vous pouvez également choisir les réseaux Kovan ou Rinkedy qui sont également des réseaux secondaires de test pour Ethereum.



Récupérer des "Ethers" pour pouvoir payer la création de votre token

Rendez vous sur https://faucet.metamask.io pour récupérer des "Ethers" qui ne fonctionneront que sur le réseau Ropsten, ces Ethers et donc ces GAS vous permettront de régler le prix de la création du token sur le réseau Ropsten. Ne sautez pas de joie trop vite, ce sont de faux Ethers qui ne fonctionneront que sur ce réseau et pas sur le Mainnet Ethereum :) 


Attendez quelques secondes ou minutes en fonction de la charge du réseau et vérifiez que vous avez dorénavant quelques ETH sur votre wallet :

Le code source de votre token Ethereum

Nous allons maintenant passser à l'étape de développement qui n'en est pas réellement une car nous vous fournissons le code source pour la création de votre token, il s'agit d'éditer le code source avec les détails de votre tokens, de se rendre sur le remix.ethereum.org, et de soumettre le contrat nouvellement crée.


pragma solidity ^0.4.4;

contract Token {

    /// @return total amount of tokens
    function totalSupply() constant returns (uint256 supply) {}

    /// @param _owner The address from which the balance will be retrieved
    /// @return The balance
    function balanceOf(address _owner) constant returns (uint256 balance) {}

    /// @notice send `_value` token to `_to` from `msg.sender`
    /// @param _to The address of the recipient
    /// @param _value The amount of token to be transferred
    /// @return Whether the transfer was successful or not
    function transfer(address _to, uint256 _value) returns (bool success) {}

    /// @notice send `_value` token to `_to` from `_from` on the condition it is approved by `_from`
    /// @param _from The address of the sender
    /// @param _to The address of the recipient
    /// @param _value The amount of token to be transferred
    /// @return Whether the transfer was successful or not
    function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {}

    /// @notice `msg.sender` approves `_addr` to spend `_value` tokens
    /// @param _spender The address of the account able to transfer the tokens
    /// @param _value The amount of wei to be approved for transfer
    /// @return Whether the approval was successful or not
    function approve(address _spender, uint256 _value) returns (bool success) {}

    /// @param _owner The address of the account owning tokens
    /// @param _spender The address of the account able to transfer the tokens
    /// @return Amount of remaining tokens allowed to spent
    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) {
        //Default assumes totalSupply can't be over max (2^256 - 1).
        //If your token leaves out totalSupply and can issue more tokens as time goes on, you need to check if it doesn't wrap.
        //Replace the if with this one instead.
        //if (balances[msg.sender] >= _value && balances[_to] + _value > balances[_to]) {
        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) {
        //same as above. Replace this line with the following if you want to protect against wrapping uints.
        //if (balances[_from] >= _value && allowed[_from][msg.sender] >= _value && balances[_to] + _value > balances[_to]) {
        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;
}


//name this contract whatever you'd like
contract ERC20Token is StandardToken {

    function () {
        //if ether is sent to this address, send it back.
        throw;
    }

    /* Public variables of the token */

    /*
    NOTE:
    The following variables are OPTIONAL vanities. One does not have to include them.
    They allow one to customise the token contract & in no way influences the core functionality.
    Some wallets/interfaces might not even bother to look at this information.
    */
    string public name;                   //fancy name: eg Simon Bucks
    uint8 public decimals;                //How many decimals to show. ie. There could 1000 base units with 3 decimals. Meaning 0.980 SBX = 980 base units. It's like comparing 1 wei to 1 ether.
    string public symbol;                 //An identifier: eg SBX
    string public version = 'H1.0';       //human 0.1 standard. Just an arbitrary versioning scheme.

//
// CHANGE THESE VALUES FOR YOUR TOKEN
//

//make sure this function name matches the contract name above. So if you're token is called TutorialToken, make sure the //contract name above is also TutorialToken instead of ERC20Token

    function ERC20Token(
        ) {
        balances[msg.sender] = 5000000;               // Give the creator all initial tokens (100000 for example)
        totalSupply = 5000000;                        // Update total supply (100000 for example)
        name = "Nom du token";                                   // Set the name for display purposes
        decimals = 0;                            // Amount of decimals for display purposes
        symbol = "Symbol du token";                               // Set the symbol for display purposes
    }

    /* Approves and then calls the receiving contract */
    function approveAndCall(address _spender, uint256 _value, bytes _extraData) returns (bool success) {
        allowed[msg.sender][_spender] = _value;
        Approval(msg.sender, _spender, _value);

        //call the receiveApproval function on the contract you want to be notified. This crafts the function signature manually so one doesn't have to include a contract in here just for this.
        //receiveApproval(address _from, uint256 _value, address _tokenContract, bytes _extraData)
        //it is assumed that when does this that the call *should* succeed, otherwise one would use vanilla approve instead.
        if(!_spender.call(bytes4(bytes32(sha3("receiveApproval(address,uint256,address,bytes)"))), msg.sender, _value, this, _extraData)) { throw; }
        return true;
    }
}

Ce code source provient de : https://github.com/ConsenSys/Token-Factory

Editez les infos de votre tokens

Dans le code source ci-dessus, il y a la fonction ERC20Token qui définie le nom, le symbole ainsi que le nombre de pièces disponible pour ce token. C'est à vous d'éditer ces informations.

    function ERC20Token(
        ) {
        balances[msg.sender] = 5000000;               // Give the creator all initial tokens (100000 for example)
        totalSupply = 5000000;                        // Update total supply (100000 for example)
        name = "Nom du token";                                   // Set the name for display purposes
        decimals = 0;                            // Amount of decimals for display purposes
        symbol = "Symbole du token";                               // Set the symbol for display purposes
    }


  • balances[msg.sender] = Défini le nombre de tokens que le créateur (votre wallet) va recevoir lors de la création.
  • totalSupply = Défini le nombre de tokens crées
  • name = Définira le nom du token
  • decimals = Définira la divisibilité de votre token
  • symbol = Défini le symbol de trading de votre token ERC-20

Ne mettez pas de double quotes (") pour les nombres ou les chiffres (balances, totalsupply, decimals) et utilisez des double quotes pour les phrases (name et symbol).

Déploiement du contrat

Une fois que vous avez décidé des différentes infos pour votre token et que vous avez modifié le code source vous allez ensuite déployer le contrat sur le réseau (Ropsten pour notre cas ou Mainnet si vous créez un token réel).

Rendez-vous donc sur l'outil de déploiement des tokens ERC-20 : http://remix.ethereum.org et collez-y votre code source puis compiler votre code. Les warnings ne sont pas importants contrairement aux erreurs, vous aurez probablement une dizaine de warning sur votre code source, ce n'est pas un soucis :

Ensuite allez dans l'onglet run pour véritablement déployer votre token. Vérifiez que vous êtes bien sur le bon environnement de publication (Injected Web 3 : Ropsten pour le test ou Mainnet pour un token réel ERC-20), vérifiez également que l'outil à bien détecté qu'il s'agit d'un token ERC-20. 

Une fois ces vérification faites vous pouvez cliquer sur le bouton"Deploy", à ce moment une pop-up de paiement MetaMask va s'ouvrir : il s'agit de régler les frais pour le déploiement de votre token sur la blockchain Ethereum. Vérifiez que vous êtes bien sur le bon serveur et cliquez le bouton Submit pour vous acquitter des frais.

Une fois le paiement effectué vous avez sur MetaMask dans l'onglet sent, la transactions qui s'affiche, vous pouvez cliquer dessus pour suivre cette transaction sur le site Etherescan.

 

Félicitation vous venez de créer votre token ERC-20 sur le réseau Ethereum :)

Afficher les tokens dans votre wallet Metamask

La dernière étape consiste à afficher les tokens crées dans votre wallet pour être certain de bien posséder les tokens. Pour cela accédez comme précédemment sur la page Etherscan qui résume le déploiement du contrat (dans l'onglet Sent de Metamask) et récupérer l'identifiant du contrat :



Sur MetaMask, allez dans l'onglet token et cliquez sur le bouton "Add token", collez l'adresse du contrat, normalement si l'adresse est bonne Metamask va remplir automatiquement "Token symbol" et "Decimal", cliquez sur "Add" et le tour est joué.


Vous êtes dorénavant le seul propriétaire de jetons qui ne valent rien à l'heure actuelle mais qui vont vous permettre de faire plein de chose dans le futur, c'est à vous de décider de la suite :)


Les commentaires à propos de cet article