Web3 Testing

1---
2name: web3-testing
3description: Test smart contracts comprehensively using Hardhat and Foundry with unit tests, integration tests, and mainnet forking. Use when testing Solidity contracts, setting up blockchain test suites, or validating DeFi protocols.
4---
5 
6# Web3 Smart Contract Testing
7 
8Master comprehensive testing strategies for smart contracts using Hardhat, Foundry, and advanced testing patterns.
9 
10## Do not use this skill when
11 
12- The task is unrelated to web3 smart contract testing
13- You need a different domain or tool outside this scope
14 
15## Instructions
16 
17- Clarify goals, constraints, and required inputs.
18- Apply relevant best practices and validate outcomes.
19- Provide actionable steps and verification.
20- If detailed examples are required, open `resources/implementation-playbook.md`.
21 
22## Use this skill when
23 
24- Writing unit tests for smart contracts
25- Setting up integration test suites
26- Performing gas optimization testing
27- Fuzzing for edge cases
28- Forking mainnet for realistic testing
29- Automating test coverage reporting
30- Verifying contracts on Etherscan
31 
32## Hardhat Testing Setup
33 
34```javascript
35// hardhat.config.js
36require("@nomicfoundation/hardhat-toolbox");
37require("@nomiclabs/hardhat-etherscan");
38require("hardhat-gas-reporter");
39require("solidity-coverage");
40 
41module.exports = {
42  solidity: {
43    version: "0.8.19",
44    settings: {
45      optimizer: {
46        enabled: true,
47        runs: 200,
48      },
49    },
50  },
51  networks: {
52    hardhat: {
53      forking: {
54        url: process.env.MAINNET_RPC_URL,
55        blockNumber: 15000000,
56      },
57    },
58    goerli: {
59      url: process.env.GOERLI_RPC_URL,
60      accounts: [process.env.PRIVATE_KEY],
61    },
62  },
63  gasReporter: {
64    enabled: true,
65    currency: "USD",
66    coinmarketcap: process.env.COINMARKETCAP_API_KEY,
67  },
68  etherscan: {
69    apiKey: process.env.ETHERSCAN_API_KEY,
70  },
71};
72```
73 
74## Unit Testing Patterns
75 
76```javascript
77const { expect } = require("chai");
78const { ethers } = require("hardhat");
79const {
80  loadFixture,
81  time,
82} = require("@nomicfoundation/hardhat-network-helpers");
83 
84describe("Token Contract", function () {
85  // Fixture for test setup
86  async function deployTokenFixture() {
87    const [owner, addr1, addr2] = await ethers.getSigners();
88 
89    const Token = await ethers.getContractFactory("Token");
90    const token = await Token.deploy();
91 
92    return { token, owner, addr1, addr2 };
93  }
94 
95  describe("Deployment", function () {
96    it("Should set the right owner", async function () {
97      const { token, owner } = await loadFixture(deployTokenFixture);
98      expect(await token.owner()).to.equal(owner.address);
99    });
100 
101    it("Should assign total supply to owner", async function () {
102      const { token, owner } = await loadFixture(deployTokenFixture);
103      const ownerBalance = await token.balanceOf(owner.address);
104      expect(await token.totalSupply()).to.equal(ownerBalance);
105    });
106  });
107 
108  describe("Transactions", function () {
109    it("Should transfer tokens between accounts", async function () {
110      const { token, owner, addr1 } = await loadFixture(deployTokenFixture);
111 
112      await expect(token.transfer(addr1.address, 50)).to.changeTokenBalances(
113        token,
114        [owner, addr1],
115        [-50, 50],
116      );
117    });
118 
119    it("Should fail if sender doesn't have enough tokens", async function () {
120      const { token, addr1 } = await loadFixture(deployTokenFixture);
121      const initialBalance = await token.balanceOf(addr1.address);
122 
123      await expect(
124        token.connect(addr1).transfer(owner.address, 1),
125      ).to.be.revertedWith("Insufficient balance");
126    });
127 
128    it("Should emit Transfer event", async function () {
129      const { token, owner, addr1 } = await loadFixture(deployTokenFixture);
130 
131      await expect(token.transfer(addr1.address, 50))
132        .to.emit(token, "Transfer")
133        .withArgs(owner.address, addr1.address, 50);
134    });
135  });
136 
137  describe("Time-based tests", function () {
138    it("Should handle time-locked operations", async function () {
139      const { token } = await loadFixture(deployTokenFixture);
140 
141      // Increase time by 1 day
142      await time.increase(86400);
143 
144      // Test time-dependent functionality
145    });
146  });
147 
148  describe("Gas optimization", function () {
149    it("Should use gas efficiently", async function () {
150      const { token } = await loadFixture(deployTokenFixture);
151 
152      const tx = await token.transfer(addr1.address, 100);
153      const receipt = await tx.wait();
154 
155      expect(receipt.gasUsed).to.be.lessThan(50000);
156    });
157  });
158});
159```
160 
161## Foundry Testing (Forge)
162 
163```solidity
164// SPDX-License-Identifier: MIT
165pragma solidity ^0.8.0;
166 
167import "forge-std/Test.sol";
168import "../src/Token.sol";
169 
170contract TokenTest is Test {
171    Token token;
172    address owner = address(1);
173    address user1 = address(2);
174    address user2 = address(3);
175 
176    function setUp() public {
177        vm.prank(owner);
178        token = new Token();
179    }
180 
181    function testInitialSupply() public {
182        assertEq(token.totalSupply(), 1000000 * 10**18);
183    }
184 
185    function testTransfer() public {
186        vm.prank(owner);
187        token.transfer(user1, 100);
188 
189        assertEq(token.balanceOf(user1), 100);
190        assertEq(token.balanceOf(owner), token.totalSupply() - 100);
191    }
192 
193    function testFailTransferInsufficientBalance() public {
194        vm.prank(user1);
195        token.transfer(user2, 100); // Should fail
196    }
197 
198    function testCannotTransferToZeroAddress() public {
199        vm.prank(owner);
200        vm.expectRevert("Invalid recipient");
201        token.transfer(address(0), 100);
202    }
203 
204    // Fuzzing test
205    function testFuzzTransfer(uint256 amount) public {
206        vm.assume(amount > 0 && amount <= token.totalSupply());
207 
208        vm.prank(owner);
209        token.transfer(user1, amount);
210 
211        assertEq(token.balanceOf(user1), amount);
212    }
213 
214    // Test with cheatcodes
215    function testDealAndPrank() public {
216        // Give ETH to address
217        vm.deal(user1, 10 ether);
218 
219        // Impersonate address
220        vm.prank(user1);
221 
222        // Test functionality
223        assertEq(user1.balance, 10 ether);
224    }
225 
226    // Mainnet fork test
227    function testForkMainnet() public {
228        vm.createSelectFork("https://eth-mainnet.alchemyapi.io/v2/...");
229 
230        // Interact with mainnet contracts
231        address dai = 0x6B175474E89094C44Da98b954EedeAC495271d0F;
232        assertEq(IERC20(dai).symbol(), "DAI");
233    }
234}
235```
236 
237## Advanced Testing Patterns
238 
239### Snapshot and Revert
240 
241```javascript
242describe("Complex State Changes", function () {
243  let snapshotId;
244 
245  beforeEach(async function () {
246    snapshotId = await network.provider.send("evm_snapshot");
247  });
248 
249  afterEach(async function () {
250    await network.provider.send("evm_revert", [snapshotId]);
251  });
252 
253  it("Test 1", async function () {
254    // Make state changes
255  });
256 
257  it("Test 2", async function () {
258    // State reverted, clean slate
259  });
260});
261```
262 
263### Mainnet Forking
264 
265```javascript
266describe("Mainnet Fork Tests", function () {
267  let uniswapRouter, dai, usdc;
268 
269  before(async function () {
270    await network.provider.request({
271      method: "hardhat_reset",
272      params: [
273        {
274          forking: {
275            jsonRpcUrl: process.env.MAINNET_RPC_URL,
276            blockNumber: 15000000,
277          },
278        },
279      ],
280    });
281 
282    // Connect to existing mainnet contracts
283    uniswapRouter = await ethers.getContractAt(
284      "IUniswapV2Router",
285      "0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D",
286    );
287 
288    dai = await ethers.getContractAt(
289      "IERC20",
290      "0x6B175474E89094C44Da98b954EedeAC495271d0F",
291    );
292  });
293 
294  it("Should swap on Uniswap", async function () {
295    // Test with real Uniswap contracts
296  });
297});
298```
299 
300### Impersonating Accounts
301 
302```javascript
303it("Should impersonate whale account", async function () {
304  const whaleAddress = "0x...";
305 
306  await network.provider.request({
307    method: "hardhat_impersonateAccount",
308    params: [whaleAddress],
309  });
310 
311  const whale = await ethers.getSigner(whaleAddress);
312 
313  // Use whale's tokens
314  await dai
315    .connect(whale)
316    .transfer(addr1.address, ethers.utils.parseEther("1000"));
317});
318```
319 
320## Gas Optimization Testing
321 
322```javascript
323const { expect } = require("chai");
324 
325describe("Gas Optimization", function () {
326  it("Compare gas usage between implementations", async function () {
327    const Implementation1 =
328      await ethers.getContractFactory("OptimizedContract");
329    const Implementation2 = await ethers.getContractFactory(
330      "UnoptimizedContract",
331    );
332 
333    const contract1 = await Implementation1.deploy();
334    const contract2 = await Implementation2.deploy();
335 
336    const tx1 = await contract1.doSomething();
337    const receipt1 = await tx1.wait();
338 
339    const tx2 = await contract2.doSomething();
340    const receipt2 = await tx2.wait();
341 
342    console.log("Optimized gas:", receipt1.gasUsed.toString());
343    console.log("Unoptimized gas:", receipt2.gasUsed.toString());
344 
345    expect(receipt1.gasUsed).to.be.lessThan(receipt2.gasUsed);
346  });
347});
348```
349 
350## Coverage Reporting
351 
352```bash
353# Generate coverage report
354npx hardhat coverage
355 
356# Output shows:
357# File                | % Stmts | % Branch | % Funcs | % Lines |
358# -------------------|---------|----------|---------|---------|
359# contracts/Token.sol |   100   |   90     |   100   |   95    |
360```
361 
362## Contract Verification
363 
364```javascript
365// Verify on Etherscan
366await hre.run("verify:verify", {
367  address: contractAddress,
368  constructorArguments: [arg1, arg2],
369});
370```
371 
372```bash
373# Or via CLI
374npx hardhat verify --network mainnet CONTRACT_ADDRESS "Constructor arg1" "arg2"
375```
376 
377## CI/CD Integration
378 
379```yaml
380# .github/workflows/test.yml
381name: Tests
382 
383on: [push, pull_request]
384 
385jobs:
386  test:
387    runs-on: ubuntu-latest
388 
389    steps:
390      - uses: actions/checkout@v2
391      - uses: actions/setup-node@v2
392        with:
393          node-version: "16"
394 
395      - run: npm install
396      - run: npx hardhat compile
397      - run: npx hardhat test
398      - run: npx hardhat coverage
399 
400      - name: Upload coverage to Codecov
401        uses: codecov/codecov-action@v2
402```
403 
404## Resources
405 
406- **references/hardhat-setup.md**: Hardhat configuration guide
407- **references/foundry-setup.md**: Foundry testing framework
408- **references/test-patterns.md**: Testing best practices
409- **references/mainnet-forking.md**: Fork testing strategies
410- **references/contract-verification.md**: Etherscan verification
411- **assets/hardhat-config.js**: Complete Hardhat configuration
412- **assets/test-suite.js**: Comprehensive test examples
413- **assets/foundry.toml**: Foundry configuration
414- **scripts/test-contract.sh**: Automated testing script
415 
416## Best Practices
417 
4181. **Test Coverage**: Aim for >90% coverage
4192. **Edge Cases**: Test boundary conditions
4203. **Gas Limits**: Verify functions don't hit block gas limit
4214. **Reentrancy**: Test for reentrancy vulnerabilities
4225. **Access Control**: Test unauthorized access attempts
4236. **Events**: Verify event emissions
4247. **Fixtures**: Use fixtures to avoid code duplication
4258. **Mainnet Fork**: Test with real contracts
4269. **Fuzzing**: Use property-based testing
42710. **CI/CD**: Automate testing on every commit
428