从零开发 ERC20 代币

// State Variables
string public name;         // Token name
string public symbol;       // Token symbol
uint8 public decimals;      // Decimal places, usually 18
uint256 public totalSupply; // Total supply

mapping(address => uint256) public balanceOf;
mapping(address => mapping(address => uint256)) public allowance;

constructor(string memory _name, string memory _symbol, uint256 _initialSupply) {
    name = _name;
    symbol = _symbol;
    decimals = 18;

    // Mint initial supply to deployer
    totalSupply = _initialSupply * 10 ** decimals;
    balanceOf[msg.sender] = totalSupply;

    emit Transfer(address(0), msg.sender, totalSupply);
}

function transfer(address _to, uint256 _value) public returns (bool success) {
    require(_to != address(0), "Cannot transfer to zero address");
    require(balanceOf[msg.sender] >= _value, "Insufficient balance");

    balanceOf[msg.sender] -= _value;
    balanceOf[_to] += _value;

    emit Transfer(msg.sender, _to, _value);
    return true;
}

function approve(address _spender, uint256 _value) public returns (bool success) {
    require(_spender != address(0), "Cannot approve zero address");

    allowance[msg.sender][_spender] = _value;

    emit Approval(msg.sender, _spender, _value);
    return true;
}

function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
    require(_from != address(0), "Cannot transfer from zero address");
    require(_to != address(0), "Cannot transfer to zero address");
    require(balanceOf[_from] >= _value, "Insufficient balance");
    require(allowance[_from][msg.sender] >= _value, "Allowance exceeded");

    balanceOf[_from] -= _value;
    balanceOf[_to] += _value;
    allowance[_from][msg.sender] -= _value;

    emit Transfer(_from, _to, _value);
    return true;
}

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

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

contract MyTokenTest is Test {
    MyToken token;
    address alice = address(0x1);
    address bob = address(0x2);

    function setUp() public {
        token = new MyToken("My Token", "MTK", 1000000);
    }

    function testInitialSupply() public {
        assertEq(token.totalSupply(), 1000000 * 10**18);
        assertEq(token.balanceOf(address(this)), 1000000 * 10**18);
    }

    function testTransfer() public {
        token.transfer(alice, 100 * 10**18);
        assertEq(token.balanceOf(alice), 100 * 10**18);
    }

    function testApprove() public {
        token.approve(alice, 50 * 10**18);
        assertEq(token.allowance(address(this), alice), 50 * 10**18);
    }

    function testTransferFrom() public {
        token.transfer(alice, 100 * 10**18);

        vm.prank(alice);
        token.approve(bob, 50 * 10**18);

        vm.prank(bob);
        token.transferFrom(alice, bob, 30 * 10**18);

        assertEq(token.balanceOf(bob), 30 * 10**18);
        assertEq(token.allowance(alice, bob), 20 * 10**18);
    }
}

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

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

contract DeployMyToken is Script {
    function run() external {
        uint256 deployerPrivateKey = vm.envUint("PRIVATE_KEY");

        vm.startBroadcast(deployerPrivateKey);

        MyToken token = new MyToken("My Token", "MTK", 1000000);

        console.log("Token deployed at:", address(token));

        vm.stopBroadcast();
    }
}

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

/**
 * @title MyToken
 * @dev ERC20 standard token implementation for educational purposes
 */
contract MyToken {
    // ═══════════════════════════════════════════════════════════════════
    // State Variables
    // ═══════════════════════════════════════════════════════════════════

    string public name;         // Token name, e.g. "My Token"
    string public symbol;       // Token symbol, e.g. "MTK"
    uint8 public decimals;      // Decimal places, usually 18 (same as ETH)
    uint256 public totalSupply; // Total supply

    // address => balance
    mapping(address => uint256) public balanceOf;

    // owner => (spender => allowance)
    mapping(address => mapping(address => uint256)) public allowance;

    // ═══════════════════════════════════════════════════════════════════
    // Events
    // ═══════════════════════════════════════════════════════════════════

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

    // ═══════════════════════════════════════════════════════════════════
    // Constructor
    // ═══════════════════════════════════════════════════════════════════

    /**
     * @dev Initialize token
     * @param _name Token name
     * @param _symbol Token symbol
     * @param _initialSupply Initial supply (will be multiplied by 10^18)
     */
    constructor(string memory _name, string memory _symbol, uint256 _initialSupply) {
        name = _name;
        symbol = _symbol;
        decimals = 18;

        // Mint initial supply to deployer
        totalSupply = _initialSupply * 10 ** decimals;
        balanceOf[msg.sender] = totalSupply;

        emit Transfer(address(0), msg.sender, totalSupply);
    }

    // ═══════════════════════════════════════════════════════════════════
    // ERC20 Core Functions
    // ═══════════════════════════════════════════════════════════════════

    /**
     * @dev Transfer tokens
     * @param _to Recipient address
     * @param _value Amount to transfer
     * @return success Whether the transfer succeeded
     */
    function transfer(address _to, uint256 _value) public returns (bool success) {
        require(_to != address(0), "Cannot transfer to zero address");
        require(balanceOf[msg.sender] >= _value, "Insufficient balance");

        balanceOf[msg.sender] -= _value;
        balanceOf[_to] += _value;

        emit Transfer(msg.sender, _to, _value);
        return true;
    }

    /**
     * @dev Approve spender to spend tokens on your behalf
     * @param _spender Address to be approved
     * @param _value Allowance amount
     * @return success Whether the approval succeeded
     */
    function approve(address _spender, uint256 _value) public returns (bool success) {
        require(_spender != address(0), "Cannot approve zero address");

        allowance[msg.sender][_spender] = _value;

        emit Approval(msg.sender, _spender, _value);
        return true;
    }

    /**
     * @dev Transfer tokens on behalf of owner
     * Requires: caller must have sufficient allowance
     * @param _from Sender address
     * @param _to Recipient address
     * @param _value Amount to transfer
     * @return success Whether the transfer succeeded
     */
    function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
        require(_from != address(0), "Cannot transfer from zero address");
        require(_to != address(0), "Cannot transfer to zero address");
        require(balanceOf[_from] >= _value, "Insufficient balance");
        require(allowance[_from][msg.sender] >= _value, "Allowance exceeded");

        balanceOf[_from] -= _value;
        balanceOf[_to] += _value;
        allowance[_from][msg.sender] -= _value;

        emit Transfer(_from, _to, _value);
        return true;
    }
}