Contrat intelligent Hello World pour les débutants

Solidity

Hardhat

Alchemy

contrats intelligents

déploiement

Débutant

elanh

31 mars 2021

14 minutes de lecture

Si vous débutez dans le développement sur chaîne de blocs et que vous ne savez pas par où commencer, ou si vous voulez simplement comprendre comment déployer et interagir avec des contrats intelligents, ce guide est fait pour vous. Nous allons vous guider dans la création et le déploiement d'un contrat intelligent simple sur le réseau de test Sepolia à l'aide d'un portefeuille virtuel MetaMask (s'ouvre dans un nouvel onglet), de Solidity (s'ouvre dans un nouvel onglet), de Hardhat (s'ouvre dans un nouvel onglet) et d'Alchemy (s'ouvre dans un nouvel onglet) (ne vous inquiétez pas si vous ne comprenez pas encore ce que tout cela signifie, nous vous l'expliquerons).

Une fois votre contrat déployé, vous pourrez créer une interface utilisateur pour celui-ci.

Si vous avez des questions à un moment donné, n'hésitez pas à nous contacter sur le Discord d'Alchemy (s'ouvre dans un nouvel onglet) !

Étape 1 : Se connecter au réseau Ethereum

Il existe de nombreuses façons d'effectuer des requêtes sur la chaîne Ethereum. Pour faire simple, nous utiliserons un compte gratuit sur Alchemy, une plateforme de développement de chaîne de blocs et une API qui nous permet de communiquer avec la chaîne Ethereum sans avoir à exécuter nos propres nœuds. La plateforme dispose également d'outils de développement pour la surveillance et l'analyse dont nous tirerons parti dans ce tutoriel pour comprendre ce qui se passe en interne lors du déploiement de notre contrat intelligent. Si vous n'avez pas encore de compte Alchemy, vous pouvez vous inscrire gratuitement ici (s'ouvre dans un nouvel onglet).

Étape 2 : Créer votre application (et votre clé API)

Une fois que vous avez créé un compte Alchemy, vous pouvez générer une clé API en créant une application. Cela nous permettra d'effectuer des requêtes sur le réseau de test Sepolia. Si vous n'êtes pas familier avec les réseaux de test, consultez cette page.

Accédez à la page « Create new app » (Créer une nouvelle application) dans votre tableau de bord Alchemy en sélectionnant « Select an app » (Sélectionner une application) dans la barre de navigation et en cliquant sur « Create new app »

Nommez votre application « Hello World », proposez une brève description et choisissez un cas d'utilisation, par exemple « Infra & Tooling ». Ensuite, recherchez « Ethereum » et sélectionnez le réseau.

Cliquez sur « Next » (Suivant) pour continuer, puis sur « Create app » (Créer l'application) et c'est tout ! Votre application devrait apparaître dans le menu déroulant de la barre de navigation, avec une clé API disponible à copier.

Étape 3 : Créer un compte Ethereum (adresse)

Nous avons besoin d'un compte Ethereum pour envoyer et recevoir des transactions. Pour ce tutoriel, nous utiliserons MetaMask, un portefeuille virtuel dans le navigateur utilisé pour gérer l'adresse de votre compte Ethereum. Pour en savoir plus sur les transactions.

Vous pouvez télécharger MetaMask et créer un compte Ethereum gratuitement ici (s'ouvre dans un nouvel onglet). Lors de la création d'un compte, ou si vous en avez déjà un, assurez-vous de passer sur le réseau de test « Sepolia » à l'aide du menu déroulant des réseaux (afin de ne pas manipuler d'argent réel).

Si vous ne voyez pas Sepolia dans la liste, ouvrez le menu dans le coin supérieur droit, sélectionnez « Networks » (Réseaux) et activez « Show test networks » (Afficher les réseaux de test) au bas de la liste des réseaux (voir le guide de MetaMask pour afficher les réseaux de test (s'ouvre dans un nouvel onglet)). Sélectionnez ensuite « Sepolia » dans le menu de sélection du réseau.

Étape 4 : Ajouter de l'ether à partir d'un faucet

Afin de déployer notre contrat intelligent sur le réseau de test, nous aurons besoin de faux ETH. Pour obtenir des ETH Sepolia, vous pouvez consulter les détails du réseau Sepolia pour voir une liste de différents faucets. Si l'un d'eux ne fonctionne pas, essayez-en un autre, car ils peuvent parfois être à sec. Certains faucets ont des règles d'éligibilité ; par exemple, le faucet Sepolia d'Alchemy exige que l'adresse de réception détienne au moins 0,001 ETH sur le réseau principal Ethereum. La réception de vos faux ETH peut prendre un certain temps en raison du trafic sur le réseau. Vous devriez voir des ETH dans votre compte MetaMask peu de temps après !

Étape 5 : Vérifier votre solde

Pour vérifier que notre solde est bien là, effectuons une requête eth_getBalance à l'aide de l'outil Composer d'Alchemy (s'ouvre dans un nouvel onglet). Cela renverra le montant d'ETH dans notre portefeuille. Après avoir saisi l'adresse de votre compte MetaMask et cliqué sur « Send Request » (Envoyer la requête), vous devriez voir une réponse comme celle-ci :

{ "jsonrpc": "2.0", "id": 0, "result": "0x2B5E3AF16B1880000" }

REMARQUE : Ce résultat est en Wei et non en ETH. Le Wei est utilisé comme la plus petite dénomination de l'ether. La conversion du Wei en ETH est la suivante : 1 eth = 10¹⁸ Wei. Donc, si nous convertissons 0x2B5E3AF16B1880000 en décimal, nous obtenons 5*10¹⁸, ce qui équivaut à 5 ETH.

Ouf ! Notre faux argent est bien là .

Étape 6 : Initialiser notre projet

Tout d'abord, nous devrons créer un dossier pour notre projet. Accédez à votre ligne de commande et tapez :

mkdir hello-world
cd hello-world

Maintenant que nous sommes dans le dossier de notre projet, nous allons utiliser npm init pour initialiser le projet. Si npm n'est pas encore installé, suivez les instructions d'installation de Node.js (s'ouvre dans un nouvel onglet) (nous aurons besoin de Node.js et de npm pour ce tutoriel).

npm init

La façon dont vous répondez aux questions d'installation n'a pas vraiment d'importance, voici comment nous avons procédé à titre de référence :

package name: (hello-world)
version: (1.0.0)
description: hello world smart contract
entry point: (index.js)
test command:
git repository:
keywords:
author:
license: (ISC)
About to write to /Users/.../.../.../hello-world/package.json:

{
  "name": "hello-world",
  "version": "1.0.0",
  "description": "hello world smart contract",
  "main": "index.js",
  "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1"
  },
  "author": "",
  "license": "ISC"
}

Approuvez le fichier package.json. Hardhat 3, que nous installerons ensuite, ne prend en charge que les projets de modules ES, alors marquez le projet comme tel :

npm pkg set type=module

Et nous sommes prêts à commencer !

Étape 7 : Télécharger Hardhat (s'ouvre dans un nouvel onglet)

Hardhat est un environnement de développement pour compiler, déployer, tester et déboguer vos logiciels Ethereum. Il aide les développeurs lors de la création de contrats intelligents et d'applications décentralisées (dapps) localement avant de les déployer sur la chaîne en direct.

Hardhat 3 nécessite Node.js v22.13.0 ou une version ultérieure. Dans notre projet hello-world, exécutez :

npm install --save-dev hardhat

Consultez cette page pour plus de détails sur les instructions d'installation (s'ouvre dans un nouvel onglet).

Étape 8 : Créer un projet Hardhat

L'exécution de npx hardhat --init générerait un exemple de projet complet, mais pour ce tutoriel, nous allons tout configurer manuellement afin que vous puissiez voir chaque élément. À la racine du dossier de votre projet, créez un fichier appelé hardhat.config.js avec le contenu suivant :

import { defineConfig } from "hardhat/config"

export default defineConfig({
  solidity: "0.8.34",
})

C'est ici que nous spécifierons toute la configuration de notre projet (à l'étape 13). Pour l'instant, cela indique simplement à Hardhat quelle version du compilateur Solidity utiliser.

Étape 9 : Ajouter les dossiers du projet

Pour garder notre projet organisé, nous allons créer deux nouveaux dossiers. Accédez au répertoire racine de votre projet dans votre ligne de commande et tapez :

mkdir contracts
mkdir scripts

contracts/ est l'endroit où nous conserverons le fichier de code de notre contrat intelligent Hello World
scripts/ est l'endroit où nous conserverons les scripts pour déployer et interagir avec notre contrat

Étape 10 : Écrire notre contrat

Vous vous demandez peut-être quand diable allons-nous écrire du code ?? Eh bien, nous y sommes, à l'étape 10.

Ouvrez le projet hello-world dans votre éditeur préféré (nous aimons VSCode (s'ouvre dans un nouvel onglet)). Les contrats intelligents sont écrits dans un langage appelé Solidity, que nous utiliserons pour écrire notre contrat intelligent HelloWorld.sol.‌

Accédez au dossier « contracts » et créez un nouveau fichier appelé HelloWorld.sol
Vous trouverez ci-dessous un exemple de contrat intelligent Hello World de la Fondation Ethereum que nous utiliserons pour ce tutoriel. Copiez et collez le contenu ci-dessous dans votre fichier HelloWorld.sol, et assurez-vous de lire les commentaires pour comprendre ce que fait ce contrat :

// SPDX-License-Identifier: MIT
// Spécifie la version de Solidity, en utilisant le versionnage sémantique.
// En savoir plus : https://docs.soliditylang.org/en/latest/layout-of-source-files.html#pragma
pragma solidity ^0.8.24;

// Définit un contrat nommé `HelloWorld`.
// Un contrat est une collection de fonctions et de données (son état). Une fois déployé, un contrat réside à une adresse spécifique sur la chaîne de blocs Ethereum. En savoir plus : https://docs.soliditylang.org/en/latest/structure-of-a-contract.html
contract HelloWorld {

   // Déclare une variable d'état `message` de type `string`.
   // Les variables d'état sont des variables dont les valeurs sont stockées de façon permanente dans le stockage du contrat. Le mot-clé `public` rend les variables accessibles depuis l'extérieur d'un contrat et crée une fonction que d'autres contrats ou clients peuvent appeler pour accéder à la valeur.
   string public message;

   // Similaire à de nombreux langages orientés objet basés sur des classes, un constructeur est une fonction spéciale qui n'est exécutée que lors de la création du contrat.
   // Les constructeurs sont utilisés pour initialiser les données du contrat. En savoir plus : https://docs.soliditylang.org/en/latest/contracts.html#constructors
   constructor(string memory initMessage) {

      // Accepte un argument de type chaîne de caractères `initMessage` et définit la valeur dans la variable de stockage `message` du contrat).
      message = initMessage;
   }

   // Une fonction publique qui accepte un argument de type chaîne de caractères et met à jour la variable de stockage `message`.
   function update(string memory newMessage) public {
      message = newMessage;
   }
}

Il s'agit d'un contrat intelligent très simple qui stocke un message lors de sa création et qui peut être mis à jour en appelant la fonction update.

Étape 11 : Connecter MetaMask et Alchemy à votre projet

Nous avons créé un portefeuille MetaMask, un compte Alchemy et écrit notre contrat intelligent, il est maintenant temps de connecter les trois.

Chaque transaction envoyée depuis votre portefeuille virtuel nécessite une signature à l'aide de votre clé privée unique. Pour fournir cette autorisation à notre programme, nous pouvons stocker en toute sécurité notre clé privée (et la clé API Alchemy) dans un fichier d'environnement.

Pour en savoir plus sur l'envoi de transactions, consultez la documentation sur les transactions.

Créez un fichier .env dans le répertoire racine de notre projet, et ajoutez-y votre clé privée MetaMask et l'URL de l'API HTTP Alchemy.

Suivez ces instructions (s'ouvre dans un nouvel onglet) pour exporter votre clé privée
Voir ci-dessous pour obtenir l'URL de l'API HTTP Alchemy

Copiez l'URL de l'API Alchemy

Votre fichier .env devrait ressembler à ceci :

API_URL="https://eth-sepolia.g.alchemy.com/v2/your-api-key"
PRIVATE_KEY="your-metamask-private-key"

Pour les connecter réellement à notre code, nous ferons référence à ces variables dans notre fichier hardhat.config.js à l'étape 13. Node.js peut lire les fichiers .env par lui-même, il n'y a donc pas de paquet supplémentaire à installer.

Ne commitez pas .env ! Assurez-vous de ne jamais partager ou exposer votre fichier .env avec qui que ce soit, car vous compromettriez vos secrets en le faisant. Si vous utilisez un système de contrôle de version, ajoutez votre .env à un fichier gitignore.

Étape 12 : Installer Ethers.js

Ethers.js est une bibliothèque qui facilite l'interaction et l'envoi de requêtes à Ethereum en enveloppant les méthodes JSON-RPC standard avec des méthodes plus conviviales.

Hardhat facilite grandement l'intégration de plugins (s'ouvre dans un nouvel onglet) pour des outils supplémentaires et des fonctionnalités étendues. Nous tirerons parti du plugin Ethers (s'ouvre dans un nouvel onglet) pour le déploiement de contrats (Ethers.js (s'ouvre dans un nouvel onglet) dispose de méthodes de déploiement de contrats très propres).

Dans le répertoire de votre projet, tapez :

npm install --save-dev @nomicfoundation/hardhat-ethers ethers

Nous ajouterons également le plugin à notre fichier hardhat.config.js à l'étape suivante.

Étape 13 : Mettre à jour hardhat.config.js

Nous avons ajouté plusieurs dépendances et plugins jusqu'à présent, nous devons maintenant mettre à jour hardhat.config.js afin que notre projet les connaisse tous.

Mettez à jour votre fichier hardhat.config.js pour qu'il ressemble à ceci :

import { existsSync } from "node:fs"
import hardhatEthers from "@nomicfoundation/hardhat-ethers"
import { configVariable, defineConfig } from "hardhat/config"

// Charge API_URL et PRIVATE_KEY depuis le fichier .env dans process.env, s'il existe
if (existsSync(".env")) process.loadEnvFile()

export default defineConfig({
  plugins: [hardhatEthers],
  solidity: "0.8.34",
  networks: {
    sepolia: {
      type: "http",
      url: configVariable("API_URL"),
      accounts: [configVariable("PRIVATE_KEY")],
    },
  },
})

configVariable indique à Hardhat de lire chaque valeur à partir d'une variable d'environnement uniquement lorsque cela est nécessaire, de sorte que des commandes comme compile fonctionnent même avant que les valeurs ne soient définies. Si vous préférez ne pas conserver votre clé privée dans un fichier texte brut, Hardhat peut également lire les variables de configuration à partir d'un magasin de clés chiffré (s'ouvre dans un nouvel onglet).

Étape 14 : Compiler notre contrat

Pour nous assurer que tout fonctionne jusqu'à présent, compilons notre contrat. La tâche compile est l'une des tâches intégrées de Hardhat.

À partir de la ligne de commande, exécutez :

npx hardhat compile

La première fois que vous compilez, Hardhat télécharge le compilateur Solidity. Vous devriez ensuite voir quelque chose comme Compiled 1 Solidity file with solc 0.8.34. Si ce n'est pas le cas, vous pouvez toujours envoyer un message sur le Discord d'Alchemy (s'ouvre dans un nouvel onglet).

Étape 15 : Écrire notre script de déploiement

Maintenant que notre contrat est écrit et que notre fichier de configuration est prêt, il est temps d'écrire notre script de déploiement de contrat.

Accédez au dossier scripts/ et créez un nouveau fichier appelé deploy.js, en y ajoutant le contenu suivant :

import { network } from "hardhat"

const { ethers } = await network.create()

const HelloWorld = await ethers.getContractFactory("HelloWorld")

// Démarre le déploiement, en renvoyant une promesse qui se résout en un objet contrat
const hello_world = await HelloWorld.deploy("Hello World!")
await hello_world.waitForDeployment()
console.log("Contract deployed to address:", await hello_world.getAddress())

Passons en revue ce que fait chacune de ces lignes de code.

const { ethers } = await network.create()

Dans Hardhat 3, un script ouvre explicitement une connexion à un réseau. network.create() se connecte au réseau que vous choisissez avec l'option --network lorsque vous exécutez le script, et le plugin hardhat-ethers ajoute un objet ethers à cette connexion.

const HelloWorld = await ethers.getContractFactory("HelloWorld")

Une ContractFactory dans Ethers.js est une abstraction utilisée pour déployer de nouveaux contrats intelligents, donc HelloWorld ici est une fabrique pour les instances de notre contrat hello world. Lors de l'utilisation du plugin hardhat-ethers, les instances ContractFactory et Contract sont connectées au premier signataire par défaut.

const hello_world = await HelloWorld.deploy("Hello World!")

L'appel de deploy() sur une ContractFactory démarrera le déploiement et renverra une Promise qui se résout en un Contract. C'est l'objet qui possède une méthode pour chacune des fonctions de notre contrat intelligent. Les arguments que vous passez à deploy() vont au constructeur du contrat, ici le message initial.

waitForDeployment() attend que la transaction de déploiement soit incluse dans un bloc, et getAddress() renvoie l'adresse du nouveau contrat. Consultez la documentation sur les contrats d'Ethers.js (s'ouvre dans un nouvel onglet) pour plus de détails.

Étape 16 : Déployer notre contrat

Nous sommes enfin prêts à déployer notre contrat intelligent ! Accédez à la ligne de commande et exécutez :

npx hardhat run scripts/deploy.js --network sepolia

Vous devriez ensuite voir quelque chose comme :

Contract deployed to address: 0x6cd7d44516a20882cEa2DE9f205bF401c0d23570

Si nous allons sur Etherscan Sepolia (s'ouvre dans un nouvel onglet) et recherchons l'adresse de notre contrat, nous devrions pouvoir voir qu'il a été déployé avec succès. La transaction ressemblera à ceci :

L'adresse From (De) doit correspondre à l'adresse de votre compte MetaMask et l'adresse To (À) indiquera « Contract Creation » (Création de contrat), mais si nous cliquons sur la transaction, nous verrons l'adresse de notre contrat dans le champ To :

Félicitations ! Vous venez de déployer un contrat intelligent sur la chaîne Ethereum 🎉

Pour comprendre comment ça fonctionne techniquement, vous pouvez consulter les requêtes que votre application « Hello World » a reçues dans votre tableau de bord Alchemy (s'ouvre dans un nouvel onglet).

Vous y verrez une poignée d'appels JSON-RPC que Hardhat/Ethers a effectués en interne pour nous lorsque nous avons appelé la fonction .deploy(). Deux appels importants à souligner ici sont eth_sendRawTransaction, qui est la requête pour écrire réellement notre contrat sur la chaîne Sepolia, et eth_getTransactionByHash qui est une requête pour lire des informations sur notre transaction à partir du hash (un modèle typique lors de l'envoi de transactions). Pour en savoir plus sur l'envoi de transactions, consultez la documentation sur les transactions.

C'est tout pour ce tutoriel. Ensuite, vous pouvez créer une interface utilisateur pour votre contrat.