罗罗编程学习记录 全栈面试题库
本页导航 展开查看

15.4.3 合约测试与本地链工程

所属:全栈开发面试题库 / 15 Web3 与区块链 / 15.4 Solidity 与合约工程

本节要解决的问题

面试里问"怎么测试合约",多数人答"用 Hardhat"。这是入门。真正的分水岭是:能不能说清 Foundry 与 Hardhat 的选型、fork test 与 fuzz test 的区别、invariant test 怎么写、以及 CI 集成。本节解决四个具体问题:一是分清 Foundry 与 Hardhat 的架构差异(Foundry 用 Rust 写测试,Hardhat 用 JS/TS);二是讲清 fork test(复刻主网状态)与 fuzz test(随机输入);三是把 invariant test(性质测试)与 unit test 串起来;四是说明部署脚本与多签治理的流程。

学习目标

学完本节,你应当能够:

  • 对比 Foundry 与 Hardhat 的优缺点,说明什么时候用哪个。
  • 写出 fork test(复刻主网状态)与 fuzz test(随机输入)。
  • 解释 invariant test(性质测试)的原理,以及怎么写。
  • 说明部署脚本与多签治理的流程。

先修与前置

知识地图

测试框架:
  Foundry:Rust 写测试,快,内置 fuzz/invariant
  Hardhat:JS/TS 写测试,生态成熟

测试类型:
  unit test:单个函数测试
  fork test:复刻主网状态测试
  fuzz test:随机输入测试
  invariant test:性质测试(永远不变的属性)

工程化:
  覆盖率:测试覆盖的代码百分比
  CI:自动跑测试
  部署脚本:自动化部署
  多签治理:部署后用多签管理

核心术语

  • Foundry:Rust 写的合约测试框架,快,内置 fuzz/invariant。
  • Hardhat:JS/TS 写的合约测试框架,生态成熟。
  • fork test:复刻主网状态测试,模拟主网环境。
  • fuzz test:随机输入测试,自动生成大量输入。
  • invariant test:性质测试,验证"永远不变的属性"。
  • 覆盖率:测试覆盖的代码百分比。
  • CI:持续集成,自动跑测试。
  • 多签治理:部署后用多签管理合约(如 OpenZeppelin Defender)。

覆盖范围

  • Foundry vs Hardhat 选型
  • 测试类型:unit、fork、fuzz、invariant
  • fork test 与主网状态复刻
  • fuzz test 与随机输入
  • invariant test 与性质测试
  • 覆盖率与 CI 集成
  • 部署脚本与多签治理
  • 测试网与主网的环境隔离

高频题速览

编号 题目 难度 频率
15.4.3-001 Foundry 和 Hardhat 怎么选? 基础 ★★★★★
15.4.3-002 unit test、fork test、fuzz test、invariant test 有什么区别? 基础 ★★★★★
15.4.3-003 fork test 是怎么复刻主网状态的? 进阶 ★★★★
15.4.3-004 fuzz test 怎么写? 进阶 ★★★★
15.4.3-005 invariant test 是什么? 进阶 ★★★★
15.4.3-006 测试中的 mock 怎么用? 进阶 ★★★
15.4.3-007 覆盖率怎么测?CI 怎么集成? 进阶 ★★★
15.4.3-008 调试技巧有哪些? 高级 ★★★
15.4.3-009 部署脚本与多签治理怎么搞? 高级 ★★★
15.4.3-010 测试网与主网怎么隔离? 高级 ★★★

15.4.3-001 Foundry 和 Hardhat 怎么选?

一句话结论

Foundry 用 Rust 写测试,快,内置 fuzz/invariant;Hardhat 用 JS/TS 写测试,生态成熟。选择取决于团队技术栈与性能需求。

概念解释

  • Foundry:Rust 写的测试框架,快,内置 fuzz/invariant,测试用 Solidity 写。
  • Hardhat:JS/TS 写的测试框架,生态成熟,插件多。
  • 选择:Rust/Solidity 团队用 Foundry,JS/TS 团队用 Hardhat。
  • 趋势:Foundry 越来越流行(快、内置 fuzz)。

原理流程

  1. Foundry:测试用 Solidity 写,跑在本地 EVM(revm),快。
  2. Hardhat:测试用 JS/TS 写,跑在 Hardhat Network(本地 EVM)。
  3. Foundry 内置 fuzz/invariant,不用额外插件。
  4. Hardhat 生态成熟,插件多(hardhat-deploy、hardhat-ethers)。
  5. 选择:取决于团队技术栈。

代码或图示

Foundry vs Hardhat:

  Foundry:
    测试语言:Solidity
    性能:快(Rust EVM)
    内置:fuzz、invariant
    适合:Rust/Solidity 团队

  Hardhat:
    测试语言:JS/TS
    性能:中等
    生态:成熟,插件多
    适合:JS/TS 团队

常见误区

  • 误区:Foundry 比 Hardhat 好;正解:两者各有优劣,取决于团队技术栈。
  • 误区:Foundry 测试用 JS 写;正解:Foundry 测试用 Solidity 写。
  • 误区:Hardhat 不能 fuzz;正解:Hardhat 可以用插件(hardhat-fuzz-testing)。

追问

  • Foundry 为什么快?答:因为用 Rust 写 EVM(revm),比 JS EVM 快很多;测试用 Solidity 写,不用跨语言。机制上 Foundry 是原生 EVM。边界在于:这也是 Foundry 越来越流行的原因。延伸:这是测试框架的性能。
  • Hardhat 有什么优点?答:生态成熟,插件多(hardhat-deploy、hardhat-ethers、hardhat-upgrades);JS/TS 团队熟悉。机制上 Hardhat 是 JS 生态。边界在于:性能不如 Foundry。延伸:这是工程生态的选择。
  • 怎么选?答:取决于团队技术栈——Rust/Solidity 团队用 Foundry,JS/TS 团队用 Hardhat。机制上选择取决于团队熟悉度。边界在于:这是工程决策。延伸:这是测试框架的选型。

15.4.3-002 unit test、fork test、fuzz test、invariant test 有什么区别?

一句话结论

unit test 测试单个函数,fork test 复刻主网状态测试,fuzz test 用随机输入测试,invariant test 验证"永远不变的属性"。

概念解释

  • unit test:测试单个函数,给定输入验证输出。
  • fork test:复刻主网状态,模拟主网环境测试。
  • fuzz test:自动生成大量随机输入,验证不崩溃。
  • invariant test:验证"永远不变的属性"(如"余额总和不变")。

原理流程

  1. unit test:给定输入,验证输出。
  2. fork test:从主网 fork 状态,模拟主网环境测试。
  3. fuzz test:自动生成随机输入,验证不崩溃。
  4. invariant test:验证"永远不变的属性"(如"总供应 = 所有用户余额之和")。
  5. 组合:unit + fork + fuzz + invariant 覆盖不同场景。

代码或图示

测试类型:

  unit test:
    function testTransfer() public {
        token.transfer(alice, 100);
        assertEq(token.balanceOf(alice), 100);
    }

  fork test:
    function testFork() public {
        // 从主网 fork 状态
        vm.createSelectFork("mainnet");
        // 测试主网交互
    }

  fuzz test:
    function testFuzz(uint amount) public {
        token.transfer(alice, amount);
        // 验证不崩溃
    }

  invariant test:
    function invariant_totalSupply() public {
        assertEq(token.totalSupply(), sumOfBalances());
    }

常见误区

  • 误区:unit test 就够了;正解:unit + fork + fuzz + invariant 覆盖不同场景。
  • 误区:fuzz test 就是随机测试;正解:fuzz test 自动生成大量随机输入,验证不崩溃。
  • 误区:invariant test 就是 unit test;正解:invariant test 验证"永远不变的属性"。

追问

  • 为什么需要 fork test?答:因为合约要与主网交互(如 Uniswap 池子),fork test 复刻主网状态,模拟真实环境。机制上 fork test 从主网拉取状态。边界在于:fork test 依赖 RPC 节点。延伸:这是 DApp 测试的重点。
  • fuzz test 有什么用?答:自动生成大量随机输入,发现边界情况与崩溃;比手动测试覆盖更多场景。机制上 fuzz test 自动生成输入。边界在于:fuzz test 不验证业务逻辑,只验证不崩溃。延伸:这是测试自动化。
  • invariant test 有什么用?答:验证"永远不变的属性"(如"余额总和不变"),发现意外状态不一致。机制上 invariant test 在每次操作后验证属性。边界在于:要识别哪些属性是不变的。延伸:这是 15.5 审计的重点。

15.4.3-003 fork test 是怎么复刻主网状态的?

一句话结论

fork test 通过 RPC 节点拉取主网状态(区块号、账户、存储),在本地 EVM 里模拟;可以测试与主网交互的场景(如 Uniswap 池子)。

概念解释

  • fork test:从主网 fork 状态,在本地 EVM 模拟。
  • RPC 节点:从主网拉取状态(账户、存储、合约代码)。
  • 用途:测试与主网交互的场景。
  • 例子:测试在 Uniswap 池子上 swap。

原理流程

  1. 指定主网 RPC 与区块号:vm.createSelectFork("https://mainnet.infura.io/v3/...", 18000000)。
  2. 测试框架从 RPC 拉取该区块的状态(账户、存储、合约代码)。
  3. 在本地 EVM 里模拟,可以修改状态(如 vm.prank)。
  4. 测试与主网交互的场景(如 Uniswap swap)。
  5. 不影响主网状态(只在本地模拟)。

代码或图示

// Foundry fork test
import "forge-std/Test.sol";

contract ForkTest is Test {
    function setUp() public {
        // 从主网 fork 区块 18000000
        vm.createSelectFork("https://mainnet.infura.io/v3/...", 18000000);
    }

    function testSwap() public {
        // 模拟用户
        address user = address(0x1234);
        vm.prank(user);

        // 与主网 Uniswap 池子交互
        IUniswapV2Router router = IUniswapV2Router(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
        router.swapExactTokensForTokens(...);
    }
}

常见误区

  • 误区:fork test 会影响主网;正解:fork test 只在本地模拟,不影响主网。
  • 误区:fork test 不需要 RPC;正解:fork test 从 RPC 拉取状态。
  • 误区:fork test 就是主网测试;正解:fork test 是本地模拟主网状态。

追问

  • fork test 有什么用?答:测试与主网交互的场景(如 Uniswap 池子、预言机),模拟真实环境。机制上 fork test 复刻主网状态。边界在于:fork test 依赖 RPC 节点(要 archive 节点查历史状态)。延伸:这是 DApp 测试的重点。
  • 怎么 fork 历史状态?答:指定区块号,从 RPC 拉取该区块的状态;需要 archive 节点。机制上 fork test 从 RPC 拉取状态。边界在于:archive 节点成本高。延伸:这是 15.3.5 的主题。
  • fork test 与主网测试的区别?答:fork test 是本地模拟,不影响主网;主网测试是真实交易,影响主网。机制上 fork test 是本地 EVM。边界在于:fork test 更快、更便宜。延伸:这是测试的分层。

15.4.3-004 fuzz test 怎么写?

一句话结论

fuzz test 就是在测试函数里加参数,测试框架自动生成随机输入,验证不崩溃。

概念解释

  • fuzz test:测试函数带参数,测试框架自动生成随机输入。
  • 验证:不崩溃(不 revert、不 OOG)。
  • Foundry 内置 fuzz,Hardhat 用插件。
  • 用途:发现边界情况与崩溃。

原理流程

  1. 写测试函数带参数:function testFuzz(uint amount) public { ... }。
  2. 测试框架自动生成大量随机 amount(如 256 次)。
  3. 每次运行测试,验证不崩溃。
  4. 如果崩溃,测试框架报告输入与堆栈。
  5. 用途:发现边界情况。

代码或图示

// Foundry fuzz test
function testFuzz_Transfer(uint amount) public {
    // 假设:amount <= balance
    vm.assume(amount < token.balanceOf(address(this)));

    token.transfer(alice, amount);
    assertEq(token.balanceOf(alice), amount);
}

常见误区

  • 误区:fuzz test 验证业务逻辑;正解:fuzz test 只验证不崩溃。
  • 误区:fuzz test 手动生成输入;正解:测试框架自动生成。
  • 误区:fuzz test 不需要断言;正解:fuzz test 可以加断言(如 invariant)。

追问

  • fuzz test 有什么用?答:自动生成大量随机输入,发现边界情况与崩溃;比手动测试覆盖更多场景。机制上 fuzz test 自动生成输入。边界在于:fuzz test 不验证业务逻辑(只验证不崩溃)。延伸:这是测试自动化。
  • 怎么限制输入空间?答:用 vm.assume 限制输入(如 vm.assume(amount < balance))。机制上 fuzz test 自动过滤不符合假设的输入。边界在于:太严格的假设会让 fuzz 无效。延伸:这是 fuzz 测试的技巧。
  • fuzz test 与 invariant test 的区别?答:fuzz test 自动生成输入,验证不崩溃;invariant test 验证"永远不变的属性"。机制上 fuzz 是随机输入,invariant 是属性验证。边界在于:两者配合使用。延伸:这是测试的分层。

15.4.3-005 invariant test 是什么?

一句话结论

invariant test 验证"永远不变的属性"(如"总供应 = 所有用户余额之和");测试框架自动生成操作,每次操作后验证属性。

概念解释

  • invariant:永远不变的属性(如"余额总和不变")。
  • invariant test:自动生成操作,每次操作后验证 invariant。
  • 用途:发现意外状态不一致。
  • Foundry 内置 invariant,Hardhat 用插件。

原理流程

  1. 定义 invariant:function invariant_totalSupply() public { assertEq(token.totalSupply(), sumOfBalances()); }
  2. 定义 handler:自动生成操作(如 transfer、approve)。
  3. 测试框架自动生成操作序列,每次操作后验证 invariant。
  4. 如果 invariant 被破坏,测试报告操作序列。
  5. 用途:发现意外状态不一致。

代码或图示

// Foundry invariant test
function invariant_totalSupply() public {
    uint sum = 0;
    for (uint i = 0; i < users.length; i++) {
        sum += token.balanceOf(users[i]);
    }
    assertEq(token.totalSupply(), sum);
}

// Handler:自动生成操作
contract Handler is Test {
    function transfer(uint amount) public {
        token.transfer(alice, amount);
    }
}

常见误区

  • 误区:invariant test 就是 unit test;正解:invariant test 验证"永远不变的属性"。
  • 误区:invariant test 手动写操作;正解:测试框架自动生成操作。
  • 误区:invariant test 只验证不崩溃;正解:invariant test 验证属性。

追问

  • invariant test 有什么用?答:发现意外状态不一致(如"余额总和不变"被破坏);比 unit test 覆盖更多场景。机制上 invariant test 自动生成操作,验证属性。边界在于:要识别哪些属性是不变的。延伸:这是 15.5 审计的重点。
  • 怎么写 invariant?答:识别"永远不变的属性"(如"总供应 = 余额总和"、"价格 = 储备比例");写断言。机制上 invariant test 在每次操作后验证。边界在于:不是所有属性都不变(如"余额会变")。延伸:这是测试设计的重点。
  • invariant test 与 fuzz test 的区别?答:fuzz test 自动生成输入,验证不崩溃;invariant test 验证属性。机制上两者配合使用。边界在于:fuzz 是随机输入,invariant 是属性验证。延伸:这是测试的分层。

15.4.3-006 测试中的 mock 怎么用?

一句话结论

mock 是替身合约,模拟外部合约的行为;用于测试不依赖真实外部合约的场景。

概念解释

  • mock:替身合约,模拟外部合约行为。
  • 用途:测试不依赖真实外部合约(如预言机、Uniswap 池子)。
  • 例子:MockOracle 模拟 Chainlink 价格。
  • Foundry/Hardhat 都支持 mock。

原理流程

  1. 写 mock 合约:contract MockOracle { int256 price = 100; function latestRoundData() external view returns (...) { return (0, price, 0, 0, 0); } }
  2. 测试时用 mock 代替真实合约。
  3. 可以设置 mock 的行为(如 mockOracle.setPrice(200))。
  4. 用途:测试不依赖真实外部合约。
  5. 配合 fork test:fork test 用真实合约,mock 用于单元测试。

代码或图示

// Mock 预言机
contract MockOracle {
    int256 public price = 100;

    function setPrice(int256 _price) external {
        price = _price;
    }

    function latestRoundData() external view returns (
        uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound
    ) {
        return (0, price, 0, 0, 0);
    }
}

// 测试
function testPrice() public {
    MockOracle mock = new MockOracle();
    mock.setPrice(200);

    MyContract c = new MyContract(address(mock));
    assertEq(c.getPrice(), 200);
}

常见误区

  • 误区:mock 就是真实合约;正解:mock 是替身,模拟行为。
  • 误区:mock 用于生产;正解:mock 只用于测试。
  • 误区:mock 与 fork test 一样;正解:fork test 用真实合约,mock 用于单元测试。

追问

  • mock 有什么用?答:测试不依赖真实外部合约(如预言机、Uniswap 池子);可以控制 mock 行为。机制上 mock 是替身。边界在于:mock 不能替代 fork test(真实交互)。延伸:这是测试分层。
  • 怎么写 mock?答:写一个合约,实现与真实合约相同的接口,但行为可控制。机制上 mock 实现接口。边界在于:mock 要与真实合约接口一致。延伸:这是测试设计。
  • mock 与 fork test 的区别?答:fork test 用真实合约,mock 用于单元测试;两者配合使用。机制上 fork 是真实交互,mock 是隔离测试。边界在于:两者互补。延伸:这是测试分层。

15.4.3-007 覆盖率怎么测?CI 怎么集成?

一句话结论

覆盖率测试用工具统计测试覆盖的代码百分比;CI 集成让测试自动跑(每次提交)。

概念解释

  • 覆盖率:测试覆盖的代码百分比(行、分支)。
  • 工具:Foundry(forge coverage)、Hardhat(solidity-coverage)。
  • CI:持续集成,每次提交自动跑测试。
  • 例子:GitHub Actions 跑 Foundry 测试。

原理流程

  1. 跑覆盖率工具:forge coverage 统计覆盖的代码百分比。
  2. CI 配置:每次提交自动跑测试(GitHub Actions、GitLab CI)。
  3. 覆盖率报告:查看哪些代码没被测试覆盖。
  4. 目标:覆盖率 > 90%。
  5. CI 失败:测试失败时阻止合并。

代码或图示

# GitHub Actions 示例
name: CI
on: [push]
jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - uses: foundry-rs/foundry-toolchain@v1
      - run: forge test
      - run: forge coverage

常见误区

  • 误区:覆盖率 100% 就够了;正解:覆盖率只是参考,关键是测试质量。
  • 误区:CI 手动跑;正解:CI 自动跑(每次提交)。
  • 误区:覆盖率不重要;正解:覆盖率帮助发现未测试的代码。

追问

  • 覆盖率有什么用?答:发现未测试的代码,提高测试质量。机制上覆盖率工具统计执行过的代码。边界在于:覆盖率只是参考,不是目标。延伸:这是工程质量。
  • CI 有什么用?答:每次提交自动跑测试,防止引入 bug。机制上 CI 自动跑测试。边界在于:CI 失败时阻止合并。延伸:这是工程实践。
  • 怎么提高覆盖率?答:写更多测试(unit、fork、fuzz、invariant);覆盖边界情况。机制上覆盖率是结果。边界在于:不要为了覆盖率而写无意义测试。延伸:这是测试设计。

15.4.3-008 调试技巧有哪些?

一句话结论

调试技巧:console.log(打印变量)、trace(交易执行轨迹)、debugger(断点)。

概念解释

  • console.log:在测试里打印变量。
  • trace:交易执行轨迹(操作码、Gas)。
  • debugger:断点调试。
  • Foundry:console.log、forge trace。

原理流程

  1. console.log:在测试里打印变量(console.log("balance:", balance))。
  2. trace:查看交易执行轨迹(操作码、Gas、栈状态)。
  3. debugger:断点调试(Hardhat Network 支持)。
  4. 用途:定位 bug。
  5. Foundry 有 console.log 与 forge trace。

代码或图示

// Foundry console.log
function testDebug() public {
    token.transfer(alice, 100);
    console.log("alice balance:", token.balanceOf(alice));  // 打印变量
}

// forge trace:查看交易执行轨迹
// $ forge test -vvvv

常见误区

  • 误区:调试只能用 console.log;正解:trace 与 debugger 更强大。
  • 误区:trace 是生产用;正解:trace 用于调试。
  • 误区:console.log 影响 Gas;正解:console.log 只在测试里,不影响生产。

追问

  • trace 有什么用?答:查看交易执行轨迹(操作码、Gas、栈状态),定位 bug。机制上 trace 记录每步执行。边界在于:trace 很长,要过滤。延伸:这是调试的重点。
  • 怎么调试?答:先用 console.log 打印变量,再用 trace 查看执行轨迹,最后用 debugger 断点。机制上分层调试。边界在于:这是工程实践。延伸:这是开发者的技能。
  • Foundry 有什么调试工具?答:console.log、forge trace(-vvvv)、forge debug。机制上 Foundry 内置调试工具。边界在于:Hardhat 也有调试工具。延伸:这是测试框架的功能。

15.4.3-009 部署脚本与多签治理怎么搞?

一句话结论

部署脚本自动化部署流程;多签治理让部署后用多签管理(如 OpenZeppelin Defender)。

概念解释

  • 部署脚本:自动化部署(Foundry script、Hardhat deploy)。
  • 多签治理:部署后用多签管理(如 OpenZeppelin Defender、Safe)。
  • 流程:部署 → 验证源码 → 多签接管。
  • 例子:Foundry script 部署 ERC20。

原理流程

  1. 写部署脚本:Foundry script(Solidity)或 Hardhat deploy(JS)。
  2. 跑脚本:部署合约、初始化。
  3. 验证源码:Etherscan 验证合约源码。
  4. 多签接管:把 admin 转给多签(Safe)。
  5. 流程:部署 → 验证 → 多签接管。

代码或图示

// Foundry 部署脚本
import "forge-std/Script.sol";

contract DeployScript is Script {
    function run() public {
        vm.startBroadcast(privateKey);

        MyToken token = new MyToken("MyToken", "MTK", 1000000);

        vm.stopBroadcast();
    }
}

常见误区

  • 误区:部署手动搞;正解:部署脚本自动化。
  • 误区:部署后用 EOA 管理;正解:部署后用多签管理。
  • 误区:验证源码不重要;正解:验证源码让用户信任合约。

追问

  • 部署脚本有什么用?答:自动化部署流程,减少人为错误。机制上部署脚本可重复。边界在于:部署脚本要安全(私钥管理)。延伸:这是工程实践。
  • 多签治理有什么用?答:部署后用多签管理(如升级、暂停),减少单点风险。机制上多签需要多个签名才能执行。边界在于:这是协议治理。延伸:这是 15.4.2 的主题。
  • 怎么验证源码?答:用 Etherscan 验证合约源码,让用户可以查看代码。机制上验证源码让用户信任。边界在于:这是协议透明度。延伸:这是工程实践。

15.4.3-010 测试网与主网怎么隔离?

一句话结论

测试网与主网隔离:用不同的 RPC、不同的私钥、不同的配置;测试网用于测试,主网用于生产。

概念解释

  • 测试网:Sepolia、Holesky,用于测试。
  • 主网:以太坊主网,生产环境。
  • 隔离:不同 RPC、不同私钥、不同配置。
  • 流程:测试网测试 → 主网部署。

原理流程

  1. 测试网:用 Sepolia/Holesky 测试,用测试网 ETH。
  2. 主网:用主网部署,用主网 ETH。
  3. 隔离:不同 RPC、不同私钥、不同配置(.env 文件)。
  4. 流程:测试网测试通过 → 主网部署。
  5. 注意:测试网与主网的合约地址不同。

代码或图示

测试网 vs 主网隔离:

  测试网(Sepolia):
    RPC:https://sepolia.infura.io
    私钥:测试网私钥
    配置:.env.sepolia
    ETH:测试网 ETH(免费)

  主网:
    RPC:https://mainnet.infura.io
    私钥:主网私钥(硬件钱包)
    配置:.env.mainnet
    ETH:主网 ETH(真实)

  流程:
    测试网测试通过 → 主网部署

常见误区

  • 误区:测试网与主网用同一私钥;正解:测试网与主网用不同私钥。
  • 误区:测试网与主网合约地址相同;正解:测试网与主网合约地址不同。
  • 误区:测试网测试通过就一定安全;正解:测试网与主网环境不同(Gas、合约)。

追问

  • 为什么要隔离?答:防止测试网私钥泄露影响主网;测试网与主网环境不同。机制上隔离减少风险。边界在于:这是工程实践。延伸:这是安全的重点。
  • 测试网与主网有什么区别?答:测试网用测试 ETH(免费),主网用真实 ETH;测试网与主网合约地址不同。机制上环境隔离。边界在于:测试网测试通过不代表主网安全。延伸:这是测试分层。
  • 怎么隔离?答:用不同 RPC、不同私钥、不同配置文件(.env)。机制上环境变量隔离。边界在于:这是工程实践。延伸:这是开发者的技能。

动手练习

练习 1:用 Foundry 写一个完整测试套件

  • 任务:为一个 ERC20 合约写 unit test、fuzz test、invariant test。
  • 验收标准:
    1. 能写出 unit test。
    2. 能写出 fuzz test。
    3. 能写出 invariant test。

练习 2:写一个 fork test

  • 任务:从主网 fork Uniswap 状态,测试 swap 操作。
  • 验收标准:
    1. 能写出 fork test。
    2. 能模拟用户交互。
    3. 能验证 swap 结果。

自检清单

  • [ ] 能对比 Foundry 与 Hardhat?
  • [ ] 能区分四种测试类型?
  • [ ] 能写出 fork test?
  • [ ] 能写出 fuzz test?
  • [ ] 能写出 invariant test?
  • [ ] 能使用 mock?
  • [ ] 能配置覆盖率与 CI?
  • [ ] 能使用调试技巧?
  • [ ] 能写部署脚本与多签治理?
  • [ ] 能隔离测试网与主网?

延伸阅读

  • Foundry 官方文档:测试、fork、fuzz、invariant。
  • Hardhat 官方文档:测试、部署。
  • OpenZeppelin Defender:多签治理。
  • 《Foundry Book》:测试与部署。

待整理清单

  • [ ] 补充 Foundry 最新版本特性(待确认)
  • [ ] 补充 CI 配置的最佳实践
  • [ ] 补充多签治理的实际案例