Tutoriel : Comment créer sa cryptomonnaie en 5 minutes

Ecrit par Sébastien Leguell Dernière mise à jour : Le 24 février 2023 à 14:53

Vous avez toujours rêvé de détenir une crypto-monnaie avec plusieurs millions voir milliards de jetons ? Mais tout le monde vous dit que la crypto, c’est trop compliqué et qu’il faut être développeur pour créer sa propre cryptomonnaie ou ses tokens ? Et si je vous disais que finalement, c’était quelque chose de simple et qu’il faut moins de 5 minutes ?

Dans ce tutoriel complet, vous allez apprendre à créer votre propre jeton de A à Z sur une blockchain EVM compatible en moins de 5 minutes. Il vous suffira de copier/coller le code source du smart contract de ce guide et de l’adapter à votre propre situation.

Préambule

Ce tutoriel va vous permettre de créer votre propre jeton dans un but pédagogique sur des blockchains dites EVM Compatibles. Pour cela, nous allons écrire un smart contract avec le langage de programmation Solidity. Les différentes étapes du guide sont vulgarisées mais cela s’adresse à des personnes avec des notions de programmation.

De plus, quelques prérequis sont aussi nécessaires comme :

• Avoir installé le portefeuille crypto MetaMask sur son ordinateur ;
• Posséder la cryptomonnaie de l’écosystème en cas de déploiement en réel.

En fonction de votre niveau de compétences, ce tutoriel peut prendre moins de 5 minutes ou bien une heure.

Un point sur les blockchains EVM compatibles

Les blockchains dites « EVM Compatibles » sont des blockchains qui utilisent la technologie EVM (Ethereum Virtual Machine), la machine virtuelle d’Ethereum. Cela permet de rendre les procédés de développement compatibles en utilisant le même langage de programmation qui est Solidity pour le développement des smart contracts.

On peut retrouver dans cette liste des blockchains comme :

• BNB Chain (BNB) ;
• Polygon (MATIC) ;
• Avalanche C-Chain (AVAX) ;
• Fantom (FTM).

Avec cette compatibilité, vous pouvez déployer des projets sur différentes blockchains rapidement et sans devoir modifier l’intégralité du code source.

Dans ce tutoriel, nous allons créer une cryptomonnaie sur la blockchain Polygon. Mais vous pouvez faire la même chose sur les autres blockchains EVM Compatibles sans aucun souci.

Ecrire le smart contract Solidity pour définir les règles de votre cryptomonnaie

Avant de créer sa crypto-monnaie sur Polygon, il faut écrire le contrat intelligent du jeton. C’est lui qui va définir toutes les règles et ses spécificités.

Les bases du contrat intelligent

Comme vous vous en doutez, c’est le smart contrat qui va permettre de créer votre propre crypto-monnaie. Celui-ci contient différentes instructions que nous allons écrire ensemble et cela commence généralement par la licence :

// SPDX-License-Identifier: GPL-3.0

Les licences servent à protéger votre code source si jamais celui-ci est public, il faut donc bien vous renseigner au préalable. Comme nous aimons les choses simples et le partage, nous utiliserons une licence de type GPL-3.0. Si vous avez un doute, les différents identifiants des licences sont disponibles sur le site officiel de SPDX.

Le Semantic Versioning (ou gestionnaire de version sémantique)

Ensuite, il faut définir la ou les versions compatibles de Solidity avec notre code. C’est ce que l’on appelle la directive pragma et elle se déclare comme ceci :

pragma solidity ^0.8.16;

Avec cette ligne, on indique que notre code est compatible avec toutes les versions de Solidity égale ou supérieur à la version 0.8.16 mais inférieur à la version 0.8.17. Le versionnement sémantique (Semantic Versioning) permet d’éviter de casser son code en cas de changement de version. Des outils comme npm semver pourront vous permettre de mieux appréhender ce concept.

Le contrat

Finalement, nous arrivons à la partie contrat qui stipule simplement son nom et est vide pour le moment. C’est à l’intérieur que les instructions vont se trouver pour créer et définir les règles de votre token.

Nous en profitons également pour ajouter la licence et la version de solidity.

// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.16;

contract Token {

}

Notez que vous pouvez remplacer le nom du contrat « Token » par ce que vous voulez. Maintenant, nous allons définir toutes les règles relatives à ce smart contract.

Les variables

Pour commencer, nous allons ajouter deux mapping. Ce sont des tables de hachage qui se composent de types de clés et de paires de types de valeurs correspondantes. On pourrait apparenter ça à des sortes de tableaux avec un principe de clé/valeur qui prennent le nom de mapping.

Le premier tableau contient le solde de toutes les adresses qui possèdent des jetons. Cela permet énormément de choses comme :

• Mettre à jour la quantité de token détenu par une adresse
• Observer le solde d’une adresse
• Transférer des tokens d’une adresse à une autre
• Avoir accès au classement des holders

Le second lui va contenir les adresses des délégataires lors d’une approbation et qui pourront transférer le jeton. C’est généralement le cas des DEX (plateformes d’échanges décentralisées) qui nécessitent une approbation ou approvals avant de faire un échange (swap) de cryptomonnaie.

mapping(address => uint) public balances;
mapping(address => mapping(address => uint)) public allowed;

Ceci étant fait, nous allons pouvoir passer à quelques propriétés qui vont vous intéresser. En effet, c’est grâce à ces variables que vous allez pouvoir personnaliser votre crypto-monnaie lors de sa création. Sans plus attendre, voici les différentes variables :

uint public totalSupply_ = 100000 * 10 ** 18;
string public name = "Au Coin du Bloc";
string public symbol = "ACB";
uint public decimals = 18;

La variable totalSupply_ concerne la quantité de jetons total qui seront créés. Dans notre exemple, nous allons créer 100 000 jetons ACB (Au Coin du Bloc). Le 10 ** 18 correspond aux 18 décimales (la valeur la plus petite disponible du jeton).

Vous pouvez donc vous faire plaisir lors de la création de votre cryptomonnaie comme :

• changer le nom
• changer le symbole
• modifier la quantité de jeton qui seront généré

Soyez créatif et n’hésitez pas à utiliser un nom original pour marquer les esprits.

Les évènements

Les évènements sont des fonctions qui sont utilisées pour émettre et écouter ce qu’il se passe. Ils peuvent être nombreux et variée lors :

• Des transferts
• Des approbations de contrats
• De la réception de cryptomonnaie

La seule limite est l’imagination du développeur qui va produire le contrat intelligent. Dans le cadre de notre contrat, nous allons créer 2 évènements :

// Événements
event Transfer(address indexed from, address indexed to, uint amount);
event Approval(address indexed owner, address indexed spender, uint amount);

Le premier évènement consistera à émettre et écouter les informations relatives aux transferts. Le second lui fera de même pour tout ce qui est approbation. Dans le cas d’un futur tutoriel, nous nous servirons de ces évènements. L’idée était surtout de vous montrer à quoi ressemblait ces évènements quand ils seront utilisés plus tard dans le code.

Nous en avons terminé pour les évènements et allons passer au cœur de la logique : les fonctions.

Les fonctions, le cœur de la logique des contrats

Sans plus tarder, nous attaquons ces fonctions avec celle que l’on nomme, le constructeur.

// Constructeur avec initialisation de la balance du contrat
constructor() {
    balances[msg.sender] = totalSupply_;
}

Rien d’extraordinaire car il ne contient aucun argument. Il va uniquement servir à définir la quantité maximum de jetons grâce à la variable précédente. Au moment du déploiement sur la blockchain, l’intégralité des jetons seront reversés à l’adresse qui aura créé le contrat (vous).

Notez que c’est le seul moment où il sera possible de spécifier la quantité et ne sera appelé qu’une seule fois.

Obtenir des informations avec les Getters

Maintenant, nous allons voir 3 autres fonctions du contrat permettant d’obtenir des informations. C’est ce que l’on appelle dans le jargon : des Getters. Ces fonctions vont nous permettre de récupérer dans l’ordre :

• la quantité totale de jetons disponibles
• la balance d’un utilisateur
• la valeur accessible au délégataire

// Récupérer la quantité totale de jetons disponibles
function totalSupply() public view returns (uint256) {
    return totalSupply_;
}

// Récupérer la balance d'un utilisateur
function balanceOf(address owner) public view returns(uint) {
    return balances[owner];
}

// Récupérer la valeur accessible au délégataire
function allowance(address owner, address delegate) public view returns(uint) {
    return allowed[owner][delegate];
}

Elles sont toutes les trois publiques (public), elles renvoient une vue (view) et retournent un type de donnée (uint256 ou uint qui sont des entiers). Elles pourront être utilisées sur Etherscan par exemple par n’importe quel utilisateurs ou d’autres contrats.

La logique et mise à jours

Enfin, nous allons voir les fonctions permettant d’envoyer ou recevoir de la cryptomonnaie ainsi que le principe d’envoi par délégation.

La première fonction que nous allons aborder est celle des transferts en tant que propriétaire. La logique ici se résume en 5 points :

1. Vérification du solde du propriétaire
2. Mise à jour du solde du propriétaire
3. Mise à jour du solde du destinataire
4. Emission de l’évènement de transfert
5. Retour d’un booléen positif en guise de succès

// Transférer les jetons en tant que détenteur
function transfer(address to, uint amount) public returns(bool) {
    require(balanceOf(msg.sender) >= amount, 'balance too low');
    balances[msg.sender] -= amount;
    balances[to] += amount;
    emit Transfer(msg.sender, to, amount);
    return true;
}

La seconde fonction est celle d’approbation et qui permet de donner une délégation. C’est notamment ce qui est utilisé par les DEX lors des swap ou par certains Yield Optimizer. Cette autorisation ou approvals nécessite également une quantité maximum d’actifs qu’il pourra être possible d’envoyer. Une fois la quantité dépassée, la transaction sera en échec.

Cette fonction approve se résume en 3 étapes :

1. Autoriser le délégataire à déplacer les fonds de l’utilisateur via les tables de hachage (mapping)
2. Emission de l’événement de d’approbation
3. Retour d’un booléen positif en guise de succès

// Approbation pour permettre à un tiers de transmettre des jetons
function approve(address spender, uint amount) public returns (bool) {
    allowed[msg.sender][spender] = amount;
    emit Approval(msg.sender, spender, amount);
    return true;
}

Enfin la dernière fonction « transferFrom » permet délégataire d’envoyer des jetons à votre place. Elle est pratiquement identique à la fonction « transfert » à deux points prêts :

• Vérification que le délégataire n’a pas dépassé sa limite de transfert
• On déduit la quantité de jetons envoyés de la balance du délégataire

// Transférer les jetons en tant que tiers (approbation préalable)
function transferFrom(address from, address to, uint amount) public returns(bool) {
    require(balanceOf(from) >= amount, 'balance too low');
    require(allowed[from][msg.sender] >= amount, 'allowance too low');

    balances[from] -= amount;
    allowed[from][msg.sender] -= amount;

    balances[to] += amount;
    emit Transfer(from, to, amount);
    return true;
}

Et voilà, nous en avons terminé avec le contrat.

Le contrat intelligent prêt à être déployé sur la blockchain

Pour vous faire gagner un peu de temps, voici le code source complet du contrat intelligent (également disponible sur GitHub) :

// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.16;

contract Token {
    mapping(address => uint) public balances;
    mapping(address => mapping(address => uint)) public allowed;
    uint public totalSupply_ = 100000 * 10 ** 18;
    string public name = "Au Coin du Bloc";
    string public symbol = "ACB";
    uint public decimals = 18;

    // Événements
    event Transfer(address indexed from, address indexed to, uint amount);
    event Approval(address indexed owner, address indexed spender, uint amount);

    // Constructeur avec initialisation de la balance du contrat
    constructor() {
        balances[msg.sender] = totalSupply_;
    }

    // Récupérer la quantité totale de jetons disponibles
    function totalSupply() public view returns (uint256) {
        return totalSupply_;
    }

    // Récupérer la balance d'un utilisateur
    function balanceOf(address owner) public view returns(uint) {
        return balances[owner];
    }

    // Récupérer la valeur accessible au délégataire
    function allowance(address owner, address delegate) public view returns(uint) {
        return allowed[owner][delegate];
    }

    // Transférer les jetons en tant que détenteur
    function transfer(address to, uint amount) public returns(bool) {
        require(balanceOf(msg.sender) >= amount, 'balance too low');
        balances[msg.sender] -= amount;
        balances[to] += amount;
        emit Transfer(msg.sender, to, amount);
        return true;
    }

    // Transférer les jetons en tant que tiers (approbation préalable)
    function transferFrom(address from, address to, uint amount) public returns(bool) {
        require(balanceOf(from) >= amount, 'balance too low');
        require(allowed[from][msg.sender] >= amount, 'allowance too low');

        balances[from] -= amount;
        allowed[from][msg.sender] -= amount;

        balances[to] += amount;
        emit Transfer(from, to, amount);
        return true;
    }

    // Approbation pour permettre à un tiers de transmettre des jetons
    function approve(address spender, uint amount) public returns (bool) {
        allowed[msg.sender][spender] = amount;
        emit Approval(msg.sender, spender, amount);
        return true;
    }
}

Il vous suffira simplement de copier/coller ce code source dans le contrat intelligent. Dans plus attendre, nous allons déployer ce contrat sur la blockchain Polygon.

Déployer son contrat intelligent avec Remix IDE

La seconde grande étape consiste à déployer son contrat sur la blockchain. Une étape pas des moindre mais relativement facile à mettre en place.

Création de l’espace de travail et du contrat intelligent Solidity

Pour débuter le déploiement du contrat intelligent, rendez-vous sur l’éditeur Remix IDE. Une fois sur la page, vous allez devoir créer un nouvel espace de travail en cliquant sur l’icône plus (en dessous de File Explorer).

Une fois la nouvelle fenêtre ouverte, vous devrez simplement :

1. Donner un nom à votre espace de travail
2. Sélectionner un thème par défaut (template) blanc

Votre espace de travail Remix IDE est maintenant opérationnel. Maintenant, il faut importer votre contrat pour qu’il puisse être compilé par l’éditeur mais pas n’importe où ni n’importe comment. Nous allons faire les choses proprement :

1. Création d’un nouveau dossier nommé « contracts« 
2. Création d’un nouveau fichier nommé « MyToken.sol« 
3. Copier/Coller le code source du contrat que nous avons écrit précédemment

Tout est maintenant prêt pour la prochaine étape : la compilation du contrat intelligent.

Compilation du contrat intelligent

Rassurez-vous, c’est une étape relativement simple du côté de l’utilisateur. Cette étape consiste à compiler le contrat solidity afin d’être lu et interprété par la machine virtuelle d’Ethereum.

A votre niveau, vous devez simplement :

• Cliquer sur l’icône dans le menu de gauche
• Sélectionner la version 0.8.16 du compilateur (comme dans notre contrat)
• Cliquer sur le bouton « Compile« 

En principe, vous ne devriez pas rencontrer d’erreur particulière. Un icône vert devrait apparaître sur l’icône dans le menu de gauche comme preuve de succès de la compilation.

Déployer le contrat sur la blockchain

Passons maintenant au déploiement du contrat sur la blockchain, l’une des étapes les plus importantes. Pour cela, vous avez besoin de votre portefeuille MetaMask avec de la crypto-monnaie pour payer les frais de transaction.

Configuration du compte et de l’environnement

En tant que débutant ou dans le cas d’un test, je vous suggère d’utiliser un testnet comme Ropsten sur Ethereum. Cela vous permet de faire vos tests et déployer vos premiers contrats gratuitement sur la blockchain.

Le déploiement se déroule en 3 étapes :

• Cliquez sur l’icône qui représente un Ether dans le menu de gauche pour accéder à l’interface de déploiement
• Sélectionner l’environnement « Injected Privoder – Metamask« . Lors de la sélection, une demande de connexion va alors avoir lieu pour connecter votre wallet à Remix IDE. C’est votre portefeuille qui va permettre de déployer le contrat, il faut donc le connecter. Pensez aussi à sélectionner le réseau sur lequel vous voulez déployer votre contrat (Ethereum, BNB Chain, Polygon…).
• Vérifiez les informations et cliquez sur « Deploy« 

Une fois le bouton cliqué, une demande de transaction sera envoyée à votre portefeuille Metamask pour validation de votre part. Si vous le souhaitez, vous pouvez vérifier les informations et modifier les frais de carburant (gas) pour que votre transaction soit plus rapide.

Confirmation de la transaction pour déployer le smart contract

Il ne vous reste plus qu’à confirmer la transaction via le bouton si vous êtes en accord.

Après quelques secondes d’attente, un message de succès devrait s’afficher au bas de Remix IDE.

Vous pouvez appuyer sur l’icône côté droit pour afficher les détails, dont le hash de la transaction pour vérifier le tout sur la blockchain. Selon la blockchain où votre smart contract est déployé, vous pouvez utiliser les différents explorateurs blockchain comme :

• Ethereum : Etherscan
• BNB Chain : BSCScan
• Polygon : PolygonScan
• Avalanche C-Chain : SnowTrace
• Fantom : FTMScan

Vérifier le processus de création du contrat de votre crypto-monnaie on-chain (sur la blockchain)

Comme vous pouvez l’observer dans la capture suivante, notre cryptomonnaie à été créer sur la blockchain Polygon avec le contrat : 0x9985659183b24f2198f77921782163276008c85d.

Bonne nouvelle, vous avez bel et bien créé votre cryptomonnaie sur la blockchain!

Actuellement, c’est vous qui possédez l’intégralité des jetons, ce qui n’est pas très intéressant. Nous allons voir comment envoyer des jetons à d’autres utilisateurs pour qu’ils puissent eux aussi en profiter.

Envoyer sa crypto-monnaie à une adresse

La première méthode consiste à utiliser l’interface Remix IDE en faisant appel aux fonctions. Pour cela :

1. Cliquez sur l’icône à côté de « Token At » pour déployer la liste
2. Cliquez sur l’icône à droite de la fonction « transfer« 

De nouveaux champs seront disponibles, vous permettant de définir :

• L’adresse qui va recevoir les jetons
• La quantité de jetons à envoyer

Rien de bien sorcier si ce n’est que le montant doit comporter 18 décimales. Exemple, si vous voulez envoyer 500 jetons, il faudra taper 500000000000000000000. Mais ne vous inquiétez pas, quand vous allez saisir la valeur, celle-ci sera affichée dans la fenêtre Metamask lors de la confirmation.

Une fois que vous êtes en adéquation avec les informations, cliquez sur le bouton transact et validez la transaction sur Metamask.

Dès que la transaction sera confirmée sur la blockchain, le destinataire va recevoir vos jetons.

Méthode alternative pour envoyer sa propre cryptomonnaie

Voici une autre méthode pour que la manipulation soit plus simple. Elle consiste à envoyer la cryptomonnaie directement depuis Metamask.

Pour cela, il suffit simplement d’ajouter le jeton au portefeuille avec ces différentes étapes :

• Ouvrez l’extension Metamask et cliquez sur Importer des jetons
• Coper/Coller la référence de votre contrat dans le champ « Adresse du contrat du jeton »
• Vérifiez les informations et cliquez sur « Importer des jetons »
• Le jeton est ajouté, cliquez sur « Envoyer » pour démarrer le processus d’envoi

Il vous suffira alors simplement de saisir la quantité à l’unité (pas besoin des 18 décimales ici). L’occasion d’offrir un airdrop de cryptomonnaie à tous vos fans. D’ailleurs, toutes mes félicitations, vous avez réussi à créer votre propre crypto-monnaie et à l’envoyer à d’autres utilisateurs du réseau.

Bonus : Vérifier et publier le code source du contrat

Selon les différentes blockchains, il est possible que certaines d’entre elles vous demandent de vous enregistrer. C’est le cas notamment de Polygon où la création d’un compte sera nécessaire.

Voici les différentes pages selon les blockchains pour vérifier et publier le code source de votre smart contract :

• Ethereum
• BNB Smart Chain
• Polygon

Une fois enregistré (si nécessaire), il vous suffit d’entrer les informations relatives à votre smart contract :

• L’adresse de votre contrat
• Le type de compilation (Solidity – Single File)
• La version du compilateur (0.8.16 identique au code)
• La licence (GNU GPLv3 identique au code source)

Dans la nouvelle fenêtre, vous allez devoir copier/coller le code source du contrat dans la champ. Une fois que c’est fait, cliquez sur « Verify and Publish » en bas de page pour démarrer la vérification.

En théorie, si le code source de votre cryptomonnaie est identique au contrat déployé sur la blockchain, la validation devrait être un succès.

Le code source était validé, vous pouvez aller contempler la pastille verte de validation sur l’interface de votre contrat. La blockchain étant transparente, n’importe quel utilisateur peut maintenant avoir accès au code source de votre crypto-monnaie.

Félicitations, en plus d’avoir créer votre cryptomonnaie et de l’envoyer à d’autres personnes, vous avez rendu votre contrat transparent aux yeux des autres utilisateurs. Un gage de confiance car n’importe qui peut consulter le code source pour vérifier son intégrité.

Bonus 2 : Personnaliser son jeton avec une icône et les réseaux sociaux)

Il est possible d’ajouter différentes informations relatives à son nouveau jeton comme :

• Les URL vers les réseaux sociaux ;
• L’adresse du site internet du token ;
• Une icône qui représente l’apparence du jeton.

Voici un exemple concret avec le jeton AAve sur la blockchain Polygon (MATIC).

Pour cela, quelques actions sont nécessaires en fonction des explorateurs blockchains comme :

• La création d’un compte utilisateur ;
• La vérification que vous êtes bien le propriétaire du contrat ;
• Vérifier et publier le code source du contrat.

Une fois ceci réalisé, vous allez pouvoir démarrer le processus de personnalisation par le biais d’un formulaire à compléter. Selon les explorateurs, l’adresse pour y accéder sera potentiellement différente :

• Etherscan
• Polygonscan
• BscScan
• Snowtrace

Dès que toutes les informations auront été vérifiées par les équipes, le profil de votre jeton sera mis à jour et vous pourrez contempler votre icône ou encore l’adresse de vos différents réseaux sur la page de votre contrat.

Conclusion

Ainsi s’achève ce tutoriel vous permettant de générer votre propre cryptomonnaie sur des blockchains EVM compatibles (BNB Chain, Ethereum, Polygon et bien d’autres).

A partir de cette création, les chemins sont infini et vous pouvez faire tout ce que vous voulez de vos jetons comme :

• Créer une pool de liquidité sur des DEX
• Distribuer votre cryptomonnaie sous forme d’airdrop
• Détruire les jetons en les envoyant sur des adresses inaccessibles
• Vendre celle-ci à d’autres utilisateurs sous forme d’ICO (levée de fond)

Ce qu’il est important de retenir, c’est que toute la logique du jeton réside dans son code source. Nous aurions pu par exemple implémenter d’autres fonctionnalités comme :

• Prélever des frais lors des échanges
• Détruire des jetons en cas de transfert
• Ajouter un processus de mint de nouveaux jetons

La seule limite est finalement celle de l’imagination.

Comme vous avez pu le constater, créer sa propre crypto-monnaie est facile et se fait en quelques minutes seulement. N’importe quelle personne peut donc créer des jetons ex nihilo (à partir de rien) comme cela peut être le cas dans de nombreux projets. Pensez-y avant d’investir dans le prochain token à la mode qui doit totalement révolutionner l’écosystème crypto.

Partager l'article sur les réseaux sociaux

Auteur

Sébastien Leguell

Depuis 2017, je ne cesse d'explorer l'univers du Bitcoin, de la blockchain des crypto monnaies, des NFT et plus récemment, celui du Web3. Après avoir fondé Au Coin du Bloc en 2021, je met à disposition mes connaissances et tente de vulgariser les aspects obscurs pour rendre abordable et compréhensible cet univers naissant dans lequel je crois fermement.