{"id":43447,"date":"2025-02-11T08:11:54","date_gmt":"2025-02-11T08:11:54","guid":{"rendered":"https:\/\/mycryptomania.com\/?p=43447"},"modified":"2025-02-11T08:11:54","modified_gmt":"2025-02-11T08:11:54","slug":"qa-blockchain-testing-smart-contract-network-performance-with-hardhat","status":"publish","type":"post","link":"https:\/\/mycryptomania.com\/?p=43447","title":{"rendered":"QA Blockchain Testing: Smart Contract & Network Performance with Hardhat"},"content":{"rendered":"

\ud83d\udee0\ufe0f \u201cTesting Node & Network Behavior in Smart Contracts Using Hardhat with TypeScript &\u00a0Mocha\u201d<\/strong><\/h4>\n

Background knowledge:<\/h3>\n

A blockchain network consists of multiple nodes<\/strong> that communicate with each other. Each node participates in mining blocks<\/strong> to form a chain<\/strong>, which requires gas fees<\/strong>. Each block contains:<\/p>\n

Transaction data<\/strong> (e.g., deposit or transfer\u00a0records)Timestamp<\/strong> (when the block was\u00a0created)A link to the previous\u00a0block<\/strong>Technical information<\/strong> about the network\u00a0state<\/p>\n

For example, if you deposit 10 ETH<\/strong>, the block would\u00a0record:<\/p>\n

Your wallet address<\/strong> (who sent\u00a0it)The contract address<\/strong> (who received\u00a0it)The amount<\/strong> (10\u00a0ETH)The transaction timestamp<\/strong>Other technical details<\/strong> about the transaction<\/p>\n

In this blog, we will test a smart contract for token lending<\/strong>, where you can deposit ETH<\/strong> to borrow WETH tokens<\/strong>, as shown in the Solidity code\u00a0below:<\/p>\n

Why using\u00a0Hardhat?<\/h3>\n

Network Simulation Capabilities<\/strong>\/\/ In Hardhat, we can control block mining
await network.provider.send(“evm_mine”, []); \/\/ Mine a new block<\/p>\n

\/\/ We can control block timestamps
await network.provider.send(“evm_increaseTime”, [3600]); \/\/ Move time forward 1 hour<\/p>\n

\/\/ We can even control gas prices
await network.provider.send(“hardhat_setNextBlockBaseFeePerGas”, [
ethers.utils.hexValue(ethers.utils.parseUnits(“100”, “gwei”))
]);<\/p>\n

You can save and restore the entire blockchain state for test error recovery:<\/p>\n

describe(“Error Recovery Testing”, () => {
it(“should recover from failed operations”, async function() {
\/\/ Take snapshot before risky operation
const snapshotId = await network.provider.send(“evm_snapshot”, []);<\/p>\n

try {
\/\/ Attempt potentially failing operation
await lendingProtocol.withdraw(ethers.utils.parseEther(“100”)); \/\/ More than deposited
} catch (error) {
\/\/ Revert to clean state
await network.provider.send(“evm_revert”, [snapshotId]);<\/p>\n

\/\/ Verify state is clean
const balance = await lendingProtocol.getUserDeposit(signer.address);
expect(balance).to.equal(0);
}
});
});Mainnet Forking<\/strong><\/p>\n

Hardhat allows us to create a copy of the real Ethereum mainnet at any point in time for\u00a0testing.<\/p>\n

\/\/ We can fork mainnet at a specific block
await network.provider.request({
method: “hardhat_reset”,
params: [{
forking: {
jsonRpcUrl: MAINNET_RPC_URL,
blockNumber: 15000000 \/\/ Specific block number
}
}]
});<\/p>\n

\/\/ Now we can interact with real mainnet contracts
const USDC = await ethers.getContractAt(“IERC20”, “0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48”);Debugging Capabilities<\/strong><\/p>\n

We can get stack traces for failed transactions<\/p>\n

it(“should maintain consistent performance under sustained load”, async function() {
const testUser = await setupTestUser(0, “1000”);
const userContract = lendingProtocol.connect(testUser);
const depositAmount = ethers.utils.parseEther(“0.1”);
const iterations = 3;
const results = [];<\/p>\n

try {
\/\/ Get initial balance
const initialBalance = await userContract.getUserDeposit(testUser.address);
console.log(“Initial balance:”, ethers.utils.formatEther(initialBalance));
} catch (error) {
console.error(“Load test failed:”, error);
}<\/p>\n

You can also use Harthat to debug Smart Contract in the\u00a0console:<\/p>\n

npx hardhat consoleTest Environment Control<\/strong><\/p>\n

With Hardhat, we have extensive control over the test environment.<\/p>\n

\/\/ We can manipulate account balances directly
await network.provider.send(“hardhat_setBalance”, [
userAddress,
ethers.utils.hexValue(ethers.utils.parseEther(“100”))
]);<\/p>\n

\/\/ We can impersonate any Ethereum address
await network.provider.request({
method: “hardhat_impersonateAccount”,
params: [whaleAddress],
});<\/p>\n

Advance Hardhat feature:<\/strong>
We can test how our protocol handles pending transactions and mempool behavior like the code\u00a0below.<\/p>\n

describe(“Transaction Pool Behavior”, () => {
it(“should handle multiple pending transactions correctly”, async function() {
\/\/ Enable auto-mining
await network.provider.send(“evm_setAutomine”, [false]);<\/p>\n

\/\/ Submit multiple transactions that will sit in the mempool
const tx1 = lendingProtocol.deposit({ value: ethers.utils.parseEther(“1”) });
const tx2 = lendingProtocol.deposit({ value: ethers.utils.parseEther(“2”) });
const tx3 = lendingProtocol.deposit({ value: ethers.utils.parseEther(“3”) });<\/p>\n

\/\/ Get pending transactions
const pendingTxs = await network.provider.send(“eth_pendingTransactions”);
console.log(“Pending transactions:”, pendingTxs.length);<\/p>\n

\/\/ Mine them all at once
await network.provider.send(“evm_mine”);<\/p>\n

\/\/ Verify final state
const totalDeposits = await lendingProtocol.totalDeposits();
expect(totalDeposits).to.equal(ethers.utils.parseEther(“6”));
});
});<\/p>\n

To run a test script with Hardhat on\u00a0local:<\/p>\n

npx hardhat test<\/p>\n

How can the QA team test the smart contract?<\/h3>\n

Method 1: Have fully access to the dev code repository<\/strong><\/p>\n

\/\/ Need access to contract code and typechain
import { TestLendingProtocol } from “..\/..\/typechain\/contracts\/TestLendingProtocol”;<\/p>\n

\/\/ Full testing capabilities with type safety
describe(“Full Testing Suite”, () => {
let lendingProtocol: TestLendingProtocol;<\/p>\n

beforeEach(async () => {
lendingProtocol = await ethers.getContractAt(
“TestLendingProtocol”,
addresses.lendingProtocol,
signer
);
});
});<\/p>\n

Before importing from the typechain folder, you might need to run this command to compile the Solidity file to generate ABI (Application Binary Interface) and TypeChain types.<\/p>\n

npx hardhat compile<\/p>\n

This creates:<\/p>\n

artifacts\/ folder containing ABIstypechain\/ folder containing TypeScript types<\/p>\n

Method 2: Testing Deployed Contracts (No Source Code\u00a0Access)<\/strong><\/p>\n

\/\/ QA only has contract address and ABI
const contractAddress = “0x123…”; \/\/ Deployed contract address
const abi = [
“function deposit() external payable”,
“function withdraw(uint256 amount) external”
];<\/p>\n

describe(“Limited Testing Suite”, () => {
it(“can test basic functionality”, async () => {
const contract = new ethers.Contract(contractAddress, abi, signer);<\/p>\n

\/\/ Can test basic functions
await contract.deposit({ value: ethers.utils.parseEther(“1”) });<\/p>\n

\/\/ Can’t simulate network conditions as effectively
\/\/ Limited to actual network behavior
});
});<\/p>\n

About testing deployed contracts, you can still use Hardhat to fork the Ethereum Mainnet or a Testnet, depending on which network the developer has deployed\u00a0to.<\/p>\n

If you fork Ethereum\u00a0Mainnet:<\/strong><\/p>\n

\/\/ CORRECT: Using Mainnet contract address
const MAINNET_USDC = “0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48”;
const MAINNET_WETH = “0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2”;<\/p>\n

await network.provider.request({
method: “hardhat_reset”,
params: [{
forking: {
jsonRpcUrl: MAINNET_RPC_URL, \/\/ Mainnet RPC URL
blockNumber: 15000000
}
}]
});<\/p>\n

const usdc = new ethers.Contract(MAINNET_USDC, USDC_ABI, signer);
const weth = new ethers.Contract(MAINNET_WETH, WETH_ABI, signer);<\/p>\n

If you fork Testnets (e.g., Sepolia):<\/strong><\/p>\n

\/\/ CORRECT: Using Sepolia contract address
const SEPOLIA_USDC = “0x1c7D4B196Cb0C7B01d743Fbc6116a902379C7238”; \/\/ Example address<\/p>\n

await network.provider.request({
method: “hardhat_reset”,
params: [{
forking: {
jsonRpcUrl: SEPOLIA_RPC_URL, \/\/ Sepolia RPC URL
blockNumber: 3000000
}
}]
});<\/p>\n

const usdc = new ethers.Contract(SEPOLIA_USDC, USDC_ABI, signer);<\/p>\n

How can the QA team test smart contracts across different networks?<\/h3>\n

You can configure the network configuration in hardhat.config.ts<\/em> like\u00a0this:<\/p>\n

When you want to run with a specific network name, use the\u00a0command:<\/p>\n

hardhat test –network mainnetFork<\/p>\n

Pre-requisite:<\/h4>\n

You can copy the mainnet URL with an API key from Alchemy or\u00a0Infura.<\/p>\n

Alchemy API\u00a0keyInfura API\u00a0key<\/p>\n

Get testnet token Sepolia for\u00a0free:<\/p>\n

https:\/\/console.optimism.io\/faucet<\/a>https:\/\/cloud.google.com\/application\/web3\/faucet\/ethereum\/sepolia<\/a>https:\/\/www.ethereumsepoliafaucet.com\/<\/a>https:\/\/sepolia-faucet.pk910.de\/<\/a><\/p>\n

How can QA identify what to test on the Defi smart contract?<\/h3>\n

First, let\u2019s look at what we know about our lending protocol:<\/p>\n

Step 1: Understand the business requirements and core functions. We can start with functional testing from this\u00a0stage.<\/h4>\n

it(“should allow deposits and withdrawals”, async function() {
await lendingProtocol.deposit({ value: ethers.utils.parseEther(“1”) });
await lendingProtocol.withdraw(ethers.utils.parseEther(“1”));
});<\/p>\n

Step 2: Understanding financial risk, think about what could go wrong with\u00a0money:<\/h4>\n

What if the network is slow and transactions get\u00a0stuck?What if gas prices suddenly spike while processing a\u00a0loan?What if the system gets many requests at\u00a0once?<\/p>\n

This leads us to our first network\u00a0tests:<\/p>\n

In this test case, we simulate extreme network conditions and attempt transactions with gas price limits. The result should be no state changes occurring to protect users from overpaying for transactions.<\/p>\n

Understand blockchain behavior:<\/strong><\/p>\n

Network congestion can cause sudden gas price increasesTransactions with too low gas prices may never\u00a0confirmUsers can set maximum gas price\u00a0limitsTransactions should fail gracefully if gas limits are\u00a0exceeded<\/p>\n

Step 3: Learning from real DeFi incidents<\/h4>\n

Many DeFi protocols have had issues in the past.\u00a0Example:<\/p>\n

MakerDAO had issues during high network congestion in March\u00a02020Compound had problems with block timing affecting interest calculationsVarious protocols had issues during network\u00a0splits<\/p>\n

This history teaches us to\u00a0test:<\/p>\n

Step 4: Understanding protocol requirements<\/h4>\n

Any lending protocol needs\u00a0to:<\/p>\n

Keep accurate\u00a0balancesCalculate interest correctlyAllow withdrawals when\u00a0promisedProtect user\u00a0funds<\/p>\n

This leads to testing time-dependent operations:<\/p>\n

Result on HTML\u00a0report:<\/p>\n

Purpose of this test\u00a0case:<\/strong><\/p>\n

Ensure interest accrues correctly, whether blocks are fast or\u00a0slowVerify calculations are precise and match expected mathematical formulasTest system resilience to different network\u00a0speeds<\/p>\n

Blockchain Behavior\u00a0Testing:<\/strong><\/p>\n

Block time variations:Ethereum block times aren\u2019t\u00a0constantNetwork congestion affects block\u00a0timingSystem must work correctly regardless<\/p>\n

2. Gas price\u00a0impact:<\/p>\n

High gas prices during network congestionShouldn\u2019t affect protocol calculationsOnly affects transaction costs<\/p>\n

3. Time-Based Calculations:<\/p>\n

Interest depends on elapsed\u00a0timeMust handle various timeframes accuratelyPrecision important for financial calculations<\/p>\n

Step 5: Learning about network\u00a0behavior<\/h4>\n

As you learn more about Ethereum, you discover:<\/p>\n

Blocks can be reorganized (changed)The network can split temporarilyGas prices can change\u00a0rapidlyTransactions can get\u00a0stuck<\/p>\n

This knowledge leads to more sophisticated tests:<\/p>\n

Step 6: Understanding user\u00a0impact<\/h4>\n

Some might deposit small\u00a0amountsOthers might deposit large\u00a0amountsThey might need their money during network\u00a0problemsThey shouldn\u2019t lose money due to technical issues<\/p>\n

This leads to testing different scenarios:<\/p>\n

How to generate an HTML report with\u00a0Mocha?<\/h3>\n

Install dependecies:<\/strong><\/p>\n

npm install –save-dev mochawesome mochawesome-merge mochawesome-report-generator mocha-multi-reporters mocha-ctrf-json-reporter<\/p>\n

You can configure mocha settings on hardhat.config.ts<\/em> like\u00a0this:<\/p>\n

Import mocha to the test\u00a0script:<\/p>\n

import “mocha”;
import addContext from ‘mochawesome\/addContext’;<\/p>\n

Example using addContext to show test results visible in HTML\u00a0report:<\/p>\n

\/\/ @ts-ignore
addContext(this, {
title: ‘WETH balance’,
value: ethers.utils.formatEther(balance)
});<\/p>\n

Additionally, we might consider creating a custom script to display total gas usage from the Hardhat gas reporter plugin inside an HTML report. This would help optimize the contract while making test results easily visible in one\u00a0place.<\/p>\n

Install Hardhat gas reporter:<\/strong><\/p>\n

npm install –save-dev hardhat-gas-reporter<\/p>\n

You can configure gas reporter settings on hardhat.config.ts<\/em> like\u00a0this:<\/p>\n

Example some part of Hardhat gas report json format that we need to covert to mocha json format for generate HTML\u00a0later:<\/p>\n

A custom script to convert the Hardhat gas report into an \u201cafter\u201d hook inside the Mocha JSON report, as shown in the code\u00a0below:<\/p>\n

Here is the command to run Hardhat test cases along with the Mocha report and a custom script for the Hardhat Gas Reporter to generate an HTML report in package.json\u00a0:<\/p>\n

“scripts”: {
“test”: “hardhat test”,
“clean:reports”: “rm -rf test-reports\/* && rm -rf gas-reports\/* && rm -rf ctrf\/*”,
“test:specific”: “npm run clean:reports && npm run deploy:mainnet-fork && hardhat test”,
“deploy:mainnet-fork”: “hardhat run scripts\/deploy\/deployAndUpdateAddresses.ts –network mainnetFork”,
“test:main_network_fork_report”: “npm run clean:reports && npm run deploy:mainnet-fork && hardhat test –network mainnetFork && npx mochawesome-merge test-reports\/*.json -o test-reports\/merged.json && node scripts\/utils\/addGasToMergedReport.js && npx marge test-reports\/merged.json -o test-reports -f report”
},<\/p>\n

Result on HTML\u00a0report:<\/p>\n

All the source code, including additional test cases, is available in this\u00a0<\/em>repo<\/em><\/a><\/p>\n

Thanks for reading, and I hope you found this article helpful.
If you found this article helpful, give it a \ud83d\udc4f (or a few!) to help others discover\u00a0it!<\/p>\n

QA Blockchain Testing: Smart Contract & Network Performance with Hardhat<\/a> was originally published in Coinmonks<\/a> on Medium, where people are continuing the conversation by highlighting and responding to this story.<\/p>","protected":false},"excerpt":{"rendered":"

\ud83d\udee0\ufe0f \u201cTesting Node & Network Behavior in Smart Contracts Using Hardhat with TypeScript &\u00a0Mocha\u201d Background knowledge: A blockchain network consists of multiple nodes that communicate with each other. Each node participates in mining blocks to form a chain, which requires gas fees. Each block contains: Transaction data (e.g., deposit or transfer\u00a0records)Timestamp (when the block was\u00a0created)A […]<\/p>\n","protected":false},"author":0,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[2],"tags":[],"class_list":["post-43447","post","type-post","status-publish","format-standard","hentry","category-interesting"],"_links":{"self":[{"href":"https:\/\/mycryptomania.com\/index.php?rest_route=\/wp\/v2\/posts\/43447"}],"collection":[{"href":"https:\/\/mycryptomania.com\/index.php?rest_route=\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/mycryptomania.com\/index.php?rest_route=\/wp\/v2\/types\/post"}],"replies":[{"embeddable":true,"href":"https:\/\/mycryptomania.com\/index.php?rest_route=%2Fwp%2Fv2%2Fcomments&post=43447"}],"version-history":[{"count":0,"href":"https:\/\/mycryptomania.com\/index.php?rest_route=\/wp\/v2\/posts\/43447\/revisions"}],"wp:attachment":[{"href":"https:\/\/mycryptomania.com\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=43447"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/mycryptomania.com\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=43447"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/mycryptomania.com\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=43447"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}