Les smart contracts, la promesse d’Ethereum

Vitalik Buterin a imaginé Ethereum pour servir de support à tous types d'applications décentralisées. Pour fonctionner, ces dernières se basent sur des smart contracts, ou contrats intelligents en français. Il s'agit de programmes autonomes déployés sur la blockchain (et plus précisément sur les comptes de contrat comme nous l'avons vu dans l'article précédent), qui exécutent automatiquement des actions prédéfinies lorsque certaines conditions sont remplies. Ces contrats révolutionnent les transactions en éliminant les intermédiaires et en apportant transparence, sécurité et efficacité. Dans cet article, nous vous présenterons en détails ces outils informatiques, les bases sur lesquelles ils reposent ainsi que leurs caractéristiques principales.

Temps de lecture estimé : 15 minutes

Introduction aux smart contracts

Principe et définition

Les contrats intelligents ne sont pas propres à Ethereum. Il s'agit de programmes informatiques irrévocables et autonomes, le plus souvent déployés sur une blockchain, qui exécutent un ensemble de règles et d'instructions prédéfinies. Pour une définition détaillée d'un smart contract, rendez-vous sur notre lexique.

Le terme « contrat intelligent » est cependant un peu trompeur, car ces programmes ne sont ni « intelligents » au sens humain du terme, ni des « contrats » au sens juridique. En 2018, le choix de cette appellation constituait même un regret pour le fondateur d'Ethereum, Vitalik Buterin.

Ces programmes sont appelés « contrats » parce qu’ils sont conçus pour exécuter des accords entre parties, tout comme un contrat juridique. Ici, c'est le code qui fait office de loi : « code is law », pour reprendre la célèbre formule de Lawrence Lessig.

Ils sont qualifiés d’« intelligent » du fait qu’ils exécutent ces accords de manière automatique et autonome, sans nécessiter d’intervention humaine. Cependant, contrairement à ce que le terme « intelligent » pourrait laisser supposer, ils ne sont pas capables d’apprendre ou de s’adapter en fonction de nouvelles informations.

Comme pour chaque programme informatique, la complexité est variable d’un contrat intelligent à l’autre. Certains implémentent des conditions logiques simples, à l'image d'une fonction « SI » d'Excel (si telle condition est remplie, alors le contrat est exécuté - « if this, then that » pour les intimes), alors que d'autres sont de véritables usines à gaz.

À titre d'exemple, certains contrats intelligents ont pour ambition de répliquer toutes les clauses et règles permettant à des sociétés, commerciales ou non, de fonctionner. On parle alors de DAO, acronyme pour Organisation Autonome Décentralisée. Il est à noter que bien souvent, la complexité est l'ennemie de la sécurité.

L'histoire des smart contracts

Bien qu'il ne soit devenu populaire que récemment, le terme « smart contract » nous vient du cypherpunk de légende, Nick Szabo, qui a écrit sur le sujet pour la première fois en 1994.

Contrairement aux idées reçues, ce n'est pas Ethereum mais Bitcoin qui fut le premier véritable système viable à fonctionner avec des contrats intelligents. Ces derniers sont cependant à l'heure actuelle limités, du fait du langage Script de Bitcoin qui n'est pas « Turing Complet » et ne permet pas d'exécuter de boucles, comme nous le verrons dans la suite de cet article.

C’est ensuite avec le lancement d’Ethereum en 2015 que les contrats intelligents ont vraiment connu leur essor. Cela grâce à Christian Reitwiessner et son équipe, qui ont pris la peine de développer un langage de programmation spécialement conçu pour pouvoir coder tous types de smart contracts : le Solidity, imaginé par Gavin Wood.

Le langage Solidity d'Ethereum

Un langage Turing Complet

Contrairement au langage Script de Bitcoin, Solidity est « Turing Complet ».

Ce terme fait référence au célèbre cryptologue et mathématicien de génie, Alan Turing. C'est en 1936, avant même l'apparition des ordinateurs, que ce dernier à imaginé une machine abstraite, pour définir clairement le concept d'algorithme aussi appelé « procédure mécanique ». Cette « machine » n'a rien de concret - il s'agit en fait d'un objet mathématique.

Un langage est dit « Turing Complet » s’il permet de simuler une machine de Turing, c’est-à-dire s’il peut résoudre n’importe quel problème de calcul, à condition qu’il soit exprimé correctement et que des ressources suffisantes soient disponibles. Cela signifie qu’il peut exprimer toutes les opérations logiques et mathématiques, et notamment les boucles qui font défaut à Bitcoin.

Solidity respecte ces caractéristiques. Pour éviter les boucles infinies, les concepteurs d'Ethereum ont fait en sorte que les instructions aient un coût financier pour pouvoir s'exécuter. Vous trouverez plus d'informations à ce sujet dans l'article dédié au gas.

Ceci complique la tache des développeurs qui doivent anticiper ces questions économiques, en plus de l'efficacité technique et de la sécurité lorsqu'ils veulent élaborer un contrat intelligent.

Les caractéristiques principales de Solidity

Solidity est langage de programmation en évolution permanente. Il est l'objet de mises à jour fréquentes, en fonction des failles identifiées et des nouvelles possibilités envisagées par les développeurs.

C'est un langage orienté objet, qui est largement inspiré du JavaScript et du C++. Sa syntaxe, proche du ECMAScript le rend facilement utilisable pour une grande partie des développeurs web.

Solidity est un langage de haut niveau, c'est à dire qu'il est plus proche des langues naturelles (français, anglais, etc.) que d'une suite de 0 et de 1. Ceci dans l'optique d'être « facilement » compréhensible et utilisable par les êtres humains.

Pour être interprété par l’environnement d’exécution d’Ethereum (l'Ethereum Virtual Machine dont nous parlerons dans l'article suivant), il doit être compilé en langage de bas niveau, du « bytecode », un code intermédiaire entre le code source et le code machine. Vous trouverez une illustration de ces propos dans le paragraphe « Exemple de smart contract ».

ll existe en parallèle deux autres langages utilisés pour coder des smart contracts sur Ethereum : le Vyper (plus sécurisé mais moins flexible) et le Yul/Yul+ (plus compliqués et moins sécurisés). Ils sont cependant largement moins populaires que le Solidity.

Les smart contracts sur Ethereum

Le déploiement d'un smart contract

Comme nous l'avons vu dans l'article précédent consacré au World State et aux comptes, un smart contract est stocké sur un compte de contrat sur la blockchain.

Il est déployé sur l'EVM, via l'adresse du compte. Une fois en place, il ne peut ni être modifié, ni être supprimé. Toutes les interactions ayant lieu avec ce dernier sont irréversibles. Il n'est contrôlé que par la logique contenue dans son code, et ni son créateur ni ses utilisateurs n'ont d'influence dessus. C'est grâce à ces propriétés que tous les transferts d'actifs sont à la fois publics, prévisibles et irrévocables.

Il est composé d'une part des lignes de codes qui définissent ses fonctions, et d'autre part d'un ensemble de variables qui définissent son état.

Les fonctions peuvent être appelées de manière interne (ne crée pas d'appel EVM), ou externe (créer un appel EVM) et entraîner des modifications des variables d'états.

Les standards techniques de jeton

Un contrat intelligent peut être codé de différentes manières pour un même cas d'usage. Cependant, à l'instar des contrats « papier » (par exemple un contrat de location) pour lesquels il est existe des modèles, les plus utilisés ont donnés lieu à la création de normes appelées ERC pour « Ethereum Request for Comments ».

Les ERC sont des standards techniques qui définissent des interfaces standardisées pour les smart contracts. Cela permet aux développeurs d'écrire des applications qui peuvent interagir avec n'importe quel contrat sans connaître ses spécificités. Les plus connus sont :

• L'ERC-20 : standard le plus utilisé qui permet de créer des jetons fongibles (USDT, MATIC, OP, ARB, LINK, UNI, etc.). Oui, les « jetons » sont donc des smart contracts construits sur une blockchain tierce à l'inverse des « coins » qui sont natifs à leur propre blockchain (BTC, ETH, SOL, ATOM, etc.) ;

• L'ERC-721 : il permet de créer des jetons non fongibles ;

• L'ERC-1155 : il combine les fonctions des ERC-20 et 721 au sein d'un même smart contract ;

• L'ERC-165 : il est utilisé pour publier et détecter les interfaces qu’un contrat intelligent implémente ;

• L'ERC-621 : il permet d'augmenter ou de diminuer l'offre d'un jeton en introduisant un mécanisme de burn/redeem ;

• L'ERC-777 : il réduit le nombre de transactions liées à une même fonction et diminue les frais ;

• L'ERC-4337 : déployé en 2023, il permet l’abstraction de comptes, c'est à dire qu'il élimine la nécessité de stocker une clé privée pour chaque compte.

• ...

Ces standards ainsi que les comportements les plus utilisés sont disponibles dans des librairies, qui offrent des « morceaux de code » copiables et prêts à l'emploi pour tous les smart contracts qui les utilisent.

Un exemple de smart contract

En 2022, il y avait plus de 44 millions de contrats intelligents déployés sur Ethereum ! Autant dire que les plus curieux d'entre vous n'auront pas de mal à trouver d'autres exemples...

Pour nous adresser au plus grand nombre, nous vous donnons ici un exemple très simple de contrat intelligent codé en Solidity, qui parlera sûrement à ceux d'entre vous qui se sont déjà essayés à la programmation.

// SPDX-License-Identifier: MIT
// compiler version must be greater than or equal to 0.8.20 and less than 0.9.0
pragma solidity ^0.8.20;

contract Bonjour {
    string public message = "Salut, c'est l'encyclo du JDC!";
}

Ici le smart contract s'appelle « Bonjour » et est codé à l'aide de la version 0.8.20 de Solidity. Il contient une variable appelée « message ». Lorsqu'on lit cette variable, on obtient le message suivant : « Salut, c'est l'encyclo du JDC ! ».

Pour pouvoir l'exécuter il faut le compiler avant de le déployer sur la blockchain. Pour ce faire, les développeurs utilisent des interfaces appelées « Environnements de Développement Intégrés » (IDE). L'une des plus connues est Remix.

Ici, pour vous montrer à quoi ressemble le bytecode (dans le cadre en rouge), nous avons utilisé soliditylang.org.

Une fois compilé, le contrat intelligent peut être déployé sur la blockchain, ce qui créé un compte de contrat. N'importe qui peut alors interagir avec ce contrat, grâce à l'adresse du compte.

L'utilisation des smart contracts

Les smart contrats peuvent être utilisés de deux manières :

• En lecture simple : ceci n'entraîne pas de transaction.

• En utilisant une ou plusieurs de ses fonctions : ceci est initié par une transaction envoyée à destination de l'adresse du compte du contrat, ce qui entraîne de nouvelles transactions et modifie l'état des comptes. Il y a donc écriture sur la blockchain.

La plupart des utilisateurs n'interagissent pas directement avec les smart contracts. En effet, ceci demande d'avoir des connaissances techniques particulières. Pour faciliter l'interaction avec les smart contract, ils passent par des interfaces qui se chargent de traduire les fonctions des smarts contrat en langage courant. Ces interfaces sont le plus souvent des sites web (Uniswap) ou des extensions de navigateur (Metamask).

Les smart contracts garantissent un ensemble de conditions d’exécution, qui en théorie ne laissent pas de place au doute ou à la confusion. Les conditions sont très clairement fixées et l’interprétation du code est sans équivoque, contrairement à l’interprétation humaine, qui laisse toujours place à la négociation ou à la découverte d’un vide juridique.

Cependant, plus ces derniers sont complexes, plus il est possible qu'ils présentent des failles. Pour les tester avant de les déployer sur le réseau principal d'Ethereum, il existe heureusement plusieurs réseaux de test, sur lesquels le gas est gratuit et les erreurs sont permises.

Les applications décentralisées (dApps)

Un contrat intelligent est très rarement utilisé seul. Il interagit souvent avec d'autres contrats. Lorsqu'une interface utilisateur est conçue pour faciliter leur utilisation, l'ensemble forme une application décentralisée (dApps).

Pour optimiser son fonctionnement et ses coûts, tous les éléments d'une dApp ne sont pas forcément décentralisés, et toutes les données ne sont pas obligatoirement stockées sur la blockchain. A l'instar d'Uniswap, il est courant d'avoir une interface centralisée et un protocole décentralisé. De nombreuses dApp utilisent par exemple l'InterPlanetary File System (IPFS) pour le stockage.

Suivant les cas d'usages, il est possible d'avoir besoin de récupérer des données extérieures à la blockchain. Les entités qui se chargent de récupérer, vérifier et transmettre ces données aux contrats intelligents sont appelées « oracles ». Ces derniers peuvent être centralisés ou non. L'un des plus connus de l'écosystème est Chainlink.

Voici une liste non exhaustive des applications décentralisées les plus populaires sur le réseau Ethereum, qui peuvent vous donner une idée un peu plus concrète de ce que les smart contracts permettent de faire à l'heure actuelle. Si vous voulez les essayer, vous aurez besoin d'un portefeuille de type Metamask, et de fractions d'ether pour payer les frais de transactions. Pas panique, l'aspect « pratique » de la chose sera expliqué dans un prochain chapitre de l'Encyclopédie du Coin :

• Les portefeuilles : Metamask, Rabby et bien d'autres... Ils sont logiquement utilisés pour stocker vos jetons et interagir avec les dApps.

• Plateforme d'échanges décentralisées (DEX) : Uniswap, PancakeSwap, Curve Finance, Dodo, Balancer... Elles permettent d'échanger des jetons les uns contre les autres.

• Agrégateurs de swap : 1inch, Kyberswap, Paraswap... Ils cherchent le chemin le plus rentable pour vous lorsque vous voulez procéder à des échanges.

• Plateforme de prêt et d'emprunt : Aave, Coumpond, Zero Lend... Vous pouvez prêter ou emprunter des cryptomonnaies.

• Agrégateurs de rendement : Yearn Finance, Convex... Ils permettent de trouver les plateformes offrants le meilleur rendement pour déposer des jetons et gagner des intérêts.

• Bridge : Multichain, Orbiter Finance, LayerSwap... Pour envoyer des jetons d'une blockchain à une autre.

• Agrégateurs de bridge : Rubic, Rhino... Pour trouver le chemin le plus avantageux pour bridger des tokens.

• Assurances : Nexus, Etherisc... Pour vous assurez contre les bugs et piratages ou créer vos propres contrats d'assurance.

• Trading de produit dérivés : Synthetix, dYdX, GMX... Pour spéculer sur les mouvements de prix de divers actifs sans les posséder directement.

• Staking Liquide : Lido, Ankr... Pour mettre vos ETH en staking et obtenir une preuve de dépôt échangeable (et liquide).

Et bien plus encore...

L’économie des smart contracts est encore embryonnaire mais semble promise à un très bel avenir. De nombreuses applications décentralisées dans les secteurs de la santé, l’assurance, ou encore les chaînes d’approvisionnement (pharmaceutiques, agro-alimentaires, cosmétiques, etc.) sont actuellement en cours de développement.

Si Ethereum est actuellement la blockchain la plus utilisée pour la programmation de smart contracts, elle n'est pas pour autant la seule. De plus en plus de protocoles concurrents se développent (Solana, Avalanche, Tezos, Cardano, Polkadot ou encore Cosmos) et permettent aussi de le faire.

Les avantages et inconvénients des smart contracts

Vous l'avez compris, les avantages des smart contracts sont multiples. Ces derniers permettent notamment de :

• Sécuriser un accord entre deux parties (ou davantage) grâce à la transparence et l’immutabilité du code et de la blockchain ;

• Automatiser des opérations tels que les paiements et éliminer les risques d’impayés, fréquemment observés dans le cadre d’un contrat traditionnel ;

• Diminuer drastiquement les coûts intermédiaires dans l’élaboration, le suivi et la passation d’un contrat (notaire, avocat) ;

• Profiter d'une communication claire qui ne laisse pas la place à l'interprétation ;

• ...

Les contrats intelligents comportent cependant des inconvénients, le principal restant le risque de failles, inhérent à tout programme informatique.

Le code des smart contracts est open source. Il est possible de récupérer le bytecode sur les adresses de contrat et de le décompiler pour récupérer du Solidity. Le revers de la médaille est qu'un code mal conçu peut facilement être étudier et permettre à des hackers ou des personnes malveillantes de détourner des fonds au détriment des autres utilisateurs.

L’exemple de piratage le plus connu est celui de The DAO, ayant entraîné une perte de plus de 150 millions de dollars (en ethers).

Pour aller plus loin

Si vous lisez ces lignes, c'est que l'univers des blockchains et cryptomonnaies vous intéresse. Aussi, nous invitons ceux d'entre vous qui ont le temps et l'envie à aller plus loin dans la découverte de la programmation et des smart contracts.

A titre informatif, le marché de l'emploi pour les développeurs Solidity est très loin d'être saturé et les salaires sont très attractifs. Après en avoir terminé avec cette encyclopédie, vous pourrez commencer par vous tourner vers la documentation officielle de ce langage de programmation.

Si vous voulez apprendre à coder vos propres smart contracts en Solidity, vous pouvez aussi consulter les articles Ethereum France ou encore les tutoriels de Cryptozombies ou de Block Geeks.

Vous l'avez compris, une fois les contrats déployés, ils sont stockés par les nœuds du réseau sur la blockchain. Pour les exécuter, c’est dans l’EVM (Ethereum Virtual Machine) que tout se passe ! C'est cet élément essentiel d'Ethereum que nous étudierons dans le prochain article de notre Encyclopédie.