玩区块链怎么能不会发代币呢，此文就给大家讲解一下以太坊代币 ERC-20 标准，解析代币标准中相关的接口及代码实现，带大家快速完成一套代币代码的修改编写。

了解代币发行

代币，英文（Token），翻译成“通证”更贴切一些。如果稍微对区块链有一定的了解，都听说过一两种代币，甚至购买或使用过。最近火爆异常的 EOS 前期就是在以太坊上基于 ERC-20 发布的一套代币。

我们可以通过目前最流行的区块链浏览器之一 Etherscan，来大概了解一下目前市面上的代币情况，访问这个链接，可查看当前在以太坊上发布的代币情况。

enter image description here

通过上图画框的部分可以看到，目前此网址已经检测出 7 万多代币的智能合约，排行居首位的就是最近火爆的 EOS。下面来讲解一下什么是 ERC-20 标准，代币的代码又是如何编写的。

什么是 ERC-20 标准

ERC-20 标准推出于 2015 年 11 月，本质上来说它是一种规范，规定了如果根据这套标准发行代币，需要遵循什么。因此，它也表现出来一种通用的可预测的特性。针对我们开发人员来说它其实就是定义了一些待实现方法的接口（interface），当实现了这套接口的具体方法之后，所有的钱包就可以直接进行兼容，比如 Jaxx、MEW、imToken 等。

从另外一方面来说，Token 合约就是包含了一个对账户地址及其余额的映射的智能合约（Smart Contract）。

ERC-20 接口标准

当要实现一个满足 ERC-20 接口标准的 Token 智能合约时，该合约必须满足以下内容实现。

name

返回当前 Token 的名称，比如：DSToken，可选项。

function name() constant returns (string name)

在智能合约中定义，可通过构造方法传值进行初始化，也可直接在代码中指定：

string public name;

symbol

symbol 就是通常使用的简称，比如：EOS，可选项。

function symbol() constant returns (string symbol)

与 name 一样，可通过构造方法传值进行初始化，也可直接在代码中指定：

string public symbol;

decimals

当前代币支持的最小精度，也就是小数点后多少位，比如此值为 2，表示 1 个 Token 可分割为 100 份。对应以太坊来说，ETH 的此值为 18，也就是说一个 ETH 可以分割为小数点后 18 位的精度。一般情况下，当查询一个 Token 余额时，是按照最小精度的整型来显示的。比如 decimals 为 2，发行一个代币，那么查询到的结果为 100，此值为可选项。

function decimals() constant returns (uint8 decimals)

与 name 和 symbol 一样，可通过构造方法传值进行初始化，也可直接在代码中指定：

uint8 public decimals;

totalSupply

Token 的发型总量，此处需注意这个数量的单位与 decimals 中指定的最小单位一致，注意它们之间的换算。

function totalSupply() constant returns (uint256 totalSupply)

与上面的属性一样，可通过构造方法传值进行初始化，也可直接在代码中指定：

uint256 public totalSupply;

balanceOf

查询指定地址账户余额，返回余额以最小单位计算。

function balanceOf(address _owner) constant returns (uint256 balance)

此账户余额对应智能合约代码中余额的存储，所有的地址与余额之间的关联都是通过此 mapping 进行存储：

mapping (address => uint256) public balanceOf;

transfer

代币转账操作，从执行转账的地址转出指定数量的代币到目标地址，并且必须触发 Transfer 事件。如果执行转账地址没有足够的余额则抛出异常，支持转账金额为 0。

function transfer(address to, uint256 value) public returns (bool);

transferFrom

从_from地址发送数量为_value的 token 到_to地址，必须触发 Transfer 事件，主要应用场景为智能合约中对操作账户进行授权，然后达到某个条件时，操作账户可以对被操作账户进行转账操作。如果无权操作则需抛出异常，与 tranfer 相同，可以进行 0 值操作。

function transferFrom(address _from, address _to, uint256 _value) returns (bool success)

approve

设置_spender地址可以从操作此方法的地址那里获得的最高金额，此方法可以多次调用。注意：为了阻止向量攻击，客户端需要确认以这样的方式创建用户接口，即将它们设置为 0，然后将其设置为同一个花费者的另一个值。虽然合同本身不应该强制执行，允许向后兼容以前部署的合同兼容性。

function approve(address _spender, uint256 _value) returns (bool success)

allowance

查询_spender可从_owner提取的金额。

function allowance(address _owner, address _spender) constant returns (uint256 remaining)

Transfer Events

当 Token 被转移的时候必须被触发，包括转移金额为 0。

event Transfer(address indexed _from, address indexed _to, uint256 _value)

Approval Events

当成功调用 approve(address _spender, uint256 _value)后，必须被触发。

event Approval(address indexed _owner, address indexed _spender, uint256 _value)

总结

综上所述我们可以看到一个标准的 ERC-20 代币接口如下：

contract ERC20 {  
  function totalSupply() constant returns (uint totalSupply);  
  function balanceOf(address _owner) constant returns (uint balance);  
  function transfer(address _to, uint _value) returns (bool success); 
  function transferFrom(address _from, address _to, uint _value) returns (bool success);  
  function approve(address _spender, uint _value) returns (bool success);  
  function allowance(address _owner, address _spender) constant returns (uint remaining);  
  event Transfer(address indexed _from, address indexed _to, uint _value);  
    event Approval(address indexed _owner, address indexed _spender, uint _value);
}

关于 ERC-20 Token 标准就介绍这么多，此协议发布于 2015 年 11 月 19 日，标准的原版位于以太坊的 GitHub 上，最原始版本地址详见这里。

实例代码

根据上面的标准讲解，大家已经了解了 ERC-20 的基本规则，下面粘贴一套由本人发布的，已经写入区块链上的代币，对照着上面的规则与下面的代码，做进一步的学习。

pragma solidity ^0.4.18;
 
/**
 * Math operations with safety checks
 */
contract SafeMath {
  function safeMul(uint256 a, uint256 b) internal pure returns (uint256) {
    if (a == 0) {
      return 0;
    }
    uint256 c = a * b;
    assert(c / a == b);
    return c;
  }
 
  function safeDiv(uint256 a, uint256 b) internal pure returns (uint256) {
    assert(b > 0);
    uint256 c = a / b;
    assert(a == b * c + a % b);
    return c;
  }
 
  function safeSub(uint256 a, uint256 b) internal pure returns (uint256) {
    assert(b <= a);
    return a - b;
  }
 
  function safeAdd(uint256 a, uint256 b) internal pure returns (uint256) {
    uint256 c = a + b;
    assert(c>=a && c>=b);
    return c;
  }
 
}
contract AC is SafeMath{
    string public name;
    string public symbol;
    uint8 public decimals = 18;
    uint256 public totalSupply;
    address public owner;
 
    /* This creates an array with all balances */
    mapping (address => uint256) public balanceOf;
    mapping (address => uint256) public freezeOf;
    mapping (address => mapping (address => uint256)) public allowance;
 
    /* This generates a public event on the blockchain that will notify clients */
    event Transfer(address indexed from, address indexed to, uint256 value);
 
    /* This notifies clients about the amount burnt */
    event Burn(address indexed from, uint256 value);
 
    /* This notifies clients about the amount frozen */
    event Freeze(address indexed from, uint256 value);
 
    /* This notifies clients about the amount unfrozen */
    event Unfreeze(address indexed from, uint256 value);
 
    /* Initializes contract with initial supply tokens to the creator of the contract */
    function AC(
        uint256 initialSupply,
        string tokenName,
        string tokenSymbol,
        address holder)  public{
        totalSupply = initialSupply * 10 ** uint256(decimals); // Update total supply
        balanceOf[holder] = totalSupply;                       // Give the creator all initial tokens
        name = tokenName;                                      // Set the name for display purposes
        symbol = tokenSymbol;                                  // Set the symbol for display purposes
        owner = holder;
    }
 
    /* Send coins */
    function transfer(address _to, uint256 _value) public{
        require(_to != 0x0);  // Prevent transfer to 0x0 address. Use burn() instead
        require(_value > 0); 
        require(balanceOf[msg.sender] >= _value);           // Check if the sender has enough
        require(balanceOf[_to] + _value >= balanceOf[_to]); // Check for overflows
        balanceOf[msg.sender] = SafeMath.safeSub(balanceOf[msg.sender], _value);                     // Subtract from the sender
        balanceOf[_to] = SafeMath.safeAdd(balanceOf[_to], _value);                            // Add the same to the recipient
        Transfer(msg.sender, _to, _value);                   // Notify anyone listening that this transfer took place
    }
 
    /* Allow another contract to spend some tokens in your behalf */
    function approve(address _spender, uint256 _value) public
        returns (bool success) {
        require(_value > 0); 
        allowance[msg.sender][_spender] = _value;
        return true;
    }
 
    /* A contract attempts to get the coins */
    function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
        require(_to != 0x0);                                // Prevent transfer to 0x0 address. Use burn() instead
        require(_value > 0); 
        require(balanceOf[_from] >= _value);                 // Check if the sender has enough
        require(balanceOf[_to] + _value >= balanceOf[_to]);  // Check for overflows
        require(_value <= allowance[_from][msg.sender]);     // Check allowance
        balanceOf[_from] = SafeMath.safeSub(balanceOf[_from], _value);                           // Subtract from the sender
        balanceOf[_to] = SafeMath.safeAdd(balanceOf[_to], _value);                             // Add the same to the recipient
        allowance[_from][msg.sender] = SafeMath.safeSub(allowance[_from][msg.sender], _value);
        Transfer(_from, _to, _value);
        return true;
    }
 
    function burn(uint256 _value) public returns (bool success) {
        require(balanceOf[msg.sender] >= _value);            // Check if the sender has enough
        require(_value > 0); 
        balanceOf[msg.sender] = SafeMath.safeSub(balanceOf[msg.sender], _value);                      // Subtract from the sender
        totalSupply = SafeMath.safeSub(totalSupply,_value);                                // Updates totalSupply
        Burn(msg.sender, _value);
        return true;
    }
 
    function freeze(uint256 _value) public returns (bool success) {
        require(balanceOf[msg.sender] >= _value);            // Check if the sender has enough
        require(_value > 0); 
        balanceOf[msg.sender] = SafeMath.safeSub(balanceOf[msg.sender], _value);                      // Subtract from the sender
        freezeOf[msg.sender] = SafeMath.safeAdd(freezeOf[msg.sender], _value);                                // Updates totalSupply
        Freeze(msg.sender, _value);
        return true;
    }
 
    function unfreeze(uint256 _value) public returns (bool success) {
        require(freezeOf[msg.sender] >= _value);            // Check if the sender has enough
        require(_value > 0); 
        freezeOf[msg.sender] = SafeMath.safeSub(freezeOf[msg.sender], _value);                      // Subtract from the sender
        balanceOf[msg.sender] = SafeMath.safeAdd(balanceOf[msg.sender], _value);
        Unfreeze(msg.sender, _value);
        return true;
    }
}   

关于此智能合约的代码就不详细进行解释了，有一定编程基础的话基本上能看懂，甚至可以直接修改合约名称即可重新发布一套代币，所有的可变参数都通过构造函数传递。

标准合约扩展

上面介绍了 ERC-20 的标准合约，就像 Java 里面的接口一样，我们要实现接口定义的方法，同时也可以在实现类里面进行其他功能的扩展。上面的合约代码中比标准合约多出了以下功能：

    /* This notifies clients about the amount burnt */
    event Burn(address indexed from, uint256 value);
     
    /* This notifies clients about the amount frozen */
    event Freeze(address indexed from, uint256 value);
     
    /* This notifies clients about the amount unfrozen */
    event Unfreeze(address indexed from, uint256 value);

顾名思义，这三个事件分别对应（具体看实现代码）：

• 燃烧操作者账户中指定金额的代币，当燃烧时代币总额也会对应减少；
• 冻结指定账户指定金额；
• 解冻指定账户指定金额。

实战经验

如果看过几套 Token 代码，你会发现此套代码与一般的代码构造函数有所不同，里面多了以下参数：

owner = holder;

这里的应用场景主要是为了安全起见，比如准备发布一套代币而发布者是技术人员，如果直接将私钥给技术人员或在网络上传输会有安全问题，那么直接通过此参数可以指定此智能合约的 owner，这样就不用担心代币拥有超级权限的 owner 私钥外泄，直接用某一个地址给另外一个地址发布代币，是不是方便很多。