Ceci est notre deuxième tutoriel Solidity, si vous l’avez manqué, jetez un œil à notre Introduction à Solidity où nous vous expliquons quelques bases de ce langage de programmation pour la blockchain Ethereum.
Nous vous expliquons un peu comment fonctionne Solidity, comment il est structuré et vous démarrez avec un code simple pour écrire un contrat intelligent «Hello World».
Dans ce tutoriel, nous approfondissons et vous apprenons le code pour déployer votre propre jeton Ethereum ERC-20. (Voici notre Jeton Blockonomi ).
Ethereum & Le boom de l’ICO
ICO signifie Initial Coin Offer et c’est un type de financement utilisant des crypto-monnaies. Dans un ICO, une quantité de crypto-monnaie est vendue sous forme de «tokens» («coins») à des spéculateurs ou des investisseurs, en échange de cours légal ou d’autres crypto-monnaies comme Bitcoin ou Ethereum.
Les jetons vendus sont promus en tant que futures unités fonctionnelles de devise si ou lorsque l’objectif de financement de l’ICO est atteint et que le projet est lancé.
Nous avons déjà expliqué comment les contrats intelligents ont ouvert un tout nouveau monde pour que les développeurs créent et innovent. Cependant, ces développeurs avaient besoin d’un moyen de financer leurs projets.
Et la solution était l’ICO.
En 2017, les ICO étaient en plein essor – d’innombrables projets apparaissaient chaque jour avec des promesses folles de ce qu’ils voulaient réaliser, et les investisseurs les ont lâchés.
Depuis lors, les choses se sont calmées à mesure que l’espace a mûri et que les investisseurs ont disparu, de nombreux ICO n’ont pas réussi à tenir ce qui était promis, mais c’est une histoire pour un autre article – nous sommes ici pour discuter du côté technique.
Qu’est-ce qu’un jeton?
Les jetons sont essentiellement des contrats intelligents qui vivent sur la blockchain Ethereum, ils peuvent avoir des utilisations et des objectifs..
Un jeton n’est pas limité à un rôle particulier. Il peut remplir de nombreux rôles dans son écosystème natif. Voici la liste de certains rôles que les jetons peuvent jouer.
- Péage: Un jeton peut servir de passerelle vers un Dapp. Fondamentalement, pour accéder au Dapp, vous devrez conserver les jetons.
- Droit de vote: Les jetons peuvent également permettre aux détenteurs de disposer de certains droits de vote. Pensez à EOS, détenir des jetons EOS vous permettra de voter pour les producteurs de blocs. EOS Blockchain vise à devenir un système d’exploitation décentralisé capable de prendre en charge des applications décentralisées à l’échelle industrielle.
- Échange de valeur: C’est l’un des rôles les plus courants des jetons au sein de l’écosystème. Les jetons peuvent aider à créer un système économique interne au sein de l’application.
- Amélioration de l’expérience utilisateur: Le jeton peut également permettre aux détenteurs d’enrichir l’expérience utilisateur dans les limites de l’environnement particulier. Par exemple. Dans Brave (un navigateur Web), les détenteurs de BAT (jetons utilisés dans Brave) obtiendront les droits d’enrichir l’expérience client en utilisant leurs jetons pour ajouter des publicités ou d’autres services axés sur l’attention sur la plateforme Brave.
- Devise: Peut être utilisé comme réserve de valeur qui peut être utilisée pour effectuer des transactions à la fois à l’intérieur et à l’extérieur de l’écosystème donné.
Qu’est-ce que l’ERC-20?
ERC-20 est une norme technique utilisée pour les contrats intelligents sur la blockchain Ethereum pour la mise en œuvre de jetons. La majorité des jetons émis sur la blockchain Ethereum sont conformes à la norme ERC-20.
ERC-20 est une norme de protocole qui définit certaines règles et normes pour l’émission de jetons sur le réseau d’Ethereum. Dans «ERC-20», ERC signifie Ethereum Request For Comments et 20 représente un numéro d’identification unique pour distinguer cette norme des autres.
Pour faire simple, ERC-20 est un guide de règles et de réglementations qui aidera à créer un plan pour les contrats intelligents basés sur Ethereum pour créer leurs jetons..
Un jeton sur Ethereum est essentiellement un contrat intelligent qui suit certaines règles communes – à savoir qu’il implémente un ensemble standard de fonctions que tous les autres contrats de jeton partagent, telles que transferFrom (adresse _from, adresse _to, uint256 _tokenId) et balanceOf (adresse _ propriétaire).
Donc, fondamentalement, un jeton est juste un contrat qui garde la trace de qui possède combien de ce jeton, et certaines fonctions afin que ces utilisateurs puissent transférer leurs jetons vers d’autres adresses..
Pourquoi la norme ERC-20 est si importante?
Étant donné que tous les jetons ERC-20 partagent le même ensemble de fonctions avec les mêmes noms, ils peuvent tous être interagis de la même manière.
Cela signifie que si vous créez une application capable d’interagir avec un jeton ERC-20, elle est également capable d’interagir avec n’importe quel jeton ERC-20. De cette façon, plus de jetons peuvent facilement être ajoutés à votre application à l’avenir sans avoir besoin d’un codage personnalisé. Vous pouvez simplement brancher la nouvelle adresse de contrat de jeton, et boom, votre application a un autre jeton qu’elle peut utiliser.
Un exemple de ceci serait un échange. Lorsqu’un échange ajoute un nouveau jeton ERC-20, il lui suffit simplement d’ajouter un autre contrat intelligent auquel il parle. Les utilisateurs peuvent dire à ce contrat d’envoyer des jetons à l’adresse du portefeuille de l’échange, et l’échange peut indiquer au contrat de renvoyer les jetons aux utilisateurs lorsqu’ils demandent un retrait.
L’échange n’a besoin de mettre en œuvre cette logique de transfert qu’une seule fois, puis lorsqu’il souhaite ajouter un nouveau jeton ERC-20, il suffit simplement d’ajouter la nouvelle adresse de contrat à sa base de données.
Commençons à créer un jeton
Nous utiliserons Remix IDE pour développer un contrat intelligent pour notre token ERC-20.
Remix est un outil en ligne qui vous permet d’écrire un contrat intelligent Solidity, puis de le déployer et de l’exécuter.
Allez simplement à https://remix.ethereum.org depuis votre navigateur et nous pouvons commencer à coder.
Cliquez sur le bouton Solidité, puis sur le bouton Plus dans le coin supérieur gauche.
Je l’appellerai «BlockonomiToken», vous pouvez choisir le nom que vous voulez pour votre propre crypto-monnaie.
Bien, tout est configuré maintenant.
Règles des jetons ERC-20
Les jetons ERC-20 suivent une liste de règles afin qu’ils puissent être partagés, échangés contre d’autres jetons ou transférés vers un crypto-portefeuille.
La norme ERC20 comprend 3 règles optionnelles et 6 règles obligatoires.
Pour le dire en termes simples, si vous incluez certaines fonctions dans le contrat intelligent du jeton, vous êtes conforme à la norme ERC20. Si vous n’incluez pas les fonctions obligatoires, vous n’êtes pas ERC20.
Les règles obligatoires sont les suivantes:
- totalSupply
- équilibre des
- transfert
- transfert à partir de
- approuver
- allocation
D’autre part, les règles optionnelles sont:
- Nom du jeton
- symbole
- Décimal (jusqu’à 18)
Il est courant de définir ces règles dans l’interface. Il n’y a pas vraiment quelque chose appelé interface dans Solidity, c’est juste un autre contrat intelligent. Heureusement, on peut hériter des contrats intelligents en langage de programmation Solidity.
L’héritage dans la solidité
Dans Solidity, l’héritage est assez similaire aux langages de programmation objet orientés classiques. Vous allez d’abord rédiger votre contrat de base et dire que votre nouveau contrat héritera du contrat de base.
contrat IBank {
// code du contrat de base…
}
contrat La banque est IBank {
// code de contrat hérité…
}
Vous devez également savoir que Solidity prend en charge l’héritage multiple en copiant du code incluant le polymorphisme.
Tous les appels de fonction sont virtuels, ce qui signifie que la fonction la plus dérivée est appelée, sauf lorsque le nom du contrat est explicitement donné.
Lorsqu’un contrat hérite de plusieurs contrats, un seul contrat est créé sur la blockchain et le code de tous les contrats de base est copié dans le contrat créé.
Revenons à notre jeton ERC-20. Nous avons des règles obligatoires pour créer le token ERC-20.
Nous allons les définir comme 6 fonctions et les écrire dans l’interface. Ensuite, le contrat de notre token héritera de cette interface, appelez donc.
Votre code devra ressembler à ceci.
contrat ERC20Interface {
fonction totalSupply ()
Publique
vue
renvoie (uint);
function balanceOf (adresse tokenOwner)
Publique
vue
retours (solde uint);
allocation de fonction
(adresse tokenOwner, adresse du client)
Publique
vue
renvoie (uint restant);
transfert de fonction (adresse vers, jetons uint) public
renvoie (succès booléen);
function approve (adresse dépensier, jetons uint) public
renvoie (succès booléen);
transfert de fonction
(adresse de, adresse à, jetons uint) public
renvoie (succès booléen);
transfert d’événement (adresse indexée de, adresse indexée sur, jetons uint);
Approbation d’événement (adresse indexée tokenOwner, adresse indexée dépenseur, jetons uint);
}
Contrat de jeton
Créons notre contrat de jeton. Type Contrat {}
Nous allons maintenant passer par 3 règles optionnelles.
Même s’il n’est pas nécessaire de nommer vos jetons, il est tout de même important de leur donner une identité.
Ensuite, nous avons des symboles. Nous ne pouvons tout simplement pas sous-estimer leur importance. Un symbole accrocheur aide à une meilleure image de marque.
Enfin, nous avons la divisibilité qui nous aidera à déterminer la valeur la plus basse possible du jeton. Une divisibilité de 0 signifiera que la valeur la plus basse du jeton est 1. Une divisibilité de 2, par contre, signifie que sa valeur la plus basse sera de 0,01. Le nombre maximum de décimales autorisé est de 18. 18 décimales est la valeur par défaut fortement suggérée, évitez de la changer
Définissons-les et initialisons-les dans le constructeur.
contrat BlockonomiToken est ERC20Interface {
chaîne nom public;
symbole public de chaîne;
uint8 décimales publiques;
constructor () public {
nom = "BlockonomiToken";
symbole = "BKM";
décimales = 18;
}
}
Notre jeton doit également avoir un approvisionnement initial et un enregistrement de tous les soldes. Nous pouvons stocker ces informations dans un tableau.
Dans le constructeur, nous initialiserons notre contrat avec des jetons de fourniture initiaux au créateur du contrat (c’est-à-dire msg.sender). Ajoutez ces lignes à notre code et nous discuterons de leur objectif.
contrat BlockonomiToken est ERC20Interface {
chaîne nom public;
symbole public de chaîne;
uint8 décimales publiques;
uint256 public _totalSupply;
mappage (adresse => uint) soldes;
mappage (adresse => mappage (adresse => uint)) autorisé;
constructor () public {
nom = "BlockonomiToken";
symbole = "BKM";
décimales = 18;
_totalSupply = 100000000000000000000000000;
soldes [msg.sender] = _totalSupply;
émettre le transfert (adresse (0), msg.sender, _totalSupply);
}
}
Types de données de solidité
Comme vous pouvez le voir, _totalSupply a un uint256 type de données et décimales uint8.
Solidity est un langage à typage statique, ce qui signifie que le type de chaque variable (état et local) doit être spécifié au moment de la compilation. Solidity fournit plusieurs types élémentaires qui peuvent être combinés pour former des types complexes.
Parlons maintenant du type Integers.
Les entiers peuvent être int ou uint: Entiers signés et non signés de différentes tailles. Si vous êtes familier avec la théorie de l’informatique ou si vous connaissez la différence entre les entiers signés et non signés en langage C, tout est absolument pareil dans Solidity.
Si ce n’est pas le cas, nous pouvons simplement dire que un non signé est un entier qui ne peut jamais être négatif! Signé d’autre part peut être à la fois négatif et positif, mais nous n’utiliserons que des unités dans notre contrat.
Mots-clés uint8 à uint256 par pas de 8 (non signé de 8 à 256 bits) et int8 à int256. uint et int sont des alias pour uint256 et int256, respectivement.
Nous avons dit que nous stockerions les soldes dans une sorte de tableau. Eh bien, la meilleure solution est d’utiliser des tables de hachage ou des mappages Solidity.
Fondamentalement, nous cartographions adresse (c’est aussi le type de données) pour uint.
msg.sender (adresse): expéditeur du message (appel en cours)
msg.sender sera la personne qui se connecte actuellement au contrat.
Plus tard, vous aurez probablement affaire à des contrats liés à des contrats. Dans ce cas, le contrat qui crée l’appel serait le msg.sender.
Mappages
Les types de mappage sont déclarés comme cartographie (_Type de clé => _Type de valeur). Ici, _KeyType peut être presque n’importe quel type, à l’exception d’un mappage, d’un tableau de taille dynamique, d’un contrat, d’une énumération et d’une structure. _ValueType peut en fait être n’importe quel type, y compris les mappages.
Les mappages peuvent être considérés comme des tables de hachage qui sont virtuellement initialisées de telle sorte que chaque clé possible existe et est mappée à une valeur dont la représentation en octets est entièrement à zéro: la valeur par défaut d’un type. La similitude s’arrête ici, cependant: les données clés ne sont pas réellement stockées dans un mappage, seul son hachage keccak256 utilisé pour rechercher la valeur.
Pour cette raison, les mappages n’ont pas de longueur ou de concept de clé ou de valeur “définie”.
Les mappages ne sont autorisés que pour les variables d’état (ou comme types de référence de stockage dans les fonctions internes).
Il est possible de marquer les mappages comme publics et de laisser Solidity créer un getter. Le _KeyType deviendra un paramètre obligatoire pour le getter et il renverra _ValueType.
Le _ValueType peut également être un mappage. Le getter aura un paramètre pour chaque _KeyType, de manière récursive.
Événements
La blockchain est une liste de blocs qui sont fondamentalement des listes de transactions. Chaque transaction est accompagnée d’un reçu qui contient zéro ou plusieurs entrées de journal. Les entrées de journal représentent le résultat d’événements ayant été déclenchés à partir d’un contrat intelligent.
Dans le code source Solidity, pour définir un événement, vous le marquez ainsi en le précédant du un événement mot-clé (utilisation similaire au mot-clé de fonction). Oui
Vous appelez ou déclenchez alors l’événement dans le corps de la fonction que vous souhaitez provoquer pour générer l’événement. (Je doute qu’il y ait une formulation standard pour cela). Vous pouvez déclencher des événements à partir de n’importe quelle fonction en utilisant émettre mot-clé.
Interface ERC-20
Implémentons l’interface ERC-20 maintenant. Pour ce faire, nous devons écrire du code pour toutes nos six fonctions obligatoires.
1. totalSupply
Identifie le nombre total de jetons ERC-20 créés. Le but de cette méthode est de déterminer le nombre total de jetons flottant autour de l’écosystème.
fonction totalSupply ()
Publique
vue
renvoie (uint)
{
return _totalSupply – soldes [adresse (0)];
}
2. balanceOf
Renvoie le nombre de jetons qu’une adresse particulière, dans ce cas, le propriétaire du contrat, a dans son compte.
function balanceOf (adresse tokenOwner)
Publique
vue
retours (solde uint)
{
renvoyer les soldes [tokenOwner];
}
3. allocation
Afin d’effectuer une transaction, l’une des données les plus importantes que le contrat doit connaître est le solde de l’utilisateur. Après tout, l’utilisateur doit disposer du minimum de jetons requis pour effectuer la transaction.
C’est pourquoi, le contrat ERC-20 inclut également la fonction allocation (). Si l’utilisateur ne dispose pas du nombre minimum de jetons requis, la fonction annule la transaction.
allocation de fonction
(adresse tokenOwner, adresse du client)
Publique
vue
renvoie (uint restant)
{
retour autorisé [tokenOwner] [dépensier];
}
4. approuver
Une fois le solde vérifié, le propriétaire du contrat peut donner son approbation à l’utilisateur pour collecter le nombre requis de jetons à partir de l’adresse du contrat..
La fonction d’approbation vérifie également la transaction par rapport à l’offre totale de jetons pour s’assurer qu’il n’y en a aucun manquant ou supplémentaire..
En d’autres termes, il garantit que la contrefaçon est impossible.
function approve (adresse de dépense, jetons uint) public
Retour
(succès booléen)
{
autorisé [msg.sender] [spender] = jetons;
émettre l’approbation (msg.sender, spender, tokens);
retourne vrai;}
Bibliothèque de mathématiques sécurisée
Afin d’implémenter correctement deux fonctions restantes, nous avons besoin de Safe Math Library.
Enveloppes Safe Math Library sur les opérations arithmétiques de Solidity avec ajout de contrôles de dépassement de capacité.
Opérations arithmétiques dans Solidity wrap en cas de dépassement. Cela peut facilement entraîner des bogues, car les programmeurs supposent généralement qu’un débordement génère une erreur, ce qui est le comportement standard dans les langages de programmation de haut niveau..
Safe Math restaure cette intuition en annulant la transaction lorsqu’une opération déborde.
L’utilisation de cette bibliothèque au lieu des opérations non vérifiées élimine toute une classe de bogues, il est donc recommandé de toujours l’utiliser.
Il ne nous reste plus qu’à copier ce code au-dessus de notre contrat, puis à en hériter.
contrat SafeMath {
function safeAdd (uint a, uint b) retours purs publics (uint c) {
c = a + b;
exiger (c >= a);
}
function safeSub (uint a, uint b) retours purs publics (uint c) {
exiger (b <= a); c = a – b; } function safeMul (uint a, uint b) retours purs publics (uint c) {c = a * b; exigent (a == 0 || c / a == b); } function safeDiv (uint a, uint b) retours purs publics (uint c) {require (b > 0);
c = a / b;
}
}
N’oubliez pas d’en hériter.
contrat BlockonomiToken est ERC20Interface, SafeMath
5. transfert
Ainsi, maintenant que toutes les vérifications ont été effectuées et que le contrat sait que l’utilisateur dispose du nombre de jetons requis pour exécuter la transaction, le propriétaire du contrat peut lui envoyer des jetons en utilisant la fonction transfer ().
Cette fonction permet au propriétaire du contrat d’envoyer un montant donné du jeton à une autre adresse, tout comme une transaction de crypto-monnaie conventionnelle., Permet le transfert d’un certain nombre de jetons de l’offre totale vers un compte utilisateur.
transfert de fonction (adresse vers, jetons uint)
Publique
renvoie (succès booléen)
{
soldes [msg.sender] = safeSub (soldes [msg.sender], jetons);
soldes [à] = safeAdd (soldes [à], jetons);
émettre Transfert (msg.sender, to, tokens);
retourne vrai;
}
6. transfert
Nous avons déjà couvert la fonction de transfert, pourquoi avons-nous une autre?
Eh bien, prenons un exemple pour voir pourquoi transferFrom est un ajout si brillant au contrat ERC20.
Nous devons tous payer une somme d’argent chaque mois comme sur des roulettes. Il peut s’agir de votre loyer, des factures, etc. Vous n’avez pas vraiment besoin de payer vous-même tous ces montants. Vous pouvez toujours mettre en place un système de paiement automatique avec vos banques pour prendre en charge ces paiements.
C’est ce que transferFrom () vous permet de faire. Il vous aide à automatiser les transferts de paiement vers un compte spécifique.
transfert de fonction
(adresse de, adresse à, jetons uint)
Publique
renvoie (succès booléen)
{
soldes [de] = safeSub (soldes [de], jetons);
autorisé [de] [msg.sender] = safeSub (autorisé [de] [msg.sender], jetons);
soldes [à] = safeAdd (soldes [à], jetons);
émettre Transfert (de, à, jetons);
retourne vrai;
}
Le code complet
Voici le code complet de notre Token Blockonomi.
solidité pragma ^ 0,5,0;
// —————————————————————————-
// Interface ERC Token Standard # 20
//
// —————————————————————————-
contrat ERC20Interface {
function totalSupply () public view renvoie (uint);
function balanceOf (adresse tokenOwner) retour de vue publique (solde uint);
allocation de fonction (adresse tokenOwner, dépense d’adresse) retours de vue publique (uint restant);
transfert de fonction (adresse vers, jetons uint) retours publics (succès booléen);
function approve (adresse spender, uint tokens) retours publics (bool success);
function transferFrom (adresse de, adresse à, jetons uint) retours publics (succès booléen);
transfert d’événement (adresse indexée de, adresse indexée sur, jetons uint);
Event Approval (adresse indexée tokenOwner, adresse indexée spender, uint tokens);
}
// —————————————————————————-
// Bibliothèque de mathématiques sécurisées
// —————————————————————————-
contrat SafeMath {
function safeAdd (uint a, uint b) retours purs publics (uint c) {
c = a + b;
exiger (c >= a);
}
function safeSub (uint a, uint b) retours purs publics (uint c) {
exiger (b <= a); c = a – b; } function safeMul (uint a, uint b) retours purs publics (uint c) {c = a * b; exigent (a == 0 || c / a == b); } function safeDiv (uint a, uint b) retours purs publics (uint c) {require (b > 0);
c = a / b;
}
}
contrat BlockonomiToken est ERC20Interface, SafeMath {
chaîne nom public;
symbole public de chaîne;
uint8 décimales publiques; // 18 décimales est la valeur par défaut fortement suggérée, évitez de la changer
uint256 public _totalSupply;
mappage (adresse => uint) soldes;
mappage (adresse => mappage (adresse => uint)) autorisé;
/ **
* Fonction constructeur
*
* Initialise le contrat avec les jetons de fourniture initiaux au créateur du contrat
* /
constructor () public {
nom = "BlockonomiToken";
symbole = "BKM";
décimales = 18;
_totalSupply = 100000000000000000000000000;
soldes [msg.sender] = _totalSupply;
émettre le transfert (adresse (0), msg.sender, _totalSupply);
}
function totalSupply () public view renvoie (uint) {
return _totalSupply – soldes [adresse (0)];
}
function balanceOf (address tokenOwner) public view renvoie (uint balance) {
renvoyer les soldes [tokenOwner];
}
allocation de fonction (adresse tokenOwner, adresse spender) retour de vue publique (uint restant) {
retour autorisé [tokenOwner] [dépensier];
}
function approve (adresse spender, uint tokens) public Returns (bool success) {
autorisé [msg.sender] [spender] = jetons;
émettre l’approbation (msg.sender, spender, tokens);
retourne vrai;
}
transfert de fonction (adresse vers, jetons uint) retours publics (succès booléen) {
soldes [msg.sender] = safeSub (soldes [msg.sender], jetons);
soldes [à] = safeAdd (soldes [à], jetons);
émettre Transfert (msg.sender, to, tokens);
retourne vrai;
}
function transferFrom (adresse de, adresse à, jetons uint) retours publics (succès booléen) {
soldes [de] = safeSub (soldes [de], jetons);
autorisé [de] [msg.sender] = safeSub (autorisé [de] [msg.sender], jetons);
soldes [à] = safeAdd (soldes [à], jetons);
émettre Transfert (de, à, jetons);
retourne vrai;
}
}
Toutes nos félicitations! Vous avez développé avec succès votre propre jeton Ethereum.
La dernière étape est le déploiement sur le réseau réel.
Déployer votre jeton
Pour ce faire, nous aurons besoin du portefeuille Metamask.
Metamask est une extension qui vous permet d’exécuter Ethereum dApps directement dans votre navigateur sans exécuter un nœud Ethereum complet.
Aller à https://metamask.io/ depuis votre navigateur (Chrome, Firefox ou Opera) et ajoutez-le.
Créer un nouveau portefeuille dans MetaMask
Lorsque l’extension est installée, cliquez sur l’icône dans le coin supérieur droit de votre navigateur pour commencer à créer un portefeuille.
Lisez et acceptez les conditions, puis entrez un mot de passe fort et cliquez sur «Créer».
Vous verrez une phrase de départ de 12 mots. Enregistrez les mots de départ dans un fichier ou copiez-les dans un endroit sûr, puis cliquez sur “Je l’ai copié dans un endroit sûr”.
Vous avez maintenant créé avec succès un compte dans MetaMask avec une nouvelle adresse de portefeuille!
Vous remarquerez qu’actuellement, vous avez 0 ETH dans votre portefeuille. Pour déployer un contrat sur le réseau Ethereum, il faut une certaine quantité d’Ether. Nous ne déploierons pas notre contrat sur le réseau principal car il ne s’agit que d’une démonstration.
Nous publierons ce contrat sur le réseau de test. Il existe en fait quelques réseaux de test de blockchain Ethereum – Ropsten, Rinkeby, Kovan…
Utilisons Ropsten pour cet exemple.
Vous avez d’abord besoin d’Ether, non? Sur le réseau de test, nous travaillons avec de faux éthers gratuits. Il suffit de réclamer certains de ceux de Faucet.
Aller à: https://faucet.ropsten.be/ , collez votre adresse de portefeuille et cliquez sur “Envoyez-moi l’éther de test”.
Après quelques secondes, vous verrez des ETH dans votre portefeuille.
Le mettre en direct
Il est maintenant temps de tout faire vivre!
Accédez à Remix IDE et compilez le contrat. S’il n’y a pas d’erreur, nous sommes prêts pour le déploiement.
Pour l’environnement, sélectionnez Injected Web3. Il détectera automatiquement votre portefeuille metamask.
Appuyez sur le bouton Déployer.
Metamask vous demandera maintenant de retirer des fonds de votre portefeuille afin d’acheter cette transaction.
Confirmez cela. Revenez ensuite à Remix IDE et faites attention au terminal. On voit que la transaction a réussi.
Nous avons donc le hachage de transaction. Cliquez sur l’URI du terminal qui ressemble à: ropsten.etherscan.io/
Cela nous guidera vers etherscan.io – c’est Ethereum Blockchain Explorer et ici vous pouvez suivre tout ce qui se passe sur les réseaux principaux et de test, car tout est public sur la blockchain bien sûr.
Lorsque nous accédons à cet uri, nous verrons les détails de notre transaction. Cliquez sur le hachage du contrat pour en savoir plus.
Tout est public sur la blockchain, même notre code. Les développeurs Solidity n’ont pas de place pour les erreurs!
Clique sur le onglet contrat et vous verrez notre bytecode compilé
Vous pouvez maintenant accéder à Token Tracer pour voir les détails de notre Jeton Blockonomi. Vous pouvez voir 3 règles optionnelles que nous avons définies précédemment.
Vérifiez maintenant votre portefeuille. Vous verrez que l’Ether que nous avons payé pour le déploiement du contrat intelligent sur Ropsten a été supprimé.
Conclusion
Cela conclut notre tutoriel, en suivant ces étapes et nos exemples de code, vous devriez être en mesure de déployer votre propre jeton Ethereum ERC-20.
S’amuser!
