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

采用拉取付款隔离接收方失败

采用拉取付款隔离接收方失败

当合约需要向多个用户支付以太币时,主动逐一转账可能被一个拒收以太币的合约阻断。拉取付款将批量推送改为记录可领取余额,由收款人自行提现。本篇使用 Solidity 实现安全的领取机制,并通过拒收合约验证故障隔离效果。

学习目标

  • 解释推送付款为何会受到恶意接收方影响,以及拉取付款如何隔离失败。
  • 实现带有余额检查、先清零后转账和重入保护的领取函数。
  • 编写 Foundry 测试,验证拒收以太币不会阻止其他用户领取资金。

推送付款为什么会造成拒绝服务

假设奖励合约需要向 Alice、Bob 和 Carol 各支付 1 ETH。传统推送付款会由管理员在一笔交易中遍历收款人,并依次发送以太币。

以下是存在拒绝服务风险的片段示例,依赖 Solidity 0.8.x,并假定合约具有足够的 ETH 余额。

solidity
function distribute(address payable[] calldata recipients) external {
    for (uint256 i = 0; i < recipients.length; i++) {
        // 任意收款方拒收,整笔交易都会回滚
        (bool ok, ) = recipients[i].call{value: 1 ether}("");
        require(ok, "payment failed");
    }
}

如果 Bob 是一个拒收以太币的智能合约,第二次转账就会失败。由于 require 触发回滚,Alice 已执行的付款也会撤销,Carol 更无法收到资金。

还有一种错误做法是忽略 ok,继续处理其他收款人。这虽然可能避免整批回滚,却会产生付款遗漏;如果没有额外记录,失败者可能永久丢失领取机会。

更合理的设计是把两个操作拆开:管理员只登记每位用户的债权,用户自行调用领取函数。登记操作不调用收款方合约,因此不会受到其 receive() 或 fallback() 行为影响。

拉取付款的资金流转

拉取付款使用 mapping(address => uint256) 保存可领取余额。管理员为用户增加余额时,ETH 仍保留在付款合约中;用户主动领取时,合约才向指定收款地址发起外部调用。

推送付款与拉取付款的故障隔离对比

一个实际的奖励分配场景可以这样处理:

  1. 管理员存入 3 ETH,分别为 Alice、Bob、Carol 登记 1 ETH。
  2. Alice 调用 withdraw(),余额先清零,再收到 1 ETH。
  3. Bob 调用 withdraw(),其合约拒收 ETH,交易回滚,Bob 的可领取余额恢复为 1 ETH。
  4. Carol 独立调用 withdraw(),正常收到 1 ETH。

各次提现属于不同交易,因此 Bob 的失败不会回滚 Alice 或 Carol 已经成功的提现。失败者的债权依然保留,可以在其接收能力恢复后重试。

需要注意,拉取付款解决的是接收方失败相互牵连的问题,并不自动解决所有重入漏洞、权限问题或无限增长的债务问题。

实现安全的余额领取合约

下面使用 Solidity 0.8.24,实现一个最小的 ETH 奖励池。管理员通过 credit() 存入资金并登记指定用户的可领取余额,用户通过 withdraw() 自行领取。

将代码保存为 src/PullPayment.sol。示例不依赖第三方合约库,可以直接用于 Foundry 项目。

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

contract PullPayment {
    address public immutable owner;
    mapping(address => uint256) public pending;
    bool private locked;

    event Credited(address indexed account, uint256 amount);
    event Withdrawn(address indexed account, uint256 amount);

    constructor() {
        owner = msg.sender;
    }

    // 管理员将本次充值全部登记给指定用户
    function credit(address account) external payable {
        require(msg.sender == owner, "not owner");
        require(account != address(0), "zero address");
        require(msg.value > 0, "zero amount");

        pending[account] += msg.value;
        emit Credited(account, msg.value);
    }

    function withdraw() external {
        require(!locked, "reentrant call");
        uint256 amount = pending[msg.sender];
        require(amount > 0, "nothing to withdraw");

        locked = true;
        // Checks-Effects-Interactions:外部调用之前清零
        pending[msg.sender] = 0;

        (bool ok, ) = payable(msg.sender).call{value: amount}("");
        require(ok, "ETH transfer failed");

        locked = false;
        emit Withdrawn(msg.sender, amount);
    }
}

代码中有三个需要特别检查的安全边界。

  • 权限边界:只有 owner 可以调用 credit(),且每次登记的金额严格等于本次实际收到的 msg.value,避免无资金支持的账面债务。
  • 状态更新顺序:提现前先检查余额并清零,然后才执行 ETH 转账。这是 Checks-Effects-Interactions 模式,防止收款方在回调期间再次领取原有余额。
  • 失败原子性:若 ETH 转账失败,require(ok) 会回滚整个提现,包括清零余额和修改锁状态,因此用户不会因失败而损失债权。

call{value: amount}("") 允许收款合约执行其接收逻辑,不受 transfer() 固定 2300 gas 转发限制,但也意味着必须防御重入。这里使用全局互斥锁演示保护方式;生产项目可以采用经过审计的 ReentrancyGuard,并保证所有相关提现入口遵循相同的安全约束。

本示例故意将提现接收方固定为 msg.sender。因此,如果一个拒收 ETH 的合约永久无法修改接收逻辑,它的资金仍可能无法取出。真实系统可根据威胁模型扩展为受益人指定接收地址的领取函数,但要额外检查受益人身份以及接收地址授权。

使用 Foundry 验证拒收隔离

使用 Foundry 的 forge test 运行自动化测试。测试将创建一个始终拒收 ETH 的合约,并验证恶意接收方无法阻断其他用户领取。

首先在已有 Foundry 项目中放置上面的 src/PullPayment.sol,再创建 test/PullPayment.t.sol。以下测试使用 Foundry 标准安装提供的 forge-std/Test.sol,并假定项目 Solidity 编译器支持 0.8.24。

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

import {Test} from "forge-std/Test.sol";
import {PullPayment} from "../src/PullPayment.sol";

contract RejectEther {
    // 接收到 ETH 时主动回滚
    receive() external payable {
        revert("reject ETH");
    }

    function claim(PullPayment pool) external {
        pool.withdraw();
    }
}

contract PullPaymentTest is Test {
    PullPayment pool;
    RejectEther rejector;
    address alice = address(0xA11CE);
    address carol = address(0xCA201);

    function setUp() public {
        pool = new PullPayment();
        rejector = new RejectEther();
        vm.deal(address(this), 3 ether);

        // 三个债权由同一管理员登记,无需执行外部转账
        pool.credit{value: 1 ether}(alice);
        pool.credit{value: 1 ether}(address(rejector));
        pool.credit{value: 1 ether}(carol);
    }

    function testRejectorCannotBlockOthers() public {
        vm.prank(alice);
        pool.withdraw();
        assertEq(alice.balance, 1 ether);

        vm.expectRevert(bytes("ETH transfer failed"));
        rejector.claim(pool);
        assertEq(pool.pending(address(rejector)), 1 ether);

        vm.prank(carol);
        pool.withdraw();
        assertEq(carol.balance, 1 ether);

        // 拒收者的债权保留,其他用户的债权已经结清
        assertEq(pool.pending(alice), 0);
        assertEq(pool.pending(carol), 0);
        assertEq(address(pool).balance, 1 ether);
    }
}

执行测试命令:

bash
forge test --match-contract PullPaymentTest -vv

预期输出的关键内容如下,实际耗时与 gas 数值会随环境变化,因此不作为固定断言。

text
[PASS] testRejectorCannotBlockOthers() (gas: <GAS>)
Suite result: ok. 1 passed; 0 failed; 0 skipped

这里的 <GAS> 表示运行环境生成的实际 gas 数值。如果项目编译器配置、测试库版本或其他测试文件不同,输出可能包含额外的编译与测试信息。

测试中最重要的断言是:拒收者提现失败后,其 pending 仍为 1 ETH;Alice 和 Carol 各获得 1 ETH;付款合约最终剩余 1 ETH。三个条件同时成立,才证明债权没有丢失且失败被限制在当前提现交易内。

审计时还要检查哪些边界

拉取付款通过独立提现降低批量转账被阻断的风险,但审计时还需要检查以下情况。

检查项 危险实现 推荐检查方法
重入 转账后才扣除余额 使用恶意接收合约递归调用 withdraw(),确认不能重复领取
失败处理 转账失败仍将余额清零 模拟 receive() 回滚,确认余额和债权恢复
重复领取 同一债权可被反复支付 成功提现后再次调用,预期以 nothing to withdraw 回滚
资金覆盖 任意管理员凭空增加债权 检查充值金额与新增债权一致,避免承诺超过实际资金
Gas 消耗 管理员遍历无限增长的收款数组 将批量处理改为独立领取,避免单笔交易因循环过大而耗尽 gas

还要考虑链上实际使用成本。拉取付款把领取交易的 gas 成本交给受益人,且在 ETH 主网拥堵时,小额奖励可能不值得单独领取。可以采用累计余额、最低领取金额或链下通知减少无效交易,但最低金额规则必须避免将已有小额债权永久锁死。

对于高价值系统,可以进一步实现带授权的 withdrawTo(address recipient),允许受益人将 ETH 发送至可接收的地址;同时防止第三方替受益人随意修改目标地址。若支持 ERC-20 资产,还应采用适配不同代币返回行为的安全转账工具,并考虑恶意代币回调和实际到账数量。

本例的验收标准很明确:管理员登记债权时不调用收款方;拒收合约只能让自身当前提现交易失败;其他用户始终能独立提现;失败后资金与可领取余额保持一致。满足这四项,才算真正实现了接收方失败隔离。

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

目录与阅读设置

阅读设置

17

记录一个想法

采用拉取付款隔离接收方失败

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

登录哪都通