Ethereum Token

ERC 20 规定必须实现下面 6 个方法：

function totalSupply() public view returns (uint256);  // 返回总共的发行量
function balanceOf(address tokenOwner) public view returns (uint256);  // 返回某帐户的余额
function transfer(address receiver, uint256 tokens) public returns (bool);  // 向另外一个地址转账
function approve(address delegate, uint256 tokens)  public returns (bool);
function transferFrom(address owner, address buyer, uint256 tokens) public returns (bool);
function allowance(address owner, address delegate) public view returns (uint256);

其中，前三个函数比较好理解， totalSupply() 返回总共的发行量， balanceOf() 返回某帐户的余额， transfer() 向另外一个地址转账。

后面三个函数可以认为和“市场运营”行为相关。考虑这个场景：用户 A，手里有 100 万 Token，他可以授权用户 B（可能是个智能合约）最多把他帐户上的 20 万 Token 转给 20 个用户（如用户 C1 到 C20）。这个场景可以通过下面步骤实现：
第一步，用户 A 通过 approve 授权用户 B 指定数量的 Token 转移权，即调用：

approve(用户B的地址, 20万)                    // 用户 A 调用

第二步，用户 B 调用 transferFrom 分发用户 A 的 Token 给用户 C1 到 C20，即调用：

transferFrom(用户A的地址, 用户C1的地址, 1万)   // 用户 B 调用，Token 从 A 转移到 C1
transferFrom(用户A的地址, 用户C2的地址, 1万)   // 用户 B 调用，Token 从 A 转移到 C2
......
transferFrom(用户A的地址, 用户C20的地址, 1万)  // 用户 B 调用，Token 从 A 转移到 C20

此外，通过 allowance 可以查询剩余的授权额度。如，查看用户 A 授权给用户 B 的额度还有多少没有用完：

allowance(用户A的地址, 用户B的地址)            // 所有人都可以调用

除了上面介绍的 6 个必须实现的方法外，ERC 20 中还定义了下面 3 个“可选实现的”方法（不过，大家基本上都实现了这些方法）：

function name() public view returns (string)    // 返回 Token 名字，如 MyToken
function symbol() public view returns (string)  // 返回 Token 符号，如 HIX
function decimals() public view returns (uint8) // 返回 Token 精度（小数点位数）

ERC 20 中定义了两类事件日志：

event Transfer(address indexed from, address indexed to, uint256 tokens);   // 有 token 转移时
event Approval(address indexed tokenOwner, address indexed spender, uint256 tokens);

参考：How to Create an ERC20 Token the Simple Way

function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external
function nonces(address owner) external view returns (uint)
function DOMAIN_SEPARATOR() external view returns (bytes32)

{
  "types": {
    "EIP712Domain": [
      {
        "name": "name",
        "type": "string"
      },
      {
        "name": "version",
        "type": "string"
      },
      {
        "name": "chainId",
        "type": "uint256"
      },
      {
        "name": "verifyingContract",
        "type": "address"
      }
    ],
    "Permit": [{
      "name": "owner",
      "type": "address"
      },
      {
        "name": "spender",
        "type": "address"
      },
      {
        "name": "value",
        "type": "uint256"
      },
      {
        "name": "nonce",
        "type": "uint256"
      },
      {
        "name": "deadline",
        "type": "uint256"
      }
    ],
    "primaryType": "Permit",
    "domain": {
      "name": erc20name,
      "version": version,
      "chainId": chainid,
      "verifyingContract": tokenAddress
  },
  "message": {
    "owner": owner,
    "spender": spender,
    "value": value,
    "nonce": nonce,
    "deadline": deadline
  }
}}

下面是 ERC 20 的一个简单实现（摘自：https://www.toptal.com/ethereum/create-erc20-token-tutorial ）：

pragma solidity >=0.5.0;

library SafeMath {
    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        assert(b <= a);
        return a - b;
    }

    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        assert(c >= a);
        return c;
    }
}

contract ERC20Basic {
    string public constant name = "ERC20Basic";
    string public constant symbol = "BSC";
    uint8 public constant decimals = 18;

    event Approval(
        address indexed tokenOwner,
        address indexed spender,
        uint256 tokens
    );
    event Transfer(address indexed from, address indexed to, uint256 tokens);

    mapping(address => uint256) balances;   // 代币余额就是 mapping 数据 balances 中的一个数字

    mapping(address => mapping(address => uint256)) allowed;

    uint256 totalSupply_;

    using SafeMath for uint256;

    constructor(uint256 total) public {
        totalSupply_ = total;
        balances[msg.sender] = totalSupply_;
    }

    function totalSupply() public view returns (uint256) {
        return totalSupply_;
    }

    function balanceOf(address tokenOwner) public view returns (uint256) {
        return balances[tokenOwner];
    }

    function transfer(address receiver, uint256 numTokens)
        public
        returns (bool)
    {
        require(numTokens <= balances[msg.sender], "balance not enough");
        balances[msg.sender] = balances[msg.sender].sub(numTokens);
        balances[receiver] = balances[receiver].add(numTokens);
        emit Transfer(msg.sender, receiver, numTokens);
        return true;
    }

    function approve(address delegate, uint256 numTokens)
        public
        returns (bool)
    {
        allowed[msg.sender][delegate] = numTokens;
        emit Approval(msg.sender, delegate, numTokens);
        return true;
    }

    function allowance(address owner, address delegate)
        public
        view
        returns (uint256)
    {
        return allowed[owner][delegate];
    }

    function transferFrom(address owner, address buyer, uint256 numTokens)
        public
        returns (bool)
    {
        require(numTokens <= balances[owner], "balance not enough");
        require(numTokens <= allowed[owner][msg.sender], "allowance not enough");

        balances[owner] = balances[owner].sub(numTokens);
        allowed[owner][msg.sender] = allowed[owner][msg.sender].sub(numTokens);
        balances[buyer] = balances[buyer].add(numTokens);
        emit Transfer(owner, buyer, numTokens);
        return true;
    }
}

下面是 ERC 20 的其它实现：
ConsenSys implementation
OpenZeppelin implementation

  function batchTransfer(address[] _receivers, uint256 _value) public whenNotPaused returns (bool) {
    uint cnt = _receivers.length;
    uint256 amount = uint256(cnt) * _value;   // 这里可能整数溢出
    require(cnt > 0 && cnt <= 20);
    require(_value > 0 && balances[msg.sender] >= amount);

    balances[msg.sender] = balances[msg.sender].sub(amount);
    for (uint i = 0; i < cnt; i++) {
        balances[_receivers[i]] = balances[_receivers[i]].add(_value);
        Transfer(msg.sender, _receivers[i], _value);
    }
    return true;
  }

ERC 223 通过 transfer 往合约转账时，会调用目标合约的 tokenFallback 方法；而 ERC 677 通过 transferAndCall 往合约转账时，会调用目标合约的 onTokenTransfer 方法。

这两种方式都可以实现“转账时自动触发目标合约的业务逻辑”。但 ERC 223 直接修改了 ERC 20 中 transfer 方法的语义，这导致一个问题：没有实现 tokenFallback 方法的合约无法接收 ERC 233 代币，从某种意义上说这限制了 ERC 233 的应用；而 ERC 677 是通过增加一个新方法（ transferAndCall ）的方式来实现“触发目标合约的业务逻辑”，如果不需要这个功能时，我们还是可以使用 ERC 20 中就存在的 transfer 方法往任意合约转移 ERC 677 代币，这使得 ERC 677 更为灵活。

ERC 777 的标准比较长，如果从零开始实现比较麻烦。OpenZeppelin 有 ERC 777 的开源实现，请参考：https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC777/ERC777.sol

基于 OpenZeppelin 的实现我们可以很简单地实现自己的 ERC 777 代币合约，如：

pragma solidity ^0.6.0;

import "@openzeppelin/contracts/token/ERC777/ERC777.sol";

contract MyERC777 is ERC777 {
    // name 为 MyERC777Token，symbol 为 XXX
    constructor() ERC777("MyERC777Token", "XXX", new address[](0)) public
    {
        // 初始发行量 2100 万
        uint256 initialSupply = 2100 * 10000 * 10 ** 18;   // ERC777 的 decimals 固定为 18
        _mint(msg.sender, msg.sender, initialSupply, "", "");
    }
}

下面是接收 ERC 777 代币的合约的例子（仅演示，未亲自测试）：

pragma solidity ^0.6.0;

import "@openzeppelin/contracts/token/ERC777/IERC777Recipient.sol";
import "@openzeppelin/contracts/token/ERC777/IERC777.sol";
import "@openzeppelin/contracts/introspection/IERC1820Registry.sol";

contract Simple777Recipient is IERC777Recipient {
    address _owner;
    IERC777 _token;

    IERC1820Registry private _erc1820 = IERC1820Registry(0x1820a4B7618BdE71Dce8cdc73aAB6C95905faD24);

    event DoneStuff(address operator, address from, address to, uint256 amount, bytes userData, bytes operatorData);

    // keccak256("ERC777TokensRecipient")
    bytes32 private constant TOKENS_RECIPIENT_INTERFACE_HASH = 0xb281fc8c12954d22544db45de3159a39272895b169a852b314f9cc762e44c53b;

    constructor(address token) public {
        _owner = msg.sender;
        _token = IERC777(token);

        // 向 ERC 1820 中注册接口 ERC777TokensRecipient 的实现为“本合约”
        _erc1820.setInterfaceImplementer(address(this), TOKENS_RECIPIENT_INTERFACE_HASH, address(this));
    }

    // 收到 ERC 777 代币时会被自动调用
    function tokensReceived(
        address operator,
        address from,
        address to,
        uint256 amount,
        bytes calldata userData,
        bytes calldata operatorData
    ) external override {
        // 只要 constructor 函数中指定的 ERC 777 代币，其它的 ERC 777 代币直接拒绝
        require(msg.sender == address(_token), "Simple777Recipient: Invalid token");

        // 记录 Log
        emit DoneStuff(operator, from, to, amount, userData, operatorData);
    }

    // 把收到的代币提到“本合约”创建者帐户
    function withdrawAll() external {
        require(msg.sender == _owner, "no permision");
        uint256 balance = _token.balanceOf(address(this));
        _token.send(_owner, balance, "withdrawAll"); // 也可以调 transfer，这时不能附带信息
    }

}

通过 ERC 777 的 send/mint 方法进行转账时，当目标地址是合约地址时，目标地址必须在 ERC 1820 合约上注册了接口 ERC777TokensRecipient 的实现，否则转换会失败。

这限制了很多合约地址无法接收 send/mint 发来的 ERC 777 代币，因为合约很可能没有在 ERC 1820 上注册接口 ERC777TokensRecipient 的实现。对于 send 来说，问题不大，因为使用 transfer 代替 send 可绕过这个问题；对于 mint 来说，不好解决，有人抱怨这个问题，参考：https://github.com/OpenZeppelin/openzeppelin-contracts/issues/2226

OpenZeppelin 对 ERC721 的实现可参考：https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC721/ERC721.sol

OpenZeppelin 对 ERC1155 的实现可参考：https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC1155/ERC1155.sol

Enjin 对 ERC1155 的实现可参考：https://github.com/enjin/erc-1155/blob/master/contracts/ERC1155.sol

在 ERC1155 中，每个 id 关联着不同的 owner 和对应的余额，在实现余额时往往采用下面方式：

contract ERC1155
{
    // id => (owner => balance)
    mapping (uint256 => mapping(address => uint256)) internal balances;

    // ......
}

这样，对于某个编号为 id1 的 token，可能被多个人拥有不同的数量，如：

#id  owner                                       balance
id1  0x65c956226C36d48FD6A7F457813e53B79c563720  7100
id1  0x21646043e1ee182576F33c07C03b2d404746B535  2000
id1  0x5714108B16557ce210c50dDbFF7264431E1408D7  1300