6 min de lecture

Aperçu

Les environnements de développement Ethereum, tels que Hardhat, facilitent l'utilisation des contrats intelligents et des nœuds Ethereum. Ils fournissent un ensemble d'outils permettant d'écrire, de tester et de déployer des contrats intelligents en toute simplicité. Dans ce guide, nous allons créer un contrat intelligent « Hello World » et le déployer sur le testnet Sepolia à l'aide de Hardhat et de Quicknode.

Prérequis

• Un compte Quicknode (créez-en un gratuitement ici)
• Un portefeuille compatible EVM (par exemple, MetaMask)
• Node.js est installé
• Hardhat est installé (nous aborderons également ce point dans ce guide)
• Ligne de commande/Fenêtre de terminal
• Éditeur de code ou de texte (par exemple, VSCode)
• ETH sur le testnet Sepolia (vous pouvez utiliser le « Quicknode Multi-chain Faucet » pour en obtenir gratuitement)

Qu'est-ce que Hardhat ?

Hardhat est un environnement de développement qui aide les développeurs à compiler, déployer, tester et déboguer leurs applications Ethereum. Il dispose d'une documentation parmi les plus claires et les plus détaillées qui soient. Hardhat offre également une fonctionnalité console.log(), similaire à celle de JavaScript, destinée au débogage. Hardhat propose par ailleurs de nombreux plugins, qui élargissent encore ses fonctionnalités.

Installation de Hardhat et des autres dépendances

Nous allons installer Hardhat à l'aide de npm, qui est fourni avec Node.js. 

Commencez par créer un nouveau répertoire de projet, puis accédez-y. N'hésitez pas à utiliser vos propres noms à la place :

mkdir HardhatTutorial
cd HardhatTutorial

Ouvrez le terminal/cmd dans le répertoire de votre projet et saisissez les commandes suivantes.

npm init --y
npm install --save-dev hardhat

Maintenant que Hardhat est installé, créons un nouveau projet Hardhat. Pour cela, nous allons utiliser npx. Npx permet d'exécuter des programmes Node.js. 

npx hardhat init

L'interface CLI de Hardhat s'affichera. Sélectionnez « Créer un fichier hardhat.config.js vide », puis appuyez sur Entrée.

Installons maintenant les autres dépendances nécessaires pour utiliser Hardhat.

npm install --save-dev @nomiclabs/hardhat-ethers ethers @nomiclabs/hardhat-waffle ethereum-waffle chai

Nous avons besoin de ces dépendances pour écrire des tests automatisés pour les contrats.

Le problème le plus courant lors de l'installation de paquets avec npm peut être une erreur interne liée à `node-gyp`. Vous pouvez suivre les instructions d'installation de node-gyp disponibles ici.

Remarque: si vous rencontrez le problème lié à node-gyp, vous devrez vous assurer que la version de Python que vous utilisez correspond à l'une des versions compatibles répertoriées dans les instructions ci-dessus. 

Un autre problème courant est un cache obsolète. Pour vider votre cache npm, il vous suffit de saisir la commande suivante dans votre terminal :

npm cache clean

Maintenant, procurons-nous une clé privée pour notre portefeuille, un peu d'ETH pour tester les frais de gaz, et mettons en place un nœud Ethereum ; tout cela nous sera nécessaire pour déployer notre contrat intelligent.

Création/récupération de la clé privée

Nous aurons besoin d'un portefeuille Ethereum pour payer le déploiement de notre contrat intelligent.

Une fois votre portefeuille créé et sa clé privée récupérée, nous l'ajouterons au fichier de configuration de Hardhat (par exemple, hardhat.config.js) dans la section suivante.

Vous pouvez suivre les guides de Quicknode pour générer une clé privée et une adresse Ethereum en JavaScript, Ruby, Python, Go ou PHP.

Pour récupérer la clé privée de votre portefeuille MetaMask, suivez ces instructions :

• Cliquez sur l'icône MetaMask, qui représente une tête de renard stylisée, dans votre navigateur. Si vous ne la voyez pas, consultez la page « Extensions » de votre navigateur.
• Cliquez sur le symbole ⋮, puis sur « Détails du compte ».
• Cliquez ensuite sur « Afficher la clé privée » et suivez les instructions.

Copiez et enregistrez la clé privée ; nous en aurons besoin dans les étapes suivantes.

Il est recommandé de stocker les informations sensibles, telles que les clés privées, dans un fichier .env et de les intégrer au fichier de configuration à l'aide de variables d'environnement, ou encore de créer un nouveau portefeuille MetaMask secondaire destiné exclusivement au développement.

Obtenir des ETH du Testnet

Nous allons déployer notre contrat sur le testnet Sepolia. Pour commencer, nous aurons besoin d'un peu d'ETH de test dans notre portefeuille MetaMask, comme nous l'avons vu à l'étape précédente.

Rendez-vous sur le site Quicknode Multi-Chain Faucet et connectez votre portefeuille ou collez l'adresse de celui-ci. Vous devrez sélectionner la chaîne Ethereum et le réseau Sepolia, puis demander des fonds.

Remarque : vous devez disposer d'un solde d'au moins 0,001 ETH sur le réseau principal d'Ethereum pour pouvoir utiliser ce « faucet ».

Configuration d'un point de terminaison Ethereum Quicknode

Pour déployer notre contrat sur la blockchain Sepolia d’Ethereum, nous aurons besoin d’accéder à un nœud Ethereum Sepolia. Pour cela, nous pourrions utiliser pratiquement n’importe quel client Ethereum, tel que Geth ou OpenEthereum (anciennement Parity). Comme cela s’avère un peu trop complexe pour le déploiement d’un seul contrat, nous allons simplement créer un compte Quicknode gratuit ici et générer facilement un point de terminaison Ethereum. Une fois que vous aurez créé votre point de terminaison Ethereum Sepolia gratuit, conservez l'URL de votre fournisseur HTTP à portée de main, car vous en aurez besoin dans la section suivante.

Configuration du fichier de configuration

Ouvrez le fichier hardhat.config.js et collez-y ce qui suit :

require("@nomiclabs/hardhat-waffle");

const endpointUrl = "ADD_YOUR_QUICKNODE_URL_HERE";
const privateKey = "ADD_YOUR_PRIVATE_KEY_HERE";

module.exports = {
  solidity: "0.8.21",
  networks: {
    sepolia: {
      url: endpointUrl,
      accounts: [privateKey],
    },
  },
};

Remplacez « ADD_YOUR_PRIVATE_KEY_HERE » par la clé privée obtenue à l'étape précédente et remplacez « ADD_YOUR_QUICKNODE_URL_HERE » par l'URL HTTP du nœud obtenue à l'étape précédente, puis enregistrez le fichier.

Explication du code ci-dessus :

• Ligne 1 : Importation du paquet « hardhat-waffle ».

• Lignes 3-4 : Définition de l'URL du point de terminaison et de la clé privée.

• Lignes 6 à 14 : mention de la version de Solidity et définition du réseau « sepolia ».

Création d'un contrat

Maintenant, pour notre contrat, créez un nouveau répertoire « contracts » et placez-y un nouveau fichier « HelloWorld.sol ».

mkdir contracts && echo > contracts/HelloWorld.sol

Copiez-collez le code suivant dans votre fichier Solidity HelloWorld.sol:

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

contract HelloWorld {

    string saySomething;

    constructor() {
        saySomething = "Hello World!";
    }

    function speak() public view returns(string memory) {
        return saySomething;
    }
}

Explication du code ci-dessus :

• Ligne 1 : Spécification du type de licence SPDX, une nouveauté introduite à partir de Solidity ^0.6.8. 

Lorsque le code source d'un contrat intelligent est rendu public, ces licences peuvent aider à résoudre ou à éviter les problèmes liés aux droits d'auteur. Si vous ne souhaitez pas préciser de type de licence, vous pouvez utiliser la licence spéciale « UNLICENSED » ou simplement ignorer l'intégralité du commentaire (cela ne provoquera pas d'erreur, mais simplement un avertissement).

• Ligne 2 : Déclaration de la version de Solidity.

• Ligne 4 : Lancement de notre contrat intitulé Bonjour tout le monde.

• Ligne 6 : Création d'une variable saySomething de type chaîne de caractères.

• Lignes 8 à 10 : Appel du constructeur et enregistrement de la chaîne « Hello World ! » dans le saySomething variable.

• Lignes 12 à 14 : Création d'une fonction nommée parler de type public, qui renverra la chaîne stockée dans le saySomething variable.

Enregistrez le fichier et compilez le contrat à l'aide de la commande Hardhat suivante.

npx hardhat compile

Si la compilation de votre contrat s'effectue correctement, vous obtiendrez un résultat similaire à celui-ci :

Déploiement du contrat intelligent « Hello World »

Pour déployer notre contrat, créons maintenant un fichier deploy.js dans un nouveau répertoire nommé « scripts ».

mkdir scripts && echo > scripts/deploy.js

Copiez-collez ce qui suit dans votre fichier deploy.js :

async function main() {

	const [deployer] = await ethers.getSigners();

	console.log(
	"Deploying contracts with the account:",
	deployer.address
	);

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

	console.log("Contract deployed at:", contract.address);

	const saySomething = await contract.speak();
  	
	console.log("saySomething value:", saySomething);
}

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

Explication du code ci-dessus.

• Ligne 1 : Lancement d'une fonction asynchrone nommée principal.

• Ligne 3 : Récupération de l'adresse Ethereum permettant de signer la transaction et enregistrement de celle-ci dans l'adresse du déployeur. 

• Lignes 5 à 8 : affichage de l'adresse Ethereum et d'une chaîne de caractères sur la console.

• Ligne 10 : Appel de la méthode ethers.js ContractFactory. Cela permettra de rechercher le HelloWorld.sol fichier, et renvoyer une instance que nous pouvons utiliser ContractFactory méthodes activées.

• Ligne 11 : Appel de la fonction « deploy » sur ContractFactory pour déployer le contrat. 

• Ligne 13 : Affichage de l'adresse du contrat déployé dans la console.

• Ligne 15 : Appel de la fonction parler du contrat mis en œuvre.

• Ligne 17 : Affichage de la valeur de retour de la fonction parler sur la console.

• Ligne 20 : Appel de la fonction principal.

• Lignes 21 à 24 : vérification de la présence d'erreurs, affichage des erreurs le cas échéant, puis arrêt du processus.

Enregistrez le fichier et exécutez la commande suivante pour déployer le contrat.

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

Une fois le contrat déployé avec succès, vous verrez s'afficher un message contenant l'adresse du contrat déployé ainsi que la valeur renvoyée par la fonction `speak`, à savoir la valeur de `saySomething`.

Nous pouvons vérifier le déploiement en copiant-collant l'adresse du contrat déployé dans la barre de recherche de Sepolia Etherscan. Cela permettra d'afficher des informations sur le contrat déployé.

Conclusion

Et voilà ! Vous maîtrisez désormais les bases de la création, de la compilation et du déploiement de contrats intelligents avec Hardhat. Mais ce n’est pas tout : Hardhat propose également des outils pour tester et déboguer votre code. Pour approfondir le sujet, consultez la documentation officielle de Hardhat.

Abonnez-vous à notre newsletter pour découvrir d'autres articles et guides sur Ethereum. Si vous avez des questions, n'hésitez pas à nous rejoindre sur notre canal dédié sur Discord ou à nous faire part de vos commentaires via le formulaire ci-dessous. Restez informé des dernières actualités en nous suivant sur Twitter et sur notre canal d'annonces Telegram.

Nous ❤️ les commentaires !

Faites-nous savoir si vous avez des commentaires ou des suggestions de nouveaux sujets. Nous serions ravis de vous entendre.