Comment créer un smart contract sur Ethereum ?

Smart contracts sur Ethereum : comment ça marche ?

L’une des principales raisons de la popularité de Solidity est qu’il s’agit du langage utilisé pour les programmes qui s’exécutent sur la machine virtuelle Ethereum (EVM). Pour comprendre pourquoi c’est important, il est utile de connaître un peu l’histoire de la blockchain.

La technologie blockchain a commencé à se diffuser en 2009 avec l’arrivée du Bitcoin. La blockchain Bitcoin – qui motorise la crypto-monnaie Bitcoin (c’est le même nom, mais ce sont deux choses bien différentes) – permettait de transférer des bitcoins (la crypto-monnaie) entre des parties, de manière sécurisée et sans autorité centrale. Mais à part cela (et c’était déjà pas mal), la blockchain Bitcoin ne savait rien faire. Elle ne permettait pas d’exécuter des règles ou d’appliquer une logique conditionnelle.

Il n’était par exemple pas possible de programmer une transaction telle que « Bob transférera deux bitcoins à Alice le premier de chaque mois pour payer le loyer de Bob ».

Puis une autre blockchain est apparue, Ethereum, avec ce type de capacités.

Pour les utiliser, Ethereum prend en charge des programmes, appelés « smart contracts ». Pour en développer, l’équipe d’Etehreum a créé un langage, Solidity, et elle a en parallèle normalisé l’EVM comme mécanisme d’exécution des smart contracts sur la blockchain Ethereum.

Concrètement, l’EVM agit comme un intermédiaire entre le bytecode compilé du smart contract et la blockchain, de la même manière qu’une machine virtuelle Java (JVM) agit comme un intermédiaire entre le bytecode Java compilé et la machine qui héberge le programme Java.

Pour Ethereum, les développeurs produisent le code du smart contract en Solidity sous la forme d’un fichier texte. Puis, le compilateur de Solidity (solc) transforme ce texte en bytecode que l’EVM peut comprendre. Enfin, le bytecode est déployé et hébergé sur la blockchain Ethereum à une adresse donnée (voir figure 1).

Selon la manière dont il est conçu, le smart contract peut fonctionner de manière autonome, ou appeler des fonctions à l’aide d’outils spéciaux.

Solidity et l’EVM ont depuis été largement adoptés. La popularité du langage Solidity s’est accrue à mesure que d’autres blockchains comme Avalanche ou Hedera ont intégré la spécification EVM.

Aujourd’hui, GitHub recense plus de 56 000 dépôts de code source liés à Solidity.

Création et déploiement d’un smart contract sur le réseau Ethereum

Bien. Maintenant, créons un smart contract et voyons comment le déployer sur Ethereum.

Le langage Solidity prend en charge l’héritage, l’encapsulation et le polymorphisme, choses classiques dans les langages orientés objet (POO) comme Java, C# ou TypeScript. Mais alors qu’en POO l’unité de base de l’encapsulation est la classe, dans Solidity elle est appelée « contrat ». Un contrat peut contenir des membres, des attributs (données) et des fonctions, publiques ou privées.

Une autre caractéristique propre à Solidity est la notion de variables prédéfinies msg, tx et block, qui sont communes à tous les contrats.

La variable msg décrit l’appel externe fait au contrat. La variable tx décrit les frais associés au coût d’exécution du contrat et la partie qui va payer ces frais.

Une caractéristique commune à toutes les blockchains est en effet qu’il y a des frais, mesurés dans une unité de dénomination appelée gaz, à payer chaque fois qu’une transaction est exécutée – que ce soit un simple transfert de fonds ou une fonction exécutée dans des applications décentralisées comme les programmes en Solidity.

La variable block décrit quant à elle l’état d’un bloc de la blockchain sous-jacente sur laquelle le contrat est hébergé. Par exemple, la propriété block.gaslimit indiquera la quantité maximale de gaz que la blockchain sous-jacente autorisera à être consommée par une transaction donnée.

Comme pour la programmation orientée objet, Solidity prend en charge les interfaces, ce qui permet aux développeurs de définir les méthodes et les attributs qu’un contrat fournira. En outre, un smart contract est considéré comme un type de données composite, tout comme une classe en programmation orientée objet.

Les exemples de codes qui suivent illustrent les étapes de la création d’un smart contract qui déclare une interface, puis la manière dont cette interface est implémentée dans un deuxième smart contract. La troisième étape montre un autre smart contract qui renvoie l’interface.

Le Code 1, ci-dessous, déclare une interface nommée ILocation. (Tout le code de cet article est disponible dans l’un de mes dépôts GitHub ici).

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;

interface ILocation {
    function getLongitude( ) external view returns(uint16 );
    function getLatitude( ) external view returns(uint16 );
}

Le Code 2 montre comment implémenter l’interface ILocation dans un contrat nommé Location. Notez que la syntaxe qui permet de déclarer un contrat en tant qu’implémentation d’une interface est exprimée à la ligne 5 à l’aide du mot-clé is.

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
import "./ILocation.sol";

contract Location is ILocation {
    uint16 latitude;
    uint16 longitude;
    constructor (uint16 _longitude, uint16 _latitude){
        latitude = _latitude;
        longitude = _longitude;
    }

    function getLongitude() external view returns(uint16 ){
        return longitude;
    }

    function getLatitude () external view returns(uint16 ){
        return latitude;
    }
}

Le Code 3 montre un autre smart contract Solidity qui importe le contrat Location défini dans le Code 2. Remarquez la déclaration d’importation à la ligne 3. L’importation du contrat Location importe implicitement l’interface ILocation. La fonction getLocation() renvoie une interface ILocation qui s’appuie en coulisses sur un contrat Location défini dans le Code 2.

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
import "./Location.sol";

contract LocationFactory {
    function getLocation(uint16 _longitude, uint16 _latitude) public returns (ILocation) {
        return new Location(_longitude, _latitude);
    }
}

Ces trois codes montrent comment créer et utiliser des contrats en Solidity, mais aussi comment utiliser l’abstraction, courante en programmation orientée objet.

Pour déployer le code sur une blockchain compatible avec EVM, le développeur doit ensuite compiler le code en bytecode, puis déployer le bytecode sur la blockchain, soit à l’aide d’un outil en ligne de commande, soit avec un IDE comme VS Code ou Remix.

Regardons un peu ces différents outils.

Outils pour développer en Solidity

L’évolution des outils pour créer des applications distribuées basées sur des smart contracts est impressionnante si l’on pense que Solidity ne date que de 2014. Aujourd’hui, les IDE font le plus gros du travail, ce qui permet aux développeurs de se concentrer sur la logique de leurs smart contracts plutôt que sur la machinerie (l’usine à gaz ?) pour faire fonctionner le tout. La plupart des développeurs de smart contracts utilisent donc aujourd’hui un IDE. L’époque où l’on utilisait un simple éditeur de texte est révolue.

Il existe deux types d’IDE. L’un est hébergé sur votre machine, en local, l’autre est en ligne et accessible à partir d’un navigateur web. Dans les IDE installables en local, on citera Visual Studio Code et JetBrains WebStorm.

À noter qu’utiliser un IDE local implique également un framework comme HardHat ou Truffle pour faciliter la compilation et le déploiement.

Dans les outils web, Remix d’Ethereum est le plus populaire.

Remix propose plusieurs fonctionnalités qui facilitent la création des smarts contract Ethereum comme la gestion des librairies, l’autocomplétion, la vérification de la syntaxe du code et même le déploiement. Remix permet de déployer des smart contracts sur des EVM de développement spécifiques. On peut également relier l’IDE à un wallet MetaMask (via un plugin du navigateur) et utiliser ensuite la crypto-monnaie Ether à partir d’une variété de comptes Ethereum pour évaluer et payer les frais de transaction liés au déploiement et à l’exécution du smart contract sur la blockchain.

Conclusion

Solidity est un langage robuste qui allie la puissance de la POO à la complexité de la blockchain. Mais aussi puissant soit-il, il n’en est qu’à ses débuts. Ses perspectives seront de plus en plus grandes à mesure que le web 3.0 et les applications décentralisées se développeront. Cet article n’était donc qu’un premier pas sur le long et passionnant chemin qui nous attend.