Comment créer et déployer un contrat intelligent sur Ethereum

L'émergence d'Ethereum et des contrats intelligents a radicalement transformé notre compréhension des accords numériques, des paiements conditionnels et, plus généralement, de la confiance dans les environnements en ligne. Ce qui nécessitait auparavant des intermédiaires, des formalités administratives et des processus manuels peut désormais être automatisé grâce à un code exécuté de manière décentralisée sur une blockchain publique.

Si cela vous semble compliqué ou réservé aux experts, rassurez-vous : créer et déployer son propre contrat intelligent est bien plus accessible qu’il n’y paraît. Grâce aux outils actuels (Remix, Truffle, Ganache, MetaMask, nœuds cloud, etc.), vous pouvez, en quelques étapes simples, créer un contrat intelligent fonctionnel sur un réseau de test ou même sur le réseau principal Ethereum.

Qu'est-ce qu'un contrat intelligent exactement dans Ethereum ?

Un contrat intelligent est un programme qui s'exécute sur une blockchain . Dans le cas d'Ethereum, ce programme s'exécute au sein de la machine virtuelle Ethereum (EVM), répliquée sur tous les nœuds du réseau. Le contrat définit des règles, des conditions et des actions qui sont exécutées automatiquement lorsque ces exigences sont remplies, sans intervention d'un tiers.

On peut considérer cela comme un accord numérique du type « si X se produit, alors Y » . Par exemple : « si l’utilisateur A effectue un paiement supérieur au montant n à l’adresse M avant le jour Z, la facture est marquée comme payée avec succès. » Avant l’avènement de la blockchain, il était impossible d’appliquer automatiquement ce type de règles sans intermédiaires de confiance.

Ethereum est la plateforme la plus populaire pour les contrats intelligents grâce à son environnement très flexible, sa vaste communauté, sa documentation complète et ses outils de développement éprouvés. Tout cela facilite la création d'applications décentralisées (DApps) et de contrats complexes, aussi bien pour les développeurs débutants que confirmés.

Les contrats intelligents sont essentiellement du code source écrit dans un langage spécifique (Solidity ou Vyper, entre autres), compilé en bytecode et déployé sur une adresse de contrat du réseau. À partir de là, tout utilisateur ou application peut interagir avec ce contrat en appelant ses fonctions publiques.

Solidity, l'EVM et d'autres langages de contrats

Solidity est le langage de programmation de référence pour le développement de contrats sur Ethereum . C'est un langage de haut niveau dont la syntaxe rappelle celle de JavaScript, C++ ou Java, conçu spécifiquement pour être compilé en bytecode compréhensible par la machine virtuelle Ethereum.

La machine virtuelle Ethereum (EVM) est la machine virtuelle qui exécute votre contrat sur chaque nœud du réseau. Son concept est similaire à celui d'une machine virtuelle Java, la principale différence étant que, dans Ethereum, chaque nœud exécute le même bytecode pour valider les transactions et maintenir la synchronisation de l'état global de la blockchain.

Lors de la compilation d'un contrat Solidity, vous obtenez le bytecode et l'ABI . Le bytecode est la représentation binaire exécutable par la machine virtuelle Elasticsearch (EVM) ; l'ABI (Application Binary Interface) décrit les fonctions, les paramètres et les types accessibles depuis l'extérieur. Toute application décentralisée (DApp) ou tout script souhaitant communiquer avec votre contrat a besoin de cette ABI et de l'adresse du contrat.

Il existe également d'autres langages et interfaces . Bien que Solidity soit la norme de facto, il existe des implémentations et des liaisons issues de langages comme Java ou Python , ainsi que des langages alternatifs comme Vyper, qui privilégie une syntaxe plus simple et des restrictions conçues pour prévenir les erreurs et les vulnérabilités.

Outils de base pour le développement de contrats intelligents

Pour débuter avec Ethereum, vous aurez besoin d'une petite boîte à outils qui vous fournira tout ce dont vous avez besoin pour écrire, tester et déployer des contrats intelligents sans vous compliquer la vie avec l'infrastructure.

Node.js et npm constituent la base de la gestion des dépendances et de l'exécution des scripts de développement. À partir de là, divers frameworks et bibliothèques prennent en charge l'ensemble du flux de travail : compilation, migrations, tests et déploiement.

Suite Truffe Il s'agit de l'un des plus anciens frameworks pour le développement de contrats intelligents. Grâce à lui, vous pouvez créer un projet avec truffle initOrganisez vos contrats dans le dossier contractsIl permet de définir des scripts de migration et d'exécuter des tests automatisés. Il s'intègre également parfaitement à Ganache.

Ganache est une blockchain locale de test . Elle émule un réseau Ethereum sur votre propre machine, en générant plusieurs comptes avec de l'Ether « fictif » afin que vous puissiez déployer des contrats, effectuer des transactions et déboguer sans dépenser un centime ni attendre de vrais mineurs.

MetaMask sert de pont entre votre navigateur et la blockchain . Ce portefeuille s'intègre comme une extension de navigateur et vous permet de connecter des DApps, de signer des transactions, de basculer entre les réseaux (testnets, mainnet, sidechains) et de gérer vos comptes très facilement.

Remix IDE : l’environnement le plus simple pour débuter

Si vous débutez, Remix est probablement le moyen le plus rapide de concrétiser votre premier contrat.Remix est un IDE basé sur un navigateur, accessible directement depuis https://remix.ethereum.org ou déployable sur votre propre serveur, ce qui inclut un éditeur, un compilateur, des outils de déploiement et un panneau d'interaction.

L'interface de Remix est organisée en plusieurs onglets principaux.L'explorateur de fichiers, le compilateur Solidity et le panneau « Déployer et exécuter des transactions ». Depuis l'explorateur, vous pouvez créer des fichiers tels que : FirstContract.sol o HelloWorld.sol dans un répertoire de contrats.

Dans l'onglet « Compilateur Solidity », vous choisissez la version du compilateur. (doit être égal ou supérieur à celui spécifié dans la directive) pragma solidity (à partir de votre contrat) et lancez la compilation avec le bouton « Compiler… ». Si tout est correct, une coche verte apparaîtra à côté du contrat.

Après compilation, Remix génère des artefacts tels que du JSON contenant du bytecode et une ABI.Dans le panneau des fichiers, vous pourriez voir quelque chose comme FirstContract.jsonqui contient des domaines très importants tels que bytecode et de l' abiCes données vous serviront ultérieurement dans des bibliothèques comme Web3.js ou Web3.py pour déployer le contrat et interagir avec lui depuis votre backend ou des scripts externes.

Dans l'onglet « Déployer et exécuter des transactions », vous choisissez l'environnement d'exécution pour le déploiement du contrat. Plusieurs options entrent en jeu ; il est donc important de bien les comprendre avant d'intervenir sur le réseau en production.

Environnements d'exécution remixés : des réseaux locaux aux réseaux publics

Le module « Environnement » de Remix contrôle la destination des transactions et l'emplacement précis du déploiement de votre contrat intelligent. L'exécution de tests rapides en mémoire est différente du déploiement sur le réseau principal.

Les machines virtuelles JavaScript (comme London) sont des environnements entièrement locaux et en mémoire. Remix crée plusieurs comptes de test avec 100 ETH, génère des blocs à la volée et supprime tout si vous rechargez la page. C'est idéal pour apprendre, tester la logique et faire des erreurs sans conséquences.

Injected Web3 utilise le fournisseur qui injecte le protocole dans votre navigateur , généralement MetaMask. Cela signifie que les transactions transiteront par le réseau que vous avez sélectionné dans votre portefeuille : il peut s’agir d’un réseau de test comme Sepolia, d’un réseau principal comme Ethereum Mainnet ou d’une chaîne latérale comme Polygon.

Le fournisseur Web3 vous permet de vous connecter directement à un nœud distant. en spécifiant son URL HTTP, par exemple un nœud privé exécuté sur votre propre infrastructure (http://192.168.41.88:8041ou un point de terminaison proposé par un fournisseur tiers. Remix envoie les transactions à ce nœud via Web3.

Une fois l'environnement choisi, sélectionnez le compte à partir duquel le contrat sera déployé . Sur les machines virtuelles locales, une liste d'adresses avec un solde simulé s'affiche ; avec MetaMask ou un nœud distant, il s'agira du compte configuré par ce fournisseur. Le déploiement consomme toujours du « gas », même si ce coût n'est pas réel sur site.

Ensuite, sélectionnez le contrat dans le menu déroulant « Contrat » et cliquez sur « Déployer » . Si le générateur de contrats reçoit des paramètres (par exemple, l’adresse du propriétaire ou un message initial), Remix affichera des champs à renseigner avant d’envoyer la transaction de déploiement.

Exemple pratique : contrats simples en Solidity

Pour bien comprendre le fonctionnement, il est utile de commencer par un contrat simple qui permet de stocker et de récupérer une valeur, ou de mettre à jour un message. C'est l'équivalent, dans le monde de la blockchain, du classique « Hello World ».

Un exemple moderne pourrait être un contrat HelloWorld avec une variable d'état messageun constructeur pour l'initialiser et une fonction pour le mettre à jour. Le tout avec une version récente de Solidity (^0.8.0) et de bonnes pratiques de visibilité.

Un autre exemple plus élaboré est le contrat. FirstContractqui introduit des variables telles que owner, ownerName, ownerAge et une liste de posts (par exemple, les URL). De plus, il définit des modificateurs d'accès personnalisés tels que onlyOwner, existsUrl y notExistsUrl centraliser les contrôles d'autorisation et la cohérence des données.

Ces modificateurs d'accès personnalisés vous permettent d'éviter de répéter la même logique. et ce, à chaque représentation. Par exemple, onlyOwner vérifier auprès de require(msg.sender == owner) que le compte exécutant la fonction est le propriétaire du contrat, et le symbole _; indique le point auquel l'exécution se poursuivra si la condition est remplie.

Les fonctions de lecture sont généralement accompagnées du modificateur viewce qui indique qu'elles ne modifient pas l'état du contrat. Cela signifie qu'elles peuvent être exécutées comme un « appel » sans frais de gaz pour l'utilisateur, puisqu'elles n'écrivent rien sur la blockchain. Plus précisément, pure indique que la fonction ne lit ni n'écrit d'état.

Tester les contrats localement et comprendre le gaz

Lorsque vous déployez un contrat dans la machine virtuelle JavaScript Remix , l'IDE crée une transaction qui consomme du gaz simulé. Ce gaz n'est pas facturé, mais il vous permet de comprendre que, dans un environnement réel, tout déploiement et toute fonction modifiant l'état ont un coût.

Une fois déployé, le solde du compte émetteur passera de 100 ETH à 99,x ETH sur la machine virtuelle locale. Cela correspond au coût du stockage du bytecode du contrat et de l'exécution du constructeur sur la blockchain. Sur un réseau de test ou le réseau principal, ces frais seront déduits du solde de votre portefeuille réel.

Les termes « gas », « frais », « wei » et « ether » sont essentiels . Le gas mesure la puissance de calcul nécessaire à l'exécution d'une opération ; son prix (en gwei, fraction d'ether) correspond à ce que vous êtes prêt à payer pour chaque unité de gas. Les frais totaux sont le produit du gas utilisé par son prix. Les soldes des comptes sont gérés en interne en wei (10^18 wei = 1 ETH).

Dans Remix, après l'ouverture du contrat, un panneau affichant tous les éléments interactifs apparaît.Les boutons orange correspondent aux fonctions qui envoient des transactions (écritures), et les boutons bleus aux fonctions en lecture seule. Vous pouvez saisir des données dans les champs correspondants et appeler des fonctions telles que… addPostUrl o setOwnerState et observez comment l'état change.

Si vous changez de compte dans le panneau « Compte » de Remix, vous remarquerez que les autorisations changent.Les fonctions protégées avec onlyOwner Elles échoueront si elles sont exécutées par un compte autre que celui du propriétaire actuel du contrat, ce qui vous permettra de vérifier que les modificateurs d'accès fonctionnent correctement.

Déploiement sur les réseaux de test publics : Sepolia, Rinkeby et compagnie

Une fois le réseau local maîtrisé, l'étape suivante consiste à passer à un réseau de test . Historiquement, Rinkeby a été utilisé, mais aujourd'hui, des réseaux comme Sepolia ou Goerli sont bien plus répandus. Le principe reste le même : reproduire le comportement du réseau principal avec de l'Ether de test obtenu gratuitement via des faucets.

Pour déployer des données depuis Remix sur un réseau de test, utilisez simplement « Web3 injecté » comme environnement et configurez votre portefeuille (MetaMask, par exemple) sur le réseau de test souhaité. Lorsque vous cliquez sur « Déployer », MetaMask affiche la transaction, le coût estimé du gaz et vous demande une confirmation.

Une fois la transaction validée, le contrat obtient sa propre adresse (compte de contrat) sur le réseau de test. Vous pouvez la copier depuis Remix ou depuis la fenêtre de confirmation de votre portefeuille et la coller dans l'explorateur de blocs correspondant (par exemple, Sepolia Etherscan).

Dans le navigateur, vous verrez le compte du contrat, son bytecode et les transactions associées . Au départ, seule la transaction de création apparaîtra, puis vous verrez les appels de lecture et d'écriture effectués par les utilisateurs ou les DApps qui interagissent avec ce contrat.

De nombreux navigateurs permettent même d'interagir directement avec le contrat depuis les onglets « Lire le contrat » et « Écrire le contrat », une fois le code source vérifié et publié, ce qui est très pratique pour effectuer des tests rapides sans avoir encore configuré sa propre interface web.

Vérifiez et publiez le code du contrat sur Etherscan.

La vérification d'un contrat sur Etherscan (ou un explorateur équivalent) est une étape essentielle de transparence . Elle consiste à télécharger le code source, à spécifier la version du compilateur et les options utilisées, afin que l'explorateur puisse recompiler et vérifier que le bytecode correspond au code déployé.

Le processus typique dans un réseau comme Sepolia est le suivantVous vous rendez sur la page de l'adresse du contrat, cliquez sur le lien « Vérifier et publier », saisissez l'adresse, sélectionnez le compilateur Solidity spécifique, indiquez la licence et, sur l'écran suivant, collez le contenu de votre fichier. .sol.

Après avoir validé le captcha et soumis le formulaire, l'explorateur recompile le code et compare le résultat avec le bytecode stocké sur la blockchain. En cas de correspondance, le contrat est validé par une coche verte à côté du bouton « Contrat ».

À partir de ce moment, l'explorateur affiche le code source, l'ABI et une interface graphique permettant d'exécuter les fonctions de lecture (« Read Contract ») et d'écriture (« Write Contract »), en utilisant votre portefeuille pour signer les transactions si nécessaire. C'est un moyen très pratique pour quiconque d'auditer ou de tester le contrat.

Un exemple typique est le contrat Register01.sol dans un réseau de testqui vous permet de stocker du texte dans une variable storedInfo avec fonction setInfo et le récupérer avec getInfoVous pouvez écrire « Hello World » dans « Écrire le contrat » puis vérifier la valeur dans « Lire le contrat ».

Interaction avec les DApps et les scripts : Web3.js, Node.js et bases de données

Au-delà de Remix et des navigateurs, la véritable vie d'un contrat intelligent commence lorsqu'une application décentralisée (DApp) l'utilise . Une DApp se compose généralement de trois éléments de base : le contrat lui-même, un serveur (par exemple, en Node.js) et une base de données auxiliaire, telle que MongoDB, pour mettre en cache les lectures et améliorer les performances.

Côté serveur, on utilise généralement Web3.js (en Node.js) ou Web3.py (en Python) pour se connecter à un nœud Ethereum (public, privé ou géré) via un point de terminaison HTTP ou WebSocket. Pour cela, vous aurez besoin de l'URL du nœud, de l'adresse du contrat et de son ABI.

Un script Node typique pourrait créer une instance Web3 avec new Web3(new Web3.providers.HttpProvider("http://localhost:8042")), analyser l'ABI avec JSON.parse et utiliser web3.eth.contract(interface) combiné avec .at("0xDirecciónDelContrato") obtenir une référence au contrat déployé.

Pour envoyer des transactions depuis le backend, vous devez déverrouiller le compte. qui signera ces transactions, soit avec web3.personal.unlockAccount si votre nœud le permet, ou en signant les transactions localement avec la clé privée (beaucoup plus délicat en termes de sécurité et de conservation).

En production, une couche de sécurité supplémentaire est presque toujours ajoutée : coffres-forts pour stocker les clés privées, politiques d’accès strictes, séparation entre le front-end et le back-end, et utilisation de fournisseurs tels que MetaMask, Infura ou des nœuds gérés, afin d’éviter d’exposer directement l’infrastructure critique.

Nœuds gérés et déploiements avancés avec AWS Managed Blockchain

À mesure qu'un projet se développe, il devient judicieux de s'appuyer sur une infrastructure gérée pour les nœuds Ethereum. Amazon Managed Blockchain en est un exemple : cette solution permet de déployer des nœuds Ethereum (sur le réseau principal, par exemple) sans avoir à se soucier de l'installation, de la synchronisation et de la maintenance du logiciel associé.

Depuis la console AWS, vous pouvez rejoindre le réseau public Ethereum , choisir le réseau (par exemple, Ethereum Mainnet), le type d'instance, la zone de disponibilité et créer un ou plusieurs nœuds pour une haute disponibilité. Après quelques minutes, le nœud passera à l'état « Disponible ».

L'accès à ces nœuds peut se faire via des signatures Sigv4 ou des jetons . L'accès par jeton simplifie considérablement l'intégration avec les outils standard de l'écosystème Ethereum (Ethers.js, Hardhat, MetaMask, The Graph, Chainlink, etc.), qui nécessitent un point de terminaison RPC direct sans aucune connaissance d'AWS.

Un point de terminaison HTTP typique a une forme comme celle-ci https://id-del-nodo.t.ethereum.managedblockchain.us-east-1.amazonaws.com/<ruta>?billingtoken=tokenGrâce à ce point de terminaison, vous pouvez créer une instance Web3 en Python, par exemple, et appeler des méthodes comme w3.is_connected() o w3.eth.syncing pour vérifier si le nœud est synchronisé.

Une fois la connexion vérifiée, vous pouvez effectuer des lectures telles que : w3.eth.get_block("latest") pour obtenir le mineur du dernier bloc, ou w3.eth.get_balance(address) pour vérifier le solde d'un compte (exprimé en wei et convertible en ether avec Web3.from_wei).

Gestion des comptes, clés et déploiement à partir du code

Le déploiement de contrats à partir de code implique la manipulation de clés privées.En Python, par exemple, vous pouvez générer une nouvelle clé privée à l'aide de la bibliothèque secrets, créez un compte avec w3.eth.account.from_key(private_key) et obtenir son adresse publique.

Cette adresse présente un solde initial nul et vous devrez la financer. Vous pouvez acheter de l'ETH via un portefeuille ou recevoir des fonds d'un autre. Tant que le nœud que vous utilisez n'est pas entièrement synchronisé, votre solde peut ne pas refléter les nouveaux fonds. Il est donc conseillé de vérifier régulièrement. w3.eth.syncing.

Pour déployer un contrat depuis Web3.py, vous avez besoin du bytecode et de l'ABI.Si vous avez écrit le contrat en Vyper, par exemple, vous pouvez le compiler avec vyper safe-remote-purchase.vy > bytecode.bin y vyper -f abi safe-remote-purchase.vy > abi.json, puis lisez les deux fichiers depuis votre script.

Avec ces données, vous créez l'objet contrat avec w3.eth.contract(abi=abi, bytecode=bytecode)Vous pouvez vérifier le prix actuel du gaz avec w3.eth.gas_priceet vous préparez la transaction de déploiement avec .constructor().build_transaction({...}) indiquant des champs tels que from, nonce, gas et éventuellement value si le constructeur a besoin d'un réservoir de stockage.

La transaction est signée avec la clé privée et envoyée avec w3.eth.send_raw_transactionEnsuite, vous attendez le reçu avec w3.eth.wait_for_transaction_receiptSi l'opération est réussie, le reçu contiendra l'adresse du contrat affichée dans contractAddress.

Exemple avancé : Achats à distance sécurisés avec Vyper

Un cas plus complexe et très révélateur est celui du contrat de « paiement à distance sécurisé » , documenté dans les exemples Vyper. Son objectif est de réglementer une vente entre un vendeur et un acheteur, les dépôts garantissant la bonne conduite des deux parties.

Le processus se déroule généralement comme suit : le vendeur initie le contrat en versant un acompte équivalent à deux fois la valeur du produit ; tant que personne n’a acheté l’article, il peut annuler et se faire rembourser. Lorsque l’acheteur décide d’acquérir l’article, il verse le prix de l’article majoré d’un acompte équivalent (deux fois le prix).

Lorsque l'acheteur reçoit le produit, il appelle la fonction correspondante. (par exemple receivedIl en résulte qu'une partie de l'acompte est restituée au vendeur, qui récupère alors à la fois le prix du produit et son acompte initial. De cette manière, les intérêts économiques des deux parties convergent.

Après avoir établi le contrat avec Vyper, vous obtenez son bytecode y ABIque vous utiliserez avec Web3 pour le déployer. Une fois déployé, vous pourrez obtenir une instance avec w3.eth.contract(address=contractAddress, abi=abi) et invoquer des méthodes telles que abort(), purchase() o received() à partir des comptes concernés (vendeur ou acheteur).

Ce type d'exemple illustre comment les contrats intelligents permettent d'automatiser des accords complexes qui, dans les systèmes traditionnels, nécessiteraient un tiers de confiance, un service de séquestre ou des contrats juridiques. Dans la blockchain, la logique de l'accord est intégrée au code lui-même, auditée et exécutée par tous les nœuds.

Grâce à ces informations, vous disposez désormais d'une vue d'ensemble complète du cycle de vie d'un contrat intelligent : de la théorie de base expliquant ce qu'est un contrat intelligent et comment il fonctionne sur la machine virtuelle Ethereum (EVM), en passant par la programmation en Solidity ou Vyper, les tests avec Remix et Ganache, le déploiement sur les réseaux de test et le réseau principal, la vérification avec Etherscan, l'interaction avec les applications décentralisées (DApps) et l'exploitation avec des nœuds gérés dans le cloud. L'étape suivante consiste naturellement à approfondir les modèles avancés (proxies, mise à niveau, héritage, sécurité) et à explorer des cas d'utilisation tels que les NFT, la finance décentralisée (DeFi) et la gouvernance on-chain, en tirant parti du vaste écosystème construit autour d'Ethereum.