Agent Skills
Discover and share powerful Agent Skills for AI assistants
web3-testing - Agent Skill - Agent Skills
Home/ Skills / web3-testing 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.
Use the skills CLI to install this skill with one command. Auto-detects all installed AI assistants.
Method 1 - skills CLI
npx skills i wshobson/agents/plugins/blockchain-web3/skills/web3-testing CopyMethod 2 - openskills (supports sync & update)
npx openskills install wshobson/agents CopyAuto-detects Claude Code, Cursor, Codex CLI, Gemini CLI, and more. One install, works everywhere.
Installation Path
Download and extract to one of the following locations:
Claude Code Cursor OpenCode Gemini CLI Codex CLI
~/.claude/skills/web3-testing/ Back No setup needed. Let our cloud agents run this skill for you.
Select Model
Claude Haiku 4.5 $0.10 Claude Sonnet 4.5 $0.20 Claude Opus 4.5 $0.50 Claude Sonnet 4.5 $0.20 /task
Best for coding tasks
Try NowNo setup required
Web3 Smart Contract Testing
Master comprehensive testing strategies for smart contracts using Hardhat, Foundry, and advanced testing patterns.
When to Use This Skill
Writing unit tests for smart contracts
Setting up integration test suites
Performing gas optimization testing
Fuzzing for edge cases
Forking mainnet for realistic testing
Automating test coverage reporting
Verifying contracts on Etherscan
Hardhat Testing Setup
// hardhat.config.js
require ( "@nomicfoundation/hardhat-toolbox" );
require ( "@nomiclabs/hardhat-etherscan" );
require ( "hardhat-gas-reporter" );
require ( "solidity-coverage" );
module . exports = {
solidity: {
version: "0.8.19" ,
settings: {
optimizer: {
enabled: true ,
runs: 200 ,
},
},
},
networks: {
hardhat: {
forking: {
url: process.env. MAINNET_RPC_URL ,
blockNumber: 15000000 ,
},
},
goerli: {
url: process.env. GOERLI_RPC_URL ,
accounts: [process.env. PRIVATE_KEY ],
},
},
gasReporter: {
enabled: true ,
currency: "USD" ,
coinmarketcap: process.env. COINMARKETCAP_API_KEY ,
},
etherscan: {
apiKey: process.env. ETHERSCAN_API_KEY ,
},
};
Unit Testing Patterns
const {
Foundry Testing (Forge)
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0 ;
import "forge-std/Test.sol" ;
import "../src/Token.sol" ;
Advanced Testing Patterns
Snapshot and Revert
describe ( "Complex State Changes" , function () {
let snapshotId;
beforeEach ( async function () {
snapshotId = await network.provider. send ( "evm_snapshot" );
});
afterEach ( async function () {
await network.provider. send (
Mainnet Forking
describe ( "Mainnet Fork Tests" , function () {
let uniswapRouter, dai, usdc;
before ( async function () {
await network.provider. request ({
method: "hardhat_reset" ,
params: [
{
forking: {
jsonRpcUrl: process.env. MAINNET_RPC_URL
Impersonating Accounts
it ( "Should impersonate whale account" , async function () {
const whaleAddress = "0x..." ;
await network.provider. request ({
method: "hardhat_impersonateAccount" ,
params: [whaleAddress],
});
const whale = await ethers. getSigner (whaleAddress);
// Use whale's tokens
Gas Optimization Testing
const { expect } = require ( "chai" );
describe ( "Gas Optimization" , function () {
it ( "Compare gas usage between implementations" , async function () {
const Implementation1 =
await ethers.
Coverage Reporting
# Generate coverage report
npx hardhat coverage
# Output shows:
# File | % Stmts | % Branch | % Funcs | % Lines |
# -------------------|---------|----------|---------|---------|
# contracts/Token.sol | 100 | 90 | 100 | 95 |
Contract Verification
// Verify on Etherscan
await hre. run ( "verify:verify" , {
address: contractAddress,
constructorArguments: [arg1, arg2],
});
# Or via CLI
npx hardhat verify --network mainnet CONTRACT_ADDRESS "Constructor arg1" "arg2"
CI/CD Integration
# .github/workflows/test.yml
name : Tests
on : [ push , pull_request ]
jobs :
test :
runs-on : ubuntu-latest
steps :
- uses : actions/checkout@v2
- uses : actions/setup-node@v2
with :
Resources
references/hardhat-setup.md : Hardhat configuration guide
references/foundry-setup.md : Foundry testing framework
references/test-patterns.md : Testing best practices
references/mainnet-forking.md : Fork testing strategies
references/contract-verification.md : Etherscan verification
assets/hardhat-config.js : Complete Hardhat configuration
assets/test-suite.js : Comprehensive test examples
assets/foundry.toml : Foundry configuration
scripts/test-contract.sh : Automated testing script
Best Practices
Test Coverage : Aim for >90% coverage
Edge Cases : Test boundary conditions
Gas Limits : Verify functions don't hit block gas limit
Reentrancy : Test for reentrancy vulnerabilities
Access Control : Test unauthorized access attempts
Events : Verify event emissions
Fixtures : Use fixtures to avoid code duplication
Mainnet Fork : Test with real contracts
Fuzzing : Use property-based testing
CI/CD : Automate testing on every commit
expect
}
=
require
(
"chai"
);
const { ethers } = require ( "hardhat" );
const {
loadFixture ,
time ,
} = require ( "@nomicfoundation/hardhat-network-helpers" );
describe ( "Token Contract" , function () {
// Fixture for test setup
async function deployTokenFixture () {
const [ owner , addr1 , addr2 ] = await ethers. getSigners ();
const Token = await ethers. getContractFactory ( "Token" );
const token = await Token. deploy ();
return { token, owner, addr1, addr2 };
}
describe ( "Deployment" , function () {
it ( "Should set the right owner" , async function () {
const { token , owner } = await loadFixture (deployTokenFixture);
expect ( await token. owner ()).to. equal (owner.address);
});
it ( "Should assign total supply to owner" , async function () {
const { token , owner } = await loadFixture (deployTokenFixture);
const ownerBalance = await token. balanceOf (owner.address);
expect ( await token. totalSupply ()).to. equal (ownerBalance);
});
});
describe ( "Transactions" , function () {
it ( "Should transfer tokens between accounts" , async function () {
const { token , owner , addr1 } = await loadFixture (deployTokenFixture);
await expect (token. transfer (addr1.address, 50 )).to. changeTokenBalances (
token,
[owner, addr1],
[ - 50 , 50 ],
);
});
it ( "Should fail if sender doesn't have enough tokens" , async function () {
const { token , addr1 } = await loadFixture (deployTokenFixture);
const initialBalance = await token. balanceOf (addr1.address);
await expect (
token. connect (addr1). transfer (owner.address, 1 ),
).to.be. revertedWith ( "Insufficient balance" );
});
it ( "Should emit Transfer event" , async function () {
const { token , owner , addr1 } = await loadFixture (deployTokenFixture);
await expect (token. transfer (addr1.address, 50 ))
.to. emit (token, "Transfer" )
. withArgs (owner.address, addr1.address, 50 );
});
});
describe ( "Time-based tests" , function () {
it ( "Should handle time-locked operations" , async function () {
const { token } = await loadFixture (deployTokenFixture);
// Increase time by 1 day
await time. increase ( 86400 );
// Test time-dependent functionality
});
});
describe ( "Gas optimization" , function () {
it ( "Should use gas efficiently" , async function () {
const { token } = await loadFixture (deployTokenFixture);
const tx = await token. transfer (addr1.address, 100 );
const receipt = await tx. wait ();
expect (receipt.gasUsed).to.be. lessThan ( 50000 );
});
});
});
contract TokenTest is Test {
Token token;
address owner = address ( 1 );
address user1 = address ( 2 );
address user2 = address ( 3 );
function setUp () public {
vm. prank (owner);
token = new Token ();
}
function testInitialSupply () public {
assertEq (token. totalSupply (), 1000000 * 10 ** 18 );
}
function testTransfer () public {
vm. prank (owner);
token. transfer (user1, 100 );
assertEq (token. balanceOf (user1), 100 );
assertEq (token. balanceOf (owner), token. totalSupply () - 100 );
}
function testFailTransferInsufficientBalance () public {
vm. prank (user1);
token. transfer (user2, 100 ); // Should fail
}
function testCannotTransferToZeroAddress () public {
vm. prank (owner);
vm. expectRevert ( "Invalid recipient" );
token. transfer ( address ( 0 ), 100 );
}
// Fuzzing test
function testFuzzTransfer ( uint256 amount ) public {
vm. assume (amount > 0 && amount <= token. totalSupply ());
vm. prank (owner);
token. transfer (user1, amount);
assertEq (token. balanceOf (user1), amount);
}
// Test with cheatcodes
function testDealAndPrank () public {
// Give ETH to address
vm. deal (user1, 10 ether );
// Impersonate address
vm. prank (user1);
// Test functionality
assertEq (user1.balance, 10 ether );
}
// Mainnet fork test
function testForkMainnet () public {
vm. createSelectFork ( "https://eth-mainnet.alchemyapi.io/v2/..." );
// Interact with mainnet contracts
address dai = 0x6B175474E89094C44Da98b954EedeAC495271d0F ;
assertEq ( IERC20 (dai). symbol (), "DAI" );
}
}
"evm_revert"
, [snapshotId]);
});
it ( "Test 1" , async function () {
// Make state changes
});
it ( "Test 2" , async function () {
// State reverted, clean slate
});
});
,
blockNumber: 15000000 ,
},
},
],
});
// Connect to existing mainnet contracts
uniswapRouter = await ethers. getContractAt (
"IUniswapV2Router" ,
"0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D" ,
);
dai = await ethers. getContractAt (
"IERC20" ,
"0x6B175474E89094C44Da98b954EedeAC495271d0F" ,
);
});
it ( "Should swap on Uniswap" , async function () {
// Test with real Uniswap contracts
});
});
await
dai
. connect (whale)
. transfer (addr1.address, ethers.utils. parseEther ( "1000" ));
});
getContractFactory
(
"OptimizedContract"
);
const Implementation2 = await ethers. getContractFactory (
"UnoptimizedContract" ,
);
const contract1 = await Implementation1. deploy ();
const contract2 = await Implementation2. deploy ();
const tx1 = await contract1. doSomething ();
const receipt1 = await tx1. wait ();
const tx2 = await contract2. doSomething ();
const receipt2 = await tx2. wait ();
console. log ( "Optimized gas:" , receipt1.gasUsed. toString ());
console. log ( "Unoptimized gas:" , receipt2.gasUsed. toString ());
expect (receipt1.gasUsed).to.be. lessThan (receipt2.gasUsed);
});
});
node-version : "16"
- run : npm install
- run : npx hardhat compile
- run : npx hardhat test
- run : npx hardhat coverage
- name : Upload coverage to Codecov
uses : codecov/codecov-action@v2