Why we chose to use Hardhat and Foundry together

[codenamejason]

Why we chose to use Hardhat and Foundry together

TL;DR;

The choice of testing and deployment frameworks can significantly impact the development workflow and efficiency. Opting for Forge for testing and Hardhat for deployment seemed like a balanced approach, leveraging the strengths of each framework:

1. Forge for Testing:

   • By choosing Forge for testing, we benefit from its Solidity-centric testing environment, faster testing speed, and additional testing features like inbuilt fuzzing, call stack traces, and an interactive debugger. This choice can lead to a more intuitive and efficient testing process, especially for developers who are more comfortable with Solidity.

2. Hardhat for Deployment:

   • On the other hand, selecting Hardhat for deployment allows us to take advantage of its robust deployment capabilities, including the straightforward deployment of proxy upgradeable contracts, as mentioned earlier. The choice of Hardhat for deployment also opens up the opportunity to utilize its extensive plugin ecosystem, which can be leveraged to further streamline the deployment process and integrate with other tools or services as needed.

This bifurcated approach allows our team to harness the specialized functionalities and advantages of both frameworks, potentially leading to a more streamlined and effective development process. The key is to ensure smooth interoperability between the two frameworks, which may require some additional configuration or tooling, but could result in a powerful and flexible development setup.

Deployment with Hardhat:

Hardhat and Foundry are two distinct frameworks used for developing and deploying smart contracts on the Ethereum blockchain. Here's an overview of some differences between Hardhat and Foundry deployments, particularly focusing on the handling of proxy upgradeable contracts:

1. Deployment of Proxy Upgradeable Contracts:

   • In Hardhat, the deployment of proxy upgradeable contracts seems to be more straightforward. An example provided on a Stack Exchange post shows the upgrades.deployProxy method being used for this purpose in Hardhat [1].
   • In contrast, the discussion did not provide a corresponding method for deploying proxy upgradeable contracts in Foundry, indicating it might not support this feature as seamlessly as Hardhat does.

2. Configuration:

   • Both frameworks use configuration files, with Hardhat utilizing a hardhat.config.js file, and Foundry generating a foundry.toml file upon project creation.
   • Hardhat allows for the addition of multiple networks in its configuration file which can be later used to deploy contracts. However, Foundry does not currently support this feature. In Foundry, most additional parameters you can add to the foundry.toml file are related to tests such as verbosity, account, balance, gas price, etc [2].

3. Usability & Complexity:

   • Foundry is marketed as "the framework for pros" and includes more tools for sophisticated smart contract analysis. However, it's mentioned that this doesn't necessarily make it more professional software [3].

4. Templates:

   • There's mention of a Hardhat-based and Foundry-based template for developing upgradeable Solidity smart contracts on GitHub. This could be beneficial for developers looking to work with upgradeable contracts on either framework.

5. Project Structure:

   • The directory structure for contract files, test files, output, and dependencies are defined in the configuration files for both frameworks, with slightly different default folders.

Foundry's apparent lack of support for deploying proxy upgradeable contracts as seamlessly as Hardhat—is consistent with the information sourced. This might necessitate additional steps or different methods to achieve a similar result when using Foundry.

---

Testing with Forge

Testing smart contracts is a crucial aspect of blockchain development to ensure the robustness and security of the code. Both Forge (a part of the Foundry framework) and Hardhat offer tools for testing, though they have distinct differences in their approach and functionalities:

1. Language Utilized for Testing:

   • Hardhat primarily utilizes JavaScript/TypeScript for writing tests.
   • In contrast, Forge allows for testing in Solidity, making it more straightforward for developers who primarily work with Solidity for smart contract development [4].

2. Testing Commands and Functionalities:

   • Forge provides the following commands for testing:
     • forge test: To run the project's tests.
     • forge snapshot: To create a snapshot of each test's gas usage.
     • forge coverage: To generate coverage reports [5].
   • Hardhat, on the other hand, employs a framework based on ethers.js, Mocha, and Chai for testing smart contracts.

3. Performance:

   • Foundry, and by extension Forge, is noted for its remarkable speed when it comes to testing. One comparison indicated that a test with 1k queries and transactions on-chain took 1 minute with Foundry, while it took 15 minutes with Hardhat. Additionally, Foundry's fuzzing functionality, which runs 10,000 tests in seconds, was highlighted for checking edge cases.

4. Implementation Language:

   • Hardhat is implemented using TypeScript, which is noted to be slower compared to Foundry, which is implemented using Rust. This has a direct impact on the speed of testing and other operations.

5. Additional Testing Features in Forge:

   • Forge offers features like call stack traces, an interactive debugger, inbuilt fuzzing, and Solidity scripting which are beneficial for a thorough testing process.

6. Ease of Use for Solidity Developers:

   • The necessity to know a scripting language like JavaScript/TypeScript to work with Hardhat could be a hurdle for Solidity developers. This is not a requirement with Forge, making it potentially more accessible for developers focused on smart contract development.

7. Compile Time:

   • Foundry has a faster compile time compared to Hardhat, which could contribute to a more efficient testing and development cycle【26†(source)】.

8. Testing, Building, and Deployment:

   • Forge is not only used for testing but also for building and deploying smart contracts, providing a comprehensive tool for these critical development stages.

🪝 Given these differences, the choice between Forge and Hardhat for testing would hinge on the project requirements, the team's familiarity with JavaScript/TypeScript versus Solidity, and the importance of testing speed and additional testing features provided by Forge.

---

Sources:
[1]
[2]
[3]
[4]
[5]