《纸上谈兵·solidity》第 22 课：代币合约（ERC20）从零实现与扩展

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

contract MyERC20 {
    string public name = "MyToken";
    string public symbol = "MTK";
    uint8 public decimals = 18;

    uint256 private _totalSupply;
    mapping(address => uint256) private _balances;
    mapping(address => mapping(address => uint256)) private _allowances;

    event Transfer(address indexed from, address indexed to, uint256 value);
    event Approval(address indexed owner, address indexed spender, uint256 value);

    constructor(uint256 initialSupply) {
        _mint(msg.sender, initialSupply);
    }

    function totalSupply() external view returns (uint256) {
        return _totalSupply;
    }

    function balanceOf(address account) external view returns (uint256) {
        return _balances[account];
    }

    function transfer(address to, uint256 amount) external returns (bool) {
        require(to != address(0), "Invalid address");
        require(_balances[msg.sender] >= amount, "Insufficient balance");

        _balances[msg.sender] -= amount;
        _balances[to] += amount;

        emit Transfer(msg.sender, to, amount);
        return true;
    }

    function approve(address spender, uint256 amount) external returns (bool) {
        _allowances[msg.sender][spender] = amount;
        emit Approval(msg.sender, spender, amount);
        return true;
    }

    function allowance(address owner, address spender) external view returns (uint256) {
        return _allowances[owner][spender];
    }

    function transferFrom(address from, address to, uint256 amount) external returns (bool) {
        require(to != address(0), "Invalid address");
        require(_balances[from] >= amount, "Insufficient balance");
        require(_allowances[from][msg.sender] >= amount, "Not approved");

        _balances[from] -= amount;
        _balances[to] += amount;
        _allowances[from][msg.sender] -= amount;

        emit Transfer(from, to, amount);
        return true;
    }

    function _mint(address account, uint256 amount) internal {
        require(account != address(0), "Invalid address");
        _totalSupply += amount;
        _balances[account] += amount;
        emit Transfer(address(0), account, amount);
    }

    function _burn(address account, uint256 amount) internal {
        require(account != address(0), "Invalid address");
        require(_balances[account] >= amount, "Insufficient balance");
        _balances[account] -= amount;
        _totalSupply -= amount;
        emit Transfer(account, address(0), amount);
    }
}

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

/// @title 一个最小但可扩展的 ERC20 实现（带 Mint 与 Burn 功能）
/// @notice 本合约演示了代币标准 ERC20 的完整逻辑，并在此基础上增加了扩展功能。
contract MyERC20WithMintBurn {
    // ======== 基本元信息 ========

    /// @notice 代币名称（例如：Ethereum）
    string public name = "MyToken";

    /// @notice 代币符号（例如：ETH）
    string public symbol = "MTK";

    /// @notice 代币小数位数，通常是 18（与以太币一致）
    uint8 public decimals = 18;

    /// @notice 代币总供应量
    uint256 private _totalSupply;

    /// @notice 合约拥有者地址（只有它能调用 mint）
    address public owner;

    // ======== 账户与授权映射 ========

    /// @notice 每个账户的余额映射
    mapping(address => uint256) private _balances;

    /// @notice 授权额度映射：owner => (spender => 金额)
    ///         例如 Alice 授权 Bob 使用 100 个代币：_allowances[Alice][Bob] = 100
    mapping(address => mapping(address => uint256)) private _allowances;

    // ======== 事件（区块链日志） ========

    /// @notice 代币转账事件
    event Transfer(address indexed from, address indexed to, uint256 value);

    /// @notice 授权额度变更事件
    event Approval(address indexed owner, address indexed spender, uint256 value);

    // ======== 修饰器（权限控制） ========

    /// @notice 限制函数只能由合约拥有者调用
    modifier onlyOwner() {
        require(msg.sender == owner, "Not owner");
        _;
    }

    // ======== 构造函数 ========

    /// @notice 部署合约时会铸造初始代币给部署者
    /// @param initialSupply 初始供应量
    constructor(uint256 initialSupply) {
        owner = msg.sender; // 部署者成为合约拥有者
        _mint(msg.sender, initialSupply); // 铸造初始代币
    }

    // ======== ERC20 标准函数 ========

    /// @notice 返回代币总供应量
    function totalSupply() external view returns (uint256) {
        return _totalSupply;
    }

    /// @notice 查询某个账户的余额
    function balanceOf(address account) external view returns (uint256) {
        return _balances[account];
    }

    /// @notice 转账函数
    /// @param to 接收者地址
    /// @param amount 转账金额
    /// @dev 会触发 Transfer 事件
    function transfer(address to, uint256 amount) external returns (bool) {
        require(to != address(0), "Invalid address"); // 禁止转账到 0 地址
        require(_balances[msg.sender] >= amount, "Insufficient balance"); // 确保余额足够

        // 扣减发送者余额
        _balances[msg.sender] -= amount;

        // 增加接收者余额
        _balances[to] += amount;

        // 记录日志
        emit Transfer(msg.sender, to, amount);
        return true;
    }

    /// @notice 授权某人（spender）可以花费调用者的代币
    /// @param spender 被授权的账户
    /// @param amount 授权金额
    function approve(address spender, uint256 amount) external returns (bool) {
        _allowances[msg.sender][spender] = amount;

        // 触发 Approval 事件，方便链上追踪
        emit Approval(msg.sender, spender, amount);
        return true;
    }

    /// @notice 查询 owner 给 spender 的授权额度
    function allowance(address _owner, address spender) external view returns (uint256) {
        return _allowances[_owner][spender];
    }

    /// @notice 转账（使用授权额度），常用于交易所托管、自动化支付等场景
    /// @param from 代币来源地址（必须已授权）
    /// @param to 代币接收地址
    /// @param amount 转账金额
    function transferFrom(address from, address to, uint256 amount) external returns (bool) {
        require(to != address(0), "Invalid address");
        require(_balances[from] >= amount, "Insufficient balance");
        require(_allowances[from][msg.sender] >= amount, "Not approved");

        // 扣减 from 的余额
        _balances[from] -= amount;

        // 增加接收者余额
        _balances[to] += amount;

        // 扣减调用者可用的授权额度
        _allowances[from][msg.sender] -= amount;

        // 触发转账事件
        emit Transfer(from, to, amount);
        return true;
    }

    // ======== 扩展功能：Mint 与 Burn ========

    /// @notice 铸造代币（只能由 owner 调用）
    /// @param to 接收者
    /// @param amount 铸造数量
    /// @dev 注意：滥用 mint 会导致代币贬值
    function mint(address to, uint256 amount) external onlyOwner {
        _mint(to, amount);
    }

    /// @notice 销毁调用者的代币
    /// @param amount 销毁数量
    /// @dev 用户只能销毁自己的代币，无法销毁别人账户的
    function burn(uint256 amount) external {
        _burn(msg.sender, amount);
    }

    // ======== 内部函数（供 mint/burn 使用） ========

    /// @notice 内部铸造逻辑
    function _mint(address account, uint256 amount) internal {
        require(account != address(0), "Invalid address");

        // 增加总供应量
        _totalSupply += amount;

        // 增加账户余额
        _balances[account] += amount;

        // 触发 Transfer 事件，from = address(0) 代表铸造
        emit Transfer(address(0), account, amount);
    }

    /// @notice 内部销毁逻辑
    function _burn(address account, uint256 amount) internal {
        require(account != address(0), "Invalid address");
        require(_balances[account] >= amount, "Insufficient balance");

        // 扣减账户余额
        _balances[account] -= amount;

        // 扣减总供应量
        _totalSupply -= amount;

        // 触发 Transfer 事件，to = address(0) 代表销毁
        emit Transfer(account, address(0), amount);
    }
}

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

import "forge-std/Test.sol"; // Foundry 的测试基类
import "../src/MyERC20WithMintBurn.sol"; // 引入待测试的合约

/// @title MyERC20WithMintBurn 的单元测试
/// @notice 使用 Foundry 测试框架验证代币逻辑
contract MyERC20WithMintBurnTest is Test {
    MyERC20WithMintBurn token; // 测试用代币实例
    address alice = address(0x1); // 测试账户 Alice
    address bob   = address(0x2); // 测试账户 Bob

    /// @notice 在每个测试前执行，初始化合约实例
    function setUp() public {
        // 部署一个初始供应量为 1000 的代币
        token = new MyERC20WithMintBurn(1000 * 1e18);
    }

    /// @notice 测试：初始供应量是否正确分配给部署者
    function testInitialSupply() public view {
        uint256 supply = token.totalSupply();
        assertEq(supply, 1000 * 1e18);

        uint256 balanceOwner = token.balanceOf(address(this));
        assertEq(balanceOwner, 1000 * 1e18);
    }

    /// @notice 测试：普通转账逻辑
    function testTransfer() public {
        // 给 Alice 转 100 代币
        token.transfer(alice, 100 * 1e18);

        // 验证 Alice 的余额
        uint256 balanceAlice = token.balanceOf(alice);
        assertEq(balanceAlice, 100 * 1e18);

        // 验证部署者余额减少
        uint256 balanceOwner = token.balanceOf(address(this));
        assertEq(balanceOwner, 900 * 1e18);
    }

    /// @notice 测试：转账余额不足时报错
    function testTransferRevertIfInsufficientBalance() public {
        vm.expectRevert("Insufficient balance"); // 预期报错
        vm.prank(alice); // 让 Alice 作为 msg.sender 执行
        token.transfer(bob, 1); // Alice 没钱，还要转账 -> 报错
    }

    /// @notice 测试：授权与 transferFrom
    function testApproveAndTransferFrom() public {
        // 部署者授权 Alice 使用 200 代币
        token.approve(alice, 200 * 1e18);

        // 验证授权额度
        uint256 allowance = token.allowance(address(this), alice);
        assertEq(allowance, 200 * 1e18);

        // 让 Alice 调用 transferFrom
        vm.prank(alice);
        token.transferFrom(address(this), bob, 150 * 1e18);

        // 验证 Bob 的余额
        uint256 balanceBob = token.balanceOf(bob);
        assertEq(balanceBob, 150 * 1e18);

        // 验证剩余授权额度
        uint256 remaining = token.allowance(address(this), alice);
        assertEq(remaining, 50 * 1e18);
    }

    /// @notice 测试：mint 功能（只有 owner 能调用）
    function testMintByOwner() public {
        uint256 beforeSupply = token.totalSupply();

        // 给 Alice 铸造 500 代币
        token.mint(alice, 500 * 1e18);

        // 验证总供应量增加
        assertEq(token.totalSupply(), beforeSupply + 500 * 1e18);

        // 验证 Alice 的余额增加
        assertEq(token.balanceOf(alice), 500 * 1e18);
    }

    /// @notice 测试：非 owner 调用 mint 会失败
    function testMintRevertIfNotOwner() public {
        vm.expectRevert("Not owner");
        vm.prank(alice); // 伪造 Alice 调用
        token.mint(alice, 1000 * 1e18);
    }

    /// @notice 测试：burn 功能
    function testBurn() public {
        uint256 beforeSupply = token.totalSupply();
        uint256 beforeBalance = token.balanceOf(address(this));

        // 销毁 100 代币
        token.burn(100 * 1e18);

        // 验证总供应量减少
        assertEq(token.totalSupply(), beforeSupply - 100 * 1e18);

        // 验证调用者余额减少
        assertEq(token.balanceOf(address(this)), beforeBalance - 100 * 1e18);
    }

    /// @notice 测试：余额不足时 burn 会失败
    function testBurnRevertIfInsufficientBalance() public {
        vm.expectRevert("Insufficient balance");
        vm.prank(alice); // Alice 没钱
        token.burn(1);
    }
}

➜  counter git:(main) ✗ forge test --match-path test/MyERC20WithMintBurn.t.sol -vvv
[⠊] Compiling...
[⠢] Compiling 1 files with Solc 0.8.29
[⠆] Solc 0.8.29 finished in 1.12s
Compiler run successful!

Ran 8 tests for test/MyERC20WithMintBurn.t.sol:MyERC20WithMintBurnTest
[PASS] testApproveAndTransferFrom() (gas: 80002)
[PASS] testBurn() (gas: 28538)
[PASS] testBurnRevertIfInsufficientBalance() (gas: 14157)
[PASS] testInitialSupply() (gas: 15398)
[PASS] testMintByOwner() (gas: 48465)
[PASS] testMintRevertIfNotOwner() (gas: 14689)
[PASS] testTransfer() (gas: 46148)
[PASS] testTransferRevertIfInsufficientBalance() (gas: 16894)
Suite result: ok. 8 passed; 0 failed; 0 skipped; finished in 7.09ms (11.64ms CPU time)

Ran 1 test suite in 359.69ms (7.09ms CPU time): 8 tests passed, 0 failed, 0 skipped (8 total tests)