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 la 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 (opens in a new tab), de Solidity (opens in a new tab), de Hardhat (opens in a new tab) et d'Alchemy (opens in a new tab) (ne vous inquiétez pas si vous ne comprenez pas encore ce que tout cela signifie, nous vous l'expliquerons).

Dans la partie 2 de ce tutoriel, nous verrons comment interagir avec notre contrat intelligent une fois qu'il sera déployé ici, et dans la partie 3, nous verrons comment le publier sur Etherscan.

Si vous avez des questions à un moment donné, n'hésitez pas à nous contacter sur le Discord d'Alchemy (opens in a new tab) !

É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 (opens in a new tab).

É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 (opens in a new tab). Lors de la création d'un compte, ou si vous en avez déjà un, assurez-vous de basculer 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, allez dans le menu, puis dans Paramètres avancés (Advanced) et faites défiler vers le bas pour activer « Afficher les réseaux de test » (Show test networks). Dans le menu de sélection du réseau, choisissez l'onglet « Personnalisé » (Custom) pour trouver une liste de réseaux de test et sélectionnez « Sepolia ».

Étape 4 : Ajouter de l'ether depuis 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 vous rendre sur les détails du réseau Sepolia pour consulter une liste de différents faucets. Si l'un d'eux ne fonctionne pas, essayez-en un autre car ils peuvent parfois être à sec. 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 (opens in a new tab). 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 vous n'avez pas encore installé npm, suivez les instructions d'installation de Node.js (opens in a new tab) (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 et nous sommes prêts à commencer !

Étape 7 : Télécharger Hardhat (opens in a new tab)

Hardhat est un environnement de développement permettant de 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.

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 (opens in a new tab).

Étape 8 : Créer un projet Hardhat

Dans le dossier de notre projet, exécutez :

npx hardhat

Vous devriez alors voir un message de bienvenue et une option pour sélectionner ce que vous voulez faire. Sélectionnez « create an empty hardhat.config.js » :

888    888                      888 888               888
888    888                      888 888               888
888    888                      888 888               888
8888888888  8888b.  888d888 .d88888 88888b.   8888b.  888888
888    888     "88b 888P"  d88" 888 888 "88b     "88b 888
888    888 .d888888 888    888  888 888  888 .d888888 888
888    888 888  888 888    Y88b 888 888  888 888  888 Y88b.
888    888 "Y888888 888     "Y88888 888  888 "Y888888  "Y888

👷 Welcome to Hardhat v2.0.11 👷‍?

What do you want to do? …
Create a sample project
❯ Create an empty hardhat.config.js
Quit

Cela générera un fichier hardhat.config.js pour nous, dans lequel nous spécifierons toute la configuration de notre projet (à l'étape 13).

É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 (opens in a new tab)). 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 :

// Spécifie la version de Solidity, en utilisant le versionnage sémantique.
// En savoir plus : https://solidity.readthedocs.io/en/v0.5.10/layout-of-source-files.html#pragma
pragma solidity ^0.7.0;

// Définit un contrat nommé `HelloWorld`.
// Un contrat est un ensemble 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://solidity.readthedocs.io/en/v0.5.10/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 manière 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://solidity.readthedocs.io/en/v0.5.10/contracts.html#constructors
   constructor(string memory initMessage) {

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

   // Une fonction publique qui accepte un argument de chaîne 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 accorder 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 ce tutoriel sur l'envoi de transactions à l'aide de Web3.

Tout d'abord, installez le paquet dotenv dans le répertoire de votre projet :

npm install dotenv --save

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

Suivez ces instructions (opens in a new tab) pour exporter votre clé privée
Voir ci-dessous pour obtenir l'URL HTTP de l'API Alchemy

Copier 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.

Ne commitez pas .env ! Assurez-vous de ne jamais partager ou exposer votre fichier .env à 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 standards avec des méthodes plus conviviales.

Hardhat facilite grandement l'intégration de plugins (opens in a new tab) pour des outils supplémentaires et des fonctionnalités étendues. Nous tirerons parti du plugin Ethers (opens in a new tab) pour le déploiement de contrats (Ethers.js (opens in a new tab) dispose de méthodes de déploiement de contrats très propres).

Dans le répertoire de votre projet, tapez :

npm install --save-dev @nomiclabs/hardhat-ethers "ethers@^5.0.0"

Nous aurons également besoin d'ethers dans notre 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 pour que notre projet les prenne tous en compte.

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

require('dotenv').config();

require("@nomiclabs/hardhat-ethers");
const { API_URL, PRIVATE_KEY } = process.env;

/**
* @type import('hardhat/config').HardhatUserConfig
*/
module.exports = {
   solidity: "0.7.3",
   defaultNetwork: "sepolia",
   networks: {
      hardhat: {},
      sepolia: {
         url: API_URL,
         accounts: [`0x${PRIVATE_KEY}`]
      }
   },
}

É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

Vous pourriez recevoir un avertissement concernant SPDX license identifier not provided in source file, mais ne vous en inquiétez pas — espérons que tout le reste semble correct ! Sinon, vous pouvez toujours envoyer un message sur le Discord d'Alchemy (opens in a new tab).

É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 :

async function main() {
   const HelloWorld = await ethers.getContractFactory("HelloWorld");

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

main()
  .then(() => process.exit(0))
  .catch(error => {
    console.error(error);
    process.exit(1);
  });

Hardhat explique très bien ce que fait chacune de ces lignes de code dans son tutoriel sur les contrats (opens in a new tab), nous avons repris leurs explications ici.

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

Un 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();

L'appel de deploy() sur un ContractFactory démarrera le déploiement et renverra une Promise qui se résout en un Contract. Il s'agit de l'objet qui possède une méthode pour chacune des fonctions de notre contrat intelligent.

É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 alors voir quelque chose comme :

Contract deployed to address: 0x6cd7d44516a20882cEa2DE9f205bF401c0d23570

Si nous allons sur Etherscan Sepolia (opens in a new tab) 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 doit correspondre à l'adresse de votre compte MetaMask et l'adresse de destination (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 ce qui se passe en interne, accédons à l'onglet Explorer (Explorateur) dans notre tableau de bord Alchemy (opens in a new tab). Si vous avez plusieurs applications Alchemy, assurez-vous de filtrer par application et de sélectionner « Hello World ».

Ici, vous 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 (opens in a new tab), qui est la requête pour écrire réellement notre contrat sur la chaîne Sepolia, et eth_getTransactionByHash (opens in a new tab) qui est une requête pour lire des informations sur notre transaction à partir du hash (un modèle typique lors des transactions). Pour en savoir plus sur l'envoi de transactions, consultez ce tutoriel sur l'envoi de transactions à l'aide de Web3

C'est tout pour la partie 1 de ce tutoriel, dans la partie 2, nous allons réellement interagir avec notre contrat intelligent en mettant à jour notre message initial, et dans la partie 3, nous allons publier notre contrat intelligent sur Etherscan afin que tout le monde sache comment interagir avec lui.

Vous voulez en savoir plus sur Alchemy ? Consultez notre site Web (opens in a new tab). Vous ne voulez manquer aucune mise à jour ? Abonnez-vous à notre newsletter ici (opens in a new tab) ! Assurez-vous également de rejoindre notre Discord (opens in a new tab)..