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

/**
 * @title IERC20 - ERC-20 代币标准接口
 * @dev 参见 https://eips.ethereum.org/EIPS/eip-20
 */
interface IERC20 {
    // ============ 查询函数 ============

    /// @notice 返回代币的总发行量
    function totalSupply () external view returns (uint256);

    /// @notice 查询某个地址的代币余额
    /// @param account 要查询的地址
    function balanceOf (address account) external view returns (uint256);

    /// @notice 查询 owner 授权给 spender 的剩余额度
    /// @param owner 代币持有者
    /// @param spender 被授权者
    function allowance (address owner, address spender) external view returns (uint256);

    // ============ 操作函数 ============

    /// @notice 直接转账：从调用者地址转代币给接收者
    /// @param to 接收地址
    /// @param amount 转账金额
    function transfer (address to, uint256 amount) external returns (bool);

    /// @notice 授权：允许 spender 从调用者地址代扣最多 amount 的代币
    /// @param spender 被授权的地址
    /// @param amount 授权额度
    function approve (address spender, uint256 amount) external returns (bool);

    /// @notice 代扣转账：spender 从 from 地址转代币到 to 地址（需先获得授权）
    /// @param from 代币来源地址
    /// @param to 接收地址
    /// @param amount 转账金额
    function transferFrom (address from, address to, uint256 amount) external returns (bool);

    // ============ 事件 ============

    /// @notice 代币转移时触发（包括铸造和销毁）
    event Transfer (address indexed from, address indexed to, uint256 value);

    /// @notice 授权额度变更时触发
    event Approval (address indexed owner, address indexed spender, uint256 value);
}

第 1 步：你调用 approve (uniswapRouter, 1000)
        → 授权 Uniswap 路由合约最多动用你的 1000 个代币

第 2 步：你调用 Uniswap 的 swap 函数
        → Uniswap 内部调用 transferFrom (你的地址，流动性池，500)
        → 从你的账户转 500 个代币到流动性池
        → 同时把对应的另一种代币转给你

bash
# 一键安装 Foundry
curl -L https://foundry.paradigm.xyz | bash

# 安装完成后执行 foundryup 拉取最新版本
foundryup

bash
# 检查各工具版本
forge --version
# 输出示例：forge 0.2.0 (xxxxxxx 2025-xx-xx)

cast --version
# 输出示例：cast 0.2.0 (xxxxxxx 2025-xx-xx)

anvil --version
# 输出示例：anvil 0.2.0 (xxxxxxx 2025-xx-xx)

bash
# 创建新项目
forge init my-token && cd my-token

# 查看项目结构
tree -L 2

my-token/
├── foundry.toml          # 项目配置文件
├── lib/                  # 依赖库目录
│   └── forge-std/        # Foundry 标准测试库
├── script/               # 部署脚本
│   └── Counter.s.sol
├── src/                  # 合约源码
│   └── Counter.sol
└── test/                 # 测试文件
    └── Counter.t.sol

bash
# 安装 OpenZeppelin Contracts v5
forge install OpenZeppelin/openzeppelin-contracts --no-commit

bash
# 创建 remappings.txt
echo '@openzeppelin/contracts/=lib/openzeppelin-contracts/contracts/' > remappings.txt

toml
[profile.default]
src = "src"
out = "out"
libs = ["lib"]
remappings = ["@openzeppelin/contracts/=lib/openzeppelin-contracts/contracts/"]

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

import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";

/**
 * @title MyToken - 一个简单的 ERC-20 代币
 * @author beihaili
 * @notice 用于学习 ERC-20 标准的示例合约
 * @dev 继承 OpenZeppelin 的 ERC20 和 Ownable 合约
 *
 * 功能说明：
 * - 部署时铸造固定数量的初始代币给部署者
 * - 合约所有者可以额外铸造代币（可选功能）
 * - 继承 ERC20 的所有标准功能（transfer, approve, transferFrom 等）
 */
contract MyToken is ERC20, Ownable {
    /// @notice 代币精度，与 ETH 保持一致（18 位小数）
    uint8 private constant DECIMALS = 18;

    /**
     * @notice 构造函数：部署合约时设置代币名称、符号和初始供应量
     * @param name_ 代币全称，例如 "My Awesome Token"
     * @param symbol_ 代币符号，例如 "MAT"
     * @param initialSupply 初始供应量（以最小单位计算，会自动乘以 10^18）
     *
     * @dev 示例：如果 initialSupply = 1_000_000，实际铸造 1,000,000 * 10^18 个最小单位
     *      这意味着代币总量为 100 万个，每个代币可被拆分到 18 位小数
     */
    constructor (
        string memory name_,
        string memory symbol_,
        uint256 initialSupply
    ) ERC20 (name_, symbol_) Ownable (msg.sender) {
        //_mint 是 OpenZeppelin ERC20 的内部函数
        //msg.sender 是部署合约的地址，所有初始代币都铸造给部署者
        _mint (msg.sender, initialSupply * 10 ** decimals ());
    }

    /**
     * @notice 铸造新代币（仅合约所有者可调用）
     * @param to 接收新代币的地址
     * @param amount 铸造数量（最小单位）
     *
     * @dev 这个函数通过 Ownable 的 onlyOwner 修饰符限制权限
     *      只有部署合约的地址（owner）才能调用
     *      注意：这里的 amount 是最小单位，不会自动乘以 decimals
     */
    function mint (address to, uint256 amount) external onlyOwner {
        _mint (to, amount);
    }
}

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

solidity
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";

solidity
contract MyToken is ERC20, Ownable {

solidity
constructor (
    string memory name_,
    string memory symbol_,
    uint256 initialSupply
) ERC20 (name_, symbol_) Ownable (msg.sender) {
    _mint (msg.sender, initialSupply * 10 ** decimals ());
}

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

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

import "forge-std/Test.sol";
import "../src/MyToken.sol";

/**
 * @title MyToken 测试合约
 * @dev 覆盖代币名称、符号、总供应量、转账、授权等核心场景
 */
contract MyTokenTest is Test {
    MyToken public token;

    // 测试用地址
    address public deployer = address (1);
    address public alice = address (2);
    address public bob = address (3);

    // 初始供应量：100 万个代币
    uint256 public constant INITIAL_SUPPLY = 1_000_000;

    /// @notice 每个测试用例前自动执行
    function setUp () public {
        // 以 deployer 身份部署合约
        vm.prank (deployer);
        token = new MyToken ("My Awesome Token", "MAT", INITIAL_SUPPLY);
    }

    // ============ 基础属性测试 ============

    /// @notice 测试代币名称是否正确
    function testName () public view {
        assertEq (token.name (), "My Awesome Token");
    }

    /// @notice 测试代币符号是否正确
    function testSymbol () public view {
        assertEq (token.symbol (), "MAT");
    }

    /// @notice 测试总供应量是否正确
    function testTotalSupply () public view {
        // INITIAL_SUPPLY * 10^18
        assertEq (token.totalSupply (), INITIAL_SUPPLY * 10 ** 18);
    }

    /// @notice 测试部署者是否收到了全部初始代币
    function testDeployerBalance () public view {
        assertEq (token.balanceOf (deployer), INITIAL_SUPPLY * 10 ** 18);
    }

    // ============ 转账测试 ============

    /// @notice 测试正常转账
    function testTransfer () public {
        uint256 amount = 1000 * 10 ** 18; // 转 1000 个代币

        //deployer 转 1000 MAT 给 alice
        vm.prank (deployer);
        bool success = token.transfer (alice, amount);

        // 断言转账成功
        assertTrue (success);
        // 断言 alice 收到代币
        assertEq (token.balanceOf (alice), amount);
        // 断言 deployer 余额减少
        assertEq (token.balanceOf (deployer), (INITIAL_SUPPLY * 10 ** 18) - amount);
    }

    /// @notice 测试余额不足时转账应 revert
    function testTransferInsufficientBalance () public {
        uint256 amount = 1000 * 10 ** 18;

        //alice 没有代币，尝试转账应该失败
        vm.prank (alice);
        vm.expectRevert (); // 预期下一次调用会 revert
        token.transfer (bob, amount);
    }

    // ============ 授权与代扣测试 ============

    /// @notice 测试 approve + transferFrom 流程
    function testApproveAndTransferFrom () public {
        uint256 amount = 500 * 10 ** 18;

        //deployer 授权 alice 可代扣 500 MAT
        vm.prank (deployer);
        token.approve (alice, amount);

        // 验证授权额度
        assertEq (token.allowance (deployer, alice), amount);

        //alice 使用授权从 deployer 转代币给 bob
        vm.prank (alice);
        token.transferFrom (deployer, bob, amount);

        // 验证余额
        assertEq (token.balanceOf (bob), amount);
        // 验证授权额度已消耗
        assertEq (token.allowance (deployer, alice), 0);
    }

    // ============ Owner 铸造测试 ============

    /// @notice 测试 owner 可以铸造新代币
    function testMintByOwner () public {
        uint256 mintAmount = 5000 * 10 ** 18;

        vm.prank (deployer);
        token.mint (alice, mintAmount);

        assertEq (token.balanceOf (alice), mintAmount);
        // 总供应量应增加
        assertEq (token.totalSupply (), (INITIAL_SUPPLY * 10 ** 18) + mintAmount);
    }

    /// @notice 测试非 owner 不能铸造
    function testMintByNonOwnerReverts () public {
        vm.prank (alice);
        vm.expectRevert (); // 非 owner 调用 mint 应 revert
        token.mint (alice, 1000 * 10 ** 18);
    }
}

bash
# 运行所有测试（-vv 显示详细日志）
forge test -vv

[⠊] Compiling...
[⠊] Compiling 1 files with Solc 0.8.28
[⠒] Solc 0.8.28 finished in 1.23s
Compiler run successful!

Ran 7 tests for test/MyToken.t.sol:MyTokenTest
[PASS] testApproveAndTransferFrom () (gas: 52341)
[PASS] testDeployerBalance () (gas: 10521)
[PASS] testMintByNonOwnerReverts () (gas: 12105)
[PASS] testMintByOwner () (gas: 36742)
[PASS] testName () (gas: 9823)
[PASS] testSymbol () (gas: 9801)
[PASS] testTotalSupply () (gas: 10478)
[PASS] testTransfer () (gas: 38123)
[PASS] testTransferInsufficientBalance () (gas: 14892)

Suite result: ok. 7 passed; 0 failed; 0 skipped; finished in 2.81ms

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

import "forge-std/Script.sol";
import "../src/MyToken.sol";

/**
 * @title 部署脚本
 * @dev 使用 forge script 命令执行
 *
 * 部署参数：
 * - 代币名称：My Awesome Token
 * - 代币符号：MAT
 * - 初始供应量：1,000,000（100 万个代币）
 */
contract DeployMyToken is Script {
    function run () external {
        // 从环境变量读取私钥
        uint256 deployerPrivateKey = vm.envUint ("PRIVATE_KEY");

        // 开始广播交易（后续的合约调用会被发送到链上）
        vm.startBroadcast (deployerPrivateKey);

        // 部署合约
        MyToken token = new MyToken (
            "My Awesome Token", // 代币名称
            "MAT",             // 代币符号
            1_000_000          // 初始供应量：100 万
        );

        // 打印部署地址
        console.log ("MyToken deployed at:", address (token));

        vm.stopBroadcast ();
    }
}

bash
# .env 文件（⚠️ 务必添加到 .gitignore！）
PRIVATE_KEY = 你的私钥
SEPOLIA_RPC_URL=https://eth-sepolia.g.alchemy.com/v2 / 你的 API 密钥
ETHERSCAN_API_KEY = 你的 Etherscan_API 密钥

bash
# 加载环境变量
source .env

# 部署到 Sepolia 测试网
forge script script/Deploy.s.sol:DeployMyToken \
    --rpc-url $SEPOLIA_RPC_URL \
    --private-key $PRIVATE_KEY \
    --broadcast

== Logs ==
  MyToken deployed at: 0x1234...abcd

## Setting up 1 EVM.

Chain 11155111

Estimated gas price: 3.5 gwei
Estimated total gas used for script: 876543
Estimated amount required: 0.003067 ETH

###
Finding wallets for all the necessary addresses...
##
Sending transactions [1/1].
⠁ [00:00:05] Waiting for tx hash...
##### sepolia
✅  Hash: 0xabcd...1234
Contract Address: 0x1234...abcd
Block: 12345678
Paid: 0.002345 ETH (876543 gas * 2.67 gwei)

bash
# 验证合约
forge verify-contract \
    < 你的合约地址 > \
    src/MyToken.sol:MyToken \
    --chain sepolia \
    --etherscan-api-key $ETHERSCAN_API_KEY \
    --constructor-args $(cast abi-encode "constructor (string,string,uint256)" "My Awesome Token" "MAT" 1000000)

bash
forge script script/Deploy.s.sol:DeployMyToken \
    --rpc-url $SEPOLIA_RPC_URL \
    --private-key $PRIVATE_KEY \
    --broadcast \
    --verify \
    --etherscan-api-key $ETHERSCAN_API_KEY