Hardhat vs Foundry : choisir le bon outil de développement Ethereum

Le choix des bons outils pour le développement de votre dapp n'affecte pas seulement la productivité, mais impacte également l'efficacité des tests, du déploiement et de la maintenance des smart contracts. Dans ce blog, nous comparons deux choix populaires parmi les développeurs de dapps Ethereum : Foundry et Hardhat, en nous concentrant sur leurs prérequis d'installation, leurs workflows de test et de déploiement, ainsi que leurs aspects techniques spécifiques et leurs limitations.

À propos de Hardhat

Hardhat est un environnement de développement bien établi, conçu pour aider les développeurs à gérer et automatiser les tâches liées au développement de smart contracts. Il est reconnu pour sa nature flexible et adaptable. Hardhat intègre le Hardhat Network, un réseau Ethereum local conçu pour le développement, qui facilite également les tests, le déploiement et le débogage.

Les développeurs peuvent interagir directement avec les smart contracts déployés sur le Hardhat Network via une console interactive, offrant un environnement local complet adapté aux tâches de développement. Hardhat prend également en charge un écosystème de plugins robuste, permettant aux développeurs d'étendre facilement ses fonctionnalités. Cependant, certains utilisateurs peuvent trouver la configuration initiale de Hardhat complexe.

À propos de Foundry

De son côté, Foundry est une suite d'outils de développement relativement récente qui met l'accent sur la rapidité et la fiabilité. Elle est construite sur Forge, un puissant framework de test qui permet aux développeurs d'écrire, de compiler et de tester des smart contracts efficacement. L'une des caractéristiques clés de Foundry est sa rapidité de test : le framework Forge accélère considérablement les temps d'exécution des tests, permettant aux développeurs d'itérer plus rapidement.

De plus, Foundry inclut des outils de débogage natifs qui aident les développeurs à diagnostiquer et résoudre les problèmes directement dans l'environnement. Foundry s'intègre également de manière transparente avec d'autres outils de l'écosystème Ethereum, facilitant un processus de développement plus fluide. Cependant, étant relativement récent, Foundry peut manquer du support communautaire étendu dont bénéficient les outils plus établis.

Comparaison technique de Hardhat et Foundry

Pour cette section, nous utiliserons un smart contract de somme aléatoire basique. Ce smart contract restera identique pour Hardhat et Foundry, mais la configuration du projet différera légèrement entre les deux frameworks.

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

contract RandomSum {
    // Function to generate a pseudo-random number based on input
    function random(uint seed) private view returns (uint) {
        return uint(keccak256(abi.encodePacked(block.timestamp, msg.sender, seed))) % 100;
    }

    // Function to generate two random numbers and return their sum
    function generateSum() public view returns (uint sum) {
        uint num1 = random(1);
        uint num2 = random(2);
        sum = num1 + num2;
    }
}
Copier

Installation :

Hardhat :

Pour commencer à utiliser Hardhat, vous devez avoir Node.js installé sur votre machine. Une fois cette étape effectuée, vous pouvez créer un nouveau projet Hardhat en suivant ces étapes :

1. Initialiser un nouveau projet Node.js :

mkdir randomsum
cd randomsum
npm init -y
Copier

1. Installer Hardhat :

1. Créer un projet Hardhat :

1. Suivez les instructions pour créer un projet de base. Sélectionnez « Create an empty hardhat.config.js » pour une configuration minimale. Choisissez de créer un exemple de projet. Cela configure un environnement Hardhat avec toutes les configurations nécessaires.

Contrat : Placez votre contrat RandomSum dans le dossier contracts.

Foundry

Foundry utilise Rust, vous devrez donc avoir Rust installé sur votre système. Une fois Rust prêt, vous pouvez installer Foundry en exécutant :

1. Installer Foundry :

curl -L <https://foundry.paradigm.xyz> | bash
foundryup
Copier

1. Initialiser un nouveau projet Foundry :

forge init randomsum-foundry
cd randomsum-foundry
Copier

Contrat : Placez votre contrat RandomSum dans le répertoire src.

Déploiement sur une blockchain locale

Hardhat

• Blockchain locale : Utilisez le Hardhat Network, qui s'exécute automatiquement lorsque vous effectuez des tâches telles que les tests ou le déploiement de contrats.

• Script de déploiement : Créez un script dans scripts/deploy.js :

async function main() {
    const RandomSum = await ethers.getContractFactory("RandomSum");
    const randomSum = await RandomSum.deploy();
    await randomSum.deployed();
    console.log("RandomSum deployed successfully:");
}

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

• Exécuter le déploiement : Lancez le déploiement avec :

Foundry

• Blockchain locale : Foundry utilise anvil, un nœud Ethereum local. Exécutez-le dans un terminal séparé pour démarrer votre nœud local.

• Script de déploiement : Utilisez directement la commande forge create :

Déploiement sur un testnet en direct

Hardhat

• Configuration réseau : Configurez le réseau souhaité dans hardhat.config.js, en ajoutant une section pour les paramètres réseau (par exemple, Sepolia).

module.exports = {
  solidity: "0.8.0",
  networks: {
    sepolia: {
      url: "https://linea-sepolia.infura.io/v3/YOUR_INFURA_KEY",
      accounts: [`0x${process.env.PRIVATE_KEY}`]
    }
  }
};
Copier

• Déploiement : Exécutez le même script de déploiement en changeant l'option réseau pour Sepolia.

Foundry

• Configuration réseau : Aucun fichier de configuration supplémentaire n'est nécessaire ; spécifiez le réseau directement dans la commande.

• Déploiement : utilisez :

Tests de smart contracts

Hardhat

• Écrire les tests : Créez un fichier de test dans test/randomSum.js en utilisant JavaScript :

const { expect } = require("chai");

describe("RandomSum", function() {
  it("Should return the sum of two random numbers", async function() {
    const RandomSum = await ethers.getContractFactory("RandomSum");
    const randomSum = await RandomSum.deploy();
    await randomSum.deployed();

    const sum = await randomSum.generateSum();
    expect(sum).to.be.a('number');
  });
});
Copier

• Exécuter les tests : Lancez-les avec :

Si vous rencontrez des problèmes lors des tests, ajoutez simplement la fonction loadFixture de @nomicfoundation/hardhat-toolbox/network-helpers.

Les principaux avantages de l'utilisation de loadFixture sont :

• Elle configure un environnement propre pour chaque test en revenant à un snapshot.

• Elle est plus efficace que le redéploiement des contrats pour chaque test.

• Elle permet de partager le code de configuration entre plusieurs tests.

Foundry

• Écrire les tests : Ajoutez un fichier de test dans test/RandomSum.t.sol en utilisant Solidity :

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

import "ds-test/test.sol";
import "../src/RandomSum.sol";

contract RandomSumTest is DSTest {
  RandomSum randomSum;

  function setUp() public {
    randomSum = new RandomSum();
  }

  function testGenerateSum() public {
    uint sum = randomSum.generateSum();
    assertTrue(sum >= 0 && sum <= 198); // since each random number is <100
  }
}
Copier

• Exécuter les tests : Utilisez :

Conclusion

Le choix entre Hardhat et Foundry dépend souvent des compétences de l'équipe et des besoins spécifiques du projet. Si l'équipe maîtrise JavaScript et nécessite une intégration poussée avec les technologies web, Hardhat pourrait être le meilleur choix. Son écosystème de plugins robuste et son environnement flexible en font un outil idéal pour les projets qui exigent un haut degré de personnalisation et d'interaction avec diverses technologies web.

En revanche, si le projet nécessite des cycles de développement rapides axés exclusivement sur les smart contracts, Foundry offre une option attrayante et efficace qui maintient tout au sein de l'écosystème Solidity. Sa rapidité et son support natif de Solidity peuvent considérablement améliorer la productivité des équipes dédiées au développement de smart contracts.

En définitive, les deux outils ont leurs points forts, et le bon choix dépend des exigences uniques de votre projet et de l'expertise de votre équipe.