智能合约与以太坊 / 系统课时

检查总资产与债务守恒条件

检查总资产与债务守恒条件

代币金库在充值、提现和收取手续费后,合约记录的用户资产与实际持币余额可能出现偏差。本课使用 Solidity 建立资产、债务和手续费之间的会计关系,并通过 Foundry 测试验证每次操作后的守恒条件,识别漏记账、重复扣款与意外转账造成的异常。

学习目标

  • 区分金库实际余额、用户债务、手续费负债和未入账资产。
  • 为充值、提现及手续费操作编写可执行的守恒断言。
  • 使用 Foundry 不变量测试检查多次操作后的账实偏差,并理解断言的边界。

定义资产与负债的会计关系

假设一个金库接收标准 ERC-20 代币,用户充值后获得等额的内部余额;提现时销毁相应内部余额;收取的手续费留在金库,等待管理员领取。

定义四个以代币最小单位计量的变量:

  • A:代币合约 balanceOf(vault) 返回的实际余额。
  • D:所有用户可提取余额之和,即金库对用户的债务。
  • F:累计已收取但尚未领取的手续费,即手续费负债。
  • S:意外转入、未分配的代币余额。

完整会计关系为:

A=D+F+SA=D+F+S

当金库不允许主动记账外捐赠,且没有额外转入时,S=0,可采用严格守恒条件 A=D+F。真实 ERC-20 允许其他地址直接向金库转账,因此不能无条件假定 S 永远为零。

例如初始充值 1000 单位,用户提现 200 单位并支付 2 单位手续费。提现实际向用户转出 198 单位,用户债务减少 200 单位,手续费负债增加 2 单位。

操作 实际余额 A 用户债务 D 手续费负债 F
初始 0 0 0
充值 1000 1000 1000 0
提现扣账 200,实付 198 802 800 2
领取手续费 2 800 800 0

每一步都满足 A=D+F。如果提现时忘记减少用户债务,实际余额仍为 802,但账面负债变为 1002,便会出现 200 单位的资金缺口。

在充值和提现中维护守恒关系

以下 Solidity 0.8.24 示例使用 OpenZeppelin Contracts 5.x 的 SafeERC20,限定使用无转账税、无自动重基准、无转账回调副作用且符合常规 ERC-20 行为的代币。为了把审计重点放在会计关系上,示例使用固定的 1% 提现手续费。

solidity
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

import {IERC20} from '@openzeppelin/contracts/token/ERC20/IERC20.sol';
import {SafeERC20} from '@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol';
import {ReentrancyGuard} from '@openzeppelin/contracts/utils/ReentrancyGuard.sol';

contract AccountingVault is ReentrancyGuard {
    using SafeERC20 for IERC20;

    IERC20 public immutable token;
    mapping(address => uint256) public deposits;
    uint256 public totalDebt;
    uint256 public accruedFees;

    constructor(IERC20 asset) {
        require(address(asset) != address(0), 'zero token');
        token = asset;
    }

    function deposit(uint256 amount) external nonReentrant {
        require(amount > 0, 'zero amount');
        uint256 beforeBalance = token.balanceOf(address(this));
        token.safeTransferFrom(msg.sender, address(this), amount);
        // 不允许转账税代币导致实际到账少于账面增量。
        require(
            token.balanceOf(address(this)) - beforeBalance == amount,
            'unexpected deposit amount'
        );
        deposits[msg.sender] += amount;
        totalDebt += amount;
    }

    function withdraw(uint256 amount) external nonReentrant {
        require(amount > 0 && deposits[msg.sender] >= amount, 'invalid amount');
        uint256 fee = amount / 100;
        uint256 payout = amount - fee;
        // 先减少用户债务,再执行外部代币转账。
        deposits[msg.sender] -= amount;
        totalDebt -= amount;
        accruedFees += fee;
        token.safeTransfer(msg.sender, payout);
    }

    function accountingGap() external view returns (uint256 surplus, uint256 deficit) {
        uint256 assets = token.balanceOf(address(this));
        uint256 liabilities = totalDebt + accruedFees;
        if (assets >= liabilities) return (assets - liabilities, 0);
        return (0, liabilities - assets);
    }
}

totalDebt 是所有用户余额的汇总缓存,必须与每次 deposits 增减同步。accruedFees 是待领取手续费,不能在用户提现时直接从总负债中消失。

accountingGap() 避免直接执行可能因余额不足而回退的减法,分别返回盈余和缺口。对标准代币、无外部转入的正常操作,两个值应始终为零。

使用 Foundry 编写守恒测试

在已安装 Foundry 的 Solidity 项目中,安装 OpenZeppelin Contracts 5.x 和 forge-std,将上面的合约保存为 src/AccountingVault.sol。以下测试使用真实的 ERC20 实现构造测试代币,并用充值、提现后的具体金额检查会计关系。

solidity
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

import {Test} from 'forge-std/Test.sol';
import {ERC20} from '@openzeppelin/contracts/token/ERC20/ERC20.sol';
import {AccountingVault} from '../src/AccountingVault.sol';

contract MockToken is ERC20 {
    constructor() ERC20('Mock Token', 'MOCK') {}

    function mint(address to, uint256 amount) external {
        _mint(to, amount);
    }
}

contract AccountingVaultTest is Test {
    MockToken token;
    AccountingVault vault;
    address user = address(0xBEEF);

    function setUp() public {
        token = new MockToken();
        vault = new AccountingVault(token);
        token.mint(user, 1000 ether);
        vm.prank(user);
        token.approve(address(vault), type(uint256).max);
    }

    function testDepositAndWithdrawConservation() public {
        vm.startPrank(user);
        vault.deposit(1000 ether);
        vault.withdraw(200 ether);
        vm.stopPrank();

        // 提现手续费为 2,用户实际收到 198。
        assertEq(vault.totalDebt(), 800 ether);
        assertEq(vault.accruedFees(), 2 ether);
        assertEq(token.balanceOf(address(vault)), 802 ether);
        assertEq(token.balanceOf(user), 198 ether);

        (uint256 surplus, uint256 deficit) = vault.accountingGap();
        assertEq(surplus, 0);
        assertEq(deficit, 0);
    }
}

在项目根目录执行测试:

bash
forge test --match-test testDepositAndWithdrawConservation

预期结果(测试通过时的关键摘要,耗时可能不同):

text
[PASS] testDepositAndWithdrawConservation()
Suite result: ok. 1 passed; 0 failed

这里的 ether 只是 Solidity 中表示 101810^{18} 的整数单位,适用于测试代币采用 18 位精度的场景,不代表金库处理的是 ETH。若真实代币采用 6 位精度,应使用与其精度一致的原始整数金额。

把单次断言扩展成不变量

单次测试只能检查一条预定操作序列。Foundry 支持 invariant_ 前缀的不变量测试:由模糊测试引擎反复执行目标合约的可调用函数,并在操作序列之间检查约束。

在同一测试文件中追加以下独立测试合约。它继承前面的测试夹具,并将操作限制为测试用户以固定调用者身份发起的充值和提现,避免随机地址因没有授权而大量回退。

solidity
contract AccountingInvariantTest is AccountingVaultTest {
    function setUp() public override {
        super.setUp();
        // 此处采用单用户 handler,完整实现见下方。
        VaultHandler handler = new VaultHandler(token, vault, user);
        token.mint(address(handler), 1000000 ether);
        targetContract(address(handler));
    }

    function invariant_liabilitiesNeverExceedAssets() public view {
        uint256 assets = token.balanceOf(address(vault));
        uint256 liabilities = vault.totalDebt() + vault.accruedFees();
        assertGe(assets, liabilities);
    }
}

contract VaultHandler is Test {
    MockToken token;
    AccountingVault vault;
    address user;

    constructor(MockToken t, AccountingVault v, address u) {
        token = t;
        vault = v;
        user = u;
        vm.prank(user);
        token.approve(address(vault), type(uint256).max);
    }

    function deposit(uint96 rawAmount) external {
        uint256 available = token.balanceOf(user);
        if (available == 0) return;
        uint256 amount = bound(uint256(rawAmount), 1, available);
        vm.prank(user);
        vault.deposit(amount);
    }

    function withdraw(uint96 rawAmount) external {
        uint256 debt = vault.deposits(user);
        if (debt == 0) return;
        uint256 amount = bound(uint256(rawAmount), 1, debt);
        vm.prank(user);
        vault.withdraw(amount);
    }
}

上述片段示例依赖同一测试文件中的 MockToken、AccountingVaultTest,以及前面的完整金库合约。实际运行前还需把 AccountingVaultTest 的 setUp() 改为 public virtual,以允许子类覆盖。测试用户初始拥有 1000 代币,Handler 的充值操作会使用用户自己的余额;额外铸给 Handler 的代币不参与调用,可删除该行以简化夹具。

执行:

bash
forge test --match-contract AccountingInvariantTest

预期结果:正常的标准代币操作不会使总负债超过实际资产,invariant_liabilitiesNeverExceedAssets 应通过。模糊调用次数、测试耗时和执行序列取决于 Foundry 配置与随机种子。

这里刻意采用 assets >= liabilities,因为第三方可以直接转账制造盈余。如果业务规定盈余需要单独追踪,可增加 unaccountedSurplus 并在接收或同步资产时更新,进一步验证 assets == liabilities + unaccountedSurplus;但普通 ERC-20 转账不会通知接收合约,不能仅靠金库函数实时维护这个数值。

识别守恒断言无法覆盖的错误

守恒条件是必要的会计检查,但不能代替用户级余额正确性与资产安全性验证。

故障场景 可能的检查结果 应增加的验证
漏扣 totalDebt 出现负债大于资产 检查缺口为零
忘记计提提现手续费 出现未解释盈余 检查严格守恒或盈余来源
给错误用户扣款 总量仍可能守恒 检查调用者余额和授权
额外铸造用户内部余额但同步增加总债务 出现资金缺口 检查每次债务变化的合法原因
外部地址直接赠送代币 出现盈余 将盈余与实际捐赠区分
代币重基准或转账税 余额可能异常变化 对代币行为单独建模

审计时建议把断言分成三层:

  1. 总量层:验证实际资产不小于总负债;在禁止外部余额变化的测试环境中检查严格相等。
  2. 用户层:验证每次充值、提现只影响对应用户的余额,且用户余额汇总与 totalDebt 一致。
  3. 操作层:验证提现金额等于用户债务减少量,手续费与实付金额之和等于扣账金额,同时检查手续费领取不会影响用户债务。

对于本课的 200 单位提现,操作层可断言 200=198+2,总量层可断言 802=800+2。如果手续费接收方领取了 2 单位,必须同时让实际资产和 accruedFees 各减少 2,而不能仅执行转账。

完整审计还要关注整数舍入、代币冻结、异常回调、可升级合约存储布局、余额强制变动与跨合约记账。遇到不满足守恒的情况,应先记录交易前后 balanceOf、totalDebt、accruedFees 的差值,再定位具体操作,而不要直接把差额记成收益或通过修改总债务掩盖缺口。

按自己的节奏,确认真正理解。

目录与阅读设置

阅读设置

17

记录一个想法

检查总资产与债务守恒条件

0 / 10000 · 笔记保存到账号。未提交的修改会在关闭、离开或刷新后丢失。

登录哪都通