fbpx Solidity pour les débutants – Hello World smart contract | Développeur Blockchain France

Solidity pour les débutants – Hello World smart contract

Posté par Vincent Ton le décembre 10, 2019 dans Formation Développeur Blockchain
Card Image

Aujourd’hui, tu as sûrement entendu les termes comme smart contract, ERC20 Token ou solidity. Tu as vu que entreprises recrutent de plus en plus de développeurs blockchain, mais tu te demandes comment y devenir.

Ça tombe bien, tu vas découvrir dans cet article une introduction à Solidity, LE langage pour écrire un smart contract sur Ethereum. Nous allons écrire ensemble un smart contract qui retourne « Hello World ». Pour ensuite se diriger sur l’écriture d’un CRUD (pour Create, Read, Update, Delete).

Prérequis :

Pour écrire des smart contracts, tu vas devoir utiliser ce site : remix.ethereum.org/ À l’heure où j’écris cet article, ce site comporte un bug génant, je ne vous conseille pas de cocher la case « auto-compile ». Je te laisse découvrir ce bug mais je pense que d’ici les quelques jours, le bug sera résolu.

Sinon, l’autre prérequis c’est que vous ayez une expérience sur Javascript pour suivre le tutoriel avec confiance.

Qu’est-ce que Solidity ?

Solidity est un langage de programmation qui te permet d’écrire des smart contracts sur l’Ethereum.

Un smart contract est un programme exécutable dans lequel on peut définir des règles.

Pour déployer un smart contract sur l’Ethereum, il y a 3 étapes :
1 – Un développeur écrit un smart contract en utilisant Solidity;
2 – Ensuite, le développeur compile le smart contract en bytecode;
3 – Enfin, le développeur déploie le smart contract sur un EVM ou Ethereum Virtual Machine

Il faut savoir qu’un EVM ne peut lire que du bytecode, d’où l’étape de compilation.

Remix IDE : 2 plugins à installer

Quand je suis allé sur remix.ethereum.org/ hier, j’étais très surpris car tout a été désinstallé. Mais pas de panique, voici les plugins que tu dois installer si toi aussi tu te retrouves avec rien sur remix IDE :

remix IDE

1 – Solidity compiler pour compiler, c’est à dire traduire le smart contract de Solidity à Bytecode ;
2 – Deploy & run transactions pour déployer le smart contract dans un EVM ;
3 – Solidity static analysis.

Débuter sur Solidity : HelloWorld.sol

Maintenant que tu as installé les plugins sur remix.ethereum.org/, il est temps de créer un nouveau fichier. Pour ce faire, il suffit de cliquer sur le « + ». Tu l’appelleras « HelloWorld.sol » sans oublier l’extension « .sol ».

1 – pragma

La première chose à faire c’est de déclarer quel langage de programmation tu vas utiliser sur le smart contract (oui car l’extention .sol ne suffit pas …). Pour ce faire, on va utiliser : pragma

pragma solidity ^0.5.12;

On n’oublie pas le  » ;  » sinon un message d’erreur va apparaître.

Ici, on utiliser la version 0.5.12 qui est la plus récente à l’heure où j’écris ce tutoriel.

Si tu ne veux pas réfléchir concernant quelle version de Solidity tu dois prendre, tu peux très bien écrire :

pragma solidity >=0.4.0 <0.7.0; // on n'oublie pas le point-virgule !

ps : le double slash permet de mettre un commentaire en une seule ligne. Pour écrire un commentaire en plusieurs ligne, il faut faire : /* ... */

2 - contract

Ensuite, on va pouvoir commencer à écrire le contrat. Pour cela, on va utiliser le terme ...... contract ! Comme ceci :

contract HelloWorld {
//...
}

À noter que le nom HelloWorld est le même que le nom du fichier HelloWorld.sol. Ce n'est pas obligatoire, mais je te conseille d'avoir ce réflexe de nommer comme ceci. Car plus tard, lorsque tu voudras faire des tests unitaires avec Mocha et Chai, tu verras qu'il faut importer le fichier solidity. Et on peut vite se méler les pinceaux.

Au final, ton premier smart contract ressemble à ceci :

pragma solidity ^0.5.12; // ou pragma solidity >=0.4.0 <0.7.0;

contract HelloWorld {
//...
}

Là, tu peux déjà compiler et déployer le smart contract. Et tu obtiendras une adresse ethereum pour ce smart contract. Mais bon, c'est un peu vide ...

3 - Ma première fonction en solidity

À l'intérieur de contract HelloWorld { ... }, entre le code suivant :

function hello() public view returns(string) {
    return "Hello World!"; // on n'oublie pas le point virgule
}

Tout de suite, ça se complique !

Tout d'abord, il y a public qui signifie que "la fonction peut être appelé par tout le monde".

Ensuite, il y a view. Le terme view est utilisé lorsque la fonction RETOURNE un résultat. C'est pourquoi tu vas souvent voir : view / returns / return

Et enfin, il y a returns(string). Avec un S ! Car c'est la fonction hello() qui retourne un string. En anglais, on traduirait comme ceci : "The function hello() returns a string" (3e personne du singulier). Dans l'accolade {}, il y a aussi le mot return sans S. Car la fonction hello() dit à l'exécutant : RETOURNE "Hello World!" (c'est de l'impératif, et en anglais, ça donne : Return "HelloWorld!").

Et tu sais quoi ? Si tu compiles la fonction, ça ne marche pas. Car depuis qu'on est passé sur la version 0.5.0 et plus, il faut préciser si les data complexes (comme string) sont des données temporaires où permanents.

memory solidity
Remix n'est pas content 🙁

C'est pourquoi remix te dit d'utiliser memory. Voici la fonction corrigée :

pragma solidity ^0.5.12;

contract HelloWorld {
    function hello() public view returns(string memory) {
        return "Hello World !";
    }
}

4 - Compile and Deploy

Maintenant que tu as écrit la fonction, il faut cliquer sur le bouton "Compile HelloWorld.sol" pour que le compiler traduit en bytecode.

Ensuite, il faut aller sur le plugin Deploy & run transaction pour la partie déploiement. Clique sur le bouton Deploy. Et c'est bon.

Tu peux analyser le résultat en cliquant sur la flèche à côté de "Debug" :

Résultat du déploiement

Dans le résultat, tu peux voir : l'adresse du smart contract (1), le propriétaire du smart contract (2) et le coût du déploiement du smart contract. C'est la somme entre "transaction cost" et "execution cost".

La différence entre "transaction cost" et "execution cost" est la suivante :
- La "transaction cost" représente le coût d'envoi des données dans la Blockchain Ethereum ;
- "execution cost" représente le coût de l'opération de calcul.

Pour en savoir plus, tu peux lire ici : ethereum.stackexchange.

Un smart contract un peu plus avancé : Message.sol

Maintenant que tu as vu comment faire un HelloWorld sur solidity, on va augmenter le difficulté. On va créer une fonction message :
- prendre 1 input string monMessage
- retournera le string monMessage.

Pour se faire, tu peux déjà :
1 - créer un nouveau fichier Message.sol ;
2 - copier-coller le code de HelloWorld.sol et changer le nom du contract en Message ;
3 - modifier la fonction hello() en message() (tu peux le laisser si tu as la flemme de modifier le nom).

1 - Les variables

Maintenant, à l'intérieur de la parenthèse de la fonction message(), on va déclarer un paramètre. Appelons monMessage.

pragma solidity ^0.5.12;

contract Message {    
    function message(string memory monMessage) public view returns(string memory) {
        return monMessage;
    }
}

Quand on définit une variable ou un paramètre, il faut préciser sur solidity le type de la variable ou du paramètre. Ici, monMessage est un string. On met memory pour dire que le paramètre "monMessage" ne garde pas la donnée de façon permanente sur la blockchain Ethereum.

Maintenant, si monMessage est un chiffre, il faut enlever string memory et mettre
uint pour unsigned integer. On n'oublie pas aussi de modifier ce qui a à l'intérieur de returns() :

pragma solidity ^0.5.12;

contract Message {    
    function message(uint monChiffre) public view returns(uint) {
        return monChiffre;
    }
}

Ici, pas besoin de définir memory car Solidity ne considère pas que uint est un paramètre complexe, contrairement à string.

ps : Remix IDE nous demande de mettre pure au lieu de view. En effet, les fonctions qu'on a écrites jusqu'à maintenant ne vont pas chercher les données dans la Blockchain. Je vous invite à lire ceci : view vs pure

2 - Deploy

Une fois que tu as écrit le smart contract, il est temps de déployer. Ensuite, il faut cliquer sur la flèche dans la partie "Deployed Contracts" comme l'image ci-dessous

Clique sur la flèche dans Deployed Contracts

Maintenant, tu peux entrer une valeur et cliquer sur le bouton bleu. Attention, n'oublie pas de mettre des guillemets quand on entre un string comme valeur.

Un smart contract plus avancé : CRUD

Le CRUD est l'acronyme de Create, Read, Update et Delete. Faire un CRUD est un exercice que l'on retrouve souvent quand on apprend un nouveau langage. Tout d'abord, recopie le code ci-dessous dans le fichier CRUD.sol :

pragma solidity ^0.5.12;

contract CRUD {
//...
}

Dans ce smart contract, nous allons contruire 4 fonctions :
- create ;
- read ;
- update ;
- delete ... SAUF QUE ça ne va pas marcher parce que delete est une fonction qui existe déjà sur Solidity. Donc la dernière fonction sera : destroy.

Mais avant tout, on va déclarer les variables que l'on va utiliser dans le smart contract.

1 - struct

L'idée, c'est que le CRUD va nous permettre de créer une liste de candidats (pour StarAc). Pour cela, on va créer une sorte de matrice comme l'image ci-dessous :

Oui, quand je créé un smart contract, j'aime bien passer par du papier ... 🙂

Pour créer ce sorte de matrice (ou un Array), on va utiliser la commande struct. Cette commande permet de déclarer un nouveau type autre que uint pour les chiffre ou string pour du texte. Voici comment faire :

struct Candidat{
    uint id;
    string name;
}
Candidat[] public candidats;
uint public nextId;

Quelques remarques sur le code : J'ai mis un C en majuscule dans Candidat car c'est de rigueur de mettre une majuscule lorsqu'on définit un struct. Un struct permet de déclarer un nouveau type, ici le nouveau type est : Candidat[]

Le type Candidat doit contenir un id en chiffre et un nom en string. Et "candidats" avec un s correspond à la liste des candidats.

Nous aurons besoin de nextId pour parcourir la liste des candidats.

2 - Create, Read, Update, Destroy

Maintenant, on va construire les 4 fonctions. Parmi ces 4 fonctions, create(), update() et destroy() modifient les données de la blockchain. C'est pourquoi il n'y aura pas l'attribut view pour ces 3 fonctions.

Voici la fonction pour create :

function create(string memory name) public {
    candidats.push(Candidat(nextId, name));
    nextId++;
}

Dans cette fonction, on a utilisé la commande push qui permet de "pousser" un candidat dans la liste "candidats" (dans la dernière position de candidats)

Voici la fonction pour read :

function read(uint id) public view returns(string memory) {
    for(uint i = 0; i <= candidats.length; i++){
        if(i == id){
            return candidats[i].name;
        }
    }
}

Ici, on a utilisé la commande for et la commande if. Remarque que dans for, j'ai déclaré un nouveau variable : i. Et c'est pourquoi je suis obligé de mettre un "uint i" car c'est un nouveau variable.

Voici la fonction pour update :

function update(uint id, string memory name) public {
    for(uint i = 0; i <= candidats.length; i++){
        if(i == id){
            candidats[i].name = name;
        }
    }
}

C'est pratiquement similaire que pour read.

Voici la fonction pour destroy :

function destroy(uint id) public {
    for(uint i = 0; i <= candidats.length; i++){
        if(i == id){
            delete candidats[i].name;
        }
    }
}

C'est pourquoi la fonction s'appelle destroy et non delete car delete existe déjà sur solidity. Elle permet de supprimer le nom d'un candidat.

Je vous invite à refaire cet exercice, et même améliorer ce smart contract.

3 - Deploy

Maintenant, il est temps de compiler et de déployer le smart contract. Si vous n'arrivez pas à compiler, voici le smart contract que tu peux copier-coller :

pragma solidity ^0.5.12;

contract CRUD {
    struct Candidat{
        uint id;
        string name;
    }
    Candidat[] public candidats;
    uint nextId;
    
    function create(string memory name) public {
        candidats.push(Candidat(nextId, name));
        nextId++;
    }
    
    function read(uint id) public view returns(string memory) {
        for(uint i = 0; i <= candidats.length; i++){
            if(i == id){
                return candidats[i].name;
            }
        }
    }
    
    function update(uint id, string memory name) public {
        for(uint i = 0; i <= candidats.length; i++){
            if(i == id){
                candidats[i].name = name;
            }
        }
    }
    
    function destroy(uint id) public {
        for(uint i = 0; i <= candidats.length; i++){
            if(i == id){
                delete candidats[i].name;
            }
        }
    }
    
}

Maintenant, tu peux jouer avec ce smart contract et créer ta liste des candidats.

Oui ... j'ai mal écrit Nairobi. Mais le plus important, c'est qu'il y a 2 couleurs : orange et bleu.

As-tu remarqué qu'il y a des boutons oranges et des boutons bleus ? Si c'est orange, alors tu dois dépenser des frais de transactions en gas pour appeler une fonction. En clair, tous les fonctions qui n'ont pas l'attribut view.

Et pour les boutons bleus, cela veut dire que tu ne dépenses pas d'ether pour appeler une fonction.

transact pour les boutons orange, call pour les boutons bleu.

Il existe aussi un bouton de couleur rouge. Tu verras lorsque une fonction manipule de l'ether (par exemple : dépôt d'eth, transfert d'eth, ...).

Conclusion

Si tu cherches à apprendre Solidity mais que tu n'as encore créer un smart contract, cet article est pour toi ! Dans cet article tu as obtenu des bases de Solidity. À travers 3 smart contract, tu as appris :

  • comment débuter un smart contract avec pragma et contract ;
  • comment déclarer une variable sur Solidity (il faut toujours préciser le type de variable) ;
  • l'attribut public ;
  • l'attribut view ;
  • les returns et return ;
  • déclarer un nouveau type avec struct ;
  • quelques commandes de bases de Javascript comme push, for, if ;
  • comment utiliser remix IDE pour compiler, déployer et appeler les fonctions.

Et si tu souhaites maitrîser plus de choses sur Solidity, tu peux réserver un appel stratégique ci-dessous avec moi !

Laisser un commentaire

Your email address will not be published. All fields are required.