以太坊ERC-20协议详解

区块链学习: https://github.com/xianfeng92/Love-Ethereum

-------------------------------------------------------------------

ERC20是以太坊定义的一个[代币标准](https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20.md), 利用以太坊的智能合约可以轻松编写出属于自己的代币，这里的代币可以代表在平台或者社区的所拥有的权益。

# 太坊的代币标准

使用代币合约标准可以在以太坊上发行在区块链应用（Dapp）上所使用的代币。

## Token

## Methods

NOTE: Callers MUST handle false from returns (bool success). Callers MUST NOT assume that false is never returned!

调用者必须处理返回值为false的方法

## name
Returns the name of the token


## symbol
Returns the symbol of the token


## decimals
Returns the number of decimals the token uses


## totalSupply
Returns the total token supply


## balanceOf
Returns the account balance of another account with address _owner
返回账户owner中的余额

## transfer
Transfers _value amount of tokens to address _to, and __MUST fire the Transfer event__. The function SHOULD throw if the _from account balance does not have enough tokens to spend

Note Transfers of 0 values MUST be treated as normal transfers and fire the Transfer event

## transferFrom


Transfers _value amount of tokens from address _from to address _to, and MUST fire the Transfer event


The transferFrom method is used for a withdraw workflow, allowing contracts to transfer tokens on your behalf. This can be used for example to allow a contract to transfer tokens on your behalf and/or to charge fees in sub-currencies


transferFrom方法用于"转账"流程，允许合约代表您转让token。 例如，这可用于允许合同代表您转让代币或者以子货币收取费用。


Note Transfers of 0 values MUST be treated as normal transfers and fire the Transfer event

## approve

Allows _spender to withdraw from your account multiple times, up to the _value amount. If this function is called again it overwrites the current allowance with _value

允许spender从你的账户中多次"提取"token,直到规定的金额value


## allowance


Returns the amount which _spender is still allowed to withdraw from _owner


返回账户spender可以从合约所有者owner中提取的token数量




## Events


### Transfer


MUST trigger when tokens are transferred, including zero value transfers.


涉及到token转移时必须触发此事件


A token contract which creates new tokens SHOULD trigger a Transfer event with the _from address set to 0x0 when tokens are created


代币合约部署时也需要触发此事件


### Approval


MUST trigger on any successful call to approve(address _spender, uint256 _value)






# 代币合约实例


下面是一个 token 合约的例子，可以直接复制到remix进行合约部署的。


事先说明两点：


１token的发行很简单的,其价值还是要看和token所关联的项目。有很多组织没有项目就胡乱发token。


２token这个概论本身是有很大的价值的，如何发行和利用token,对项目成败也有很多影响。




pragma solidity ^0.4.20;


interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) public; }


contract TokenLBJ {
　　　　// 代币名称,如:"LeBron James"
    string public name;
    // 代币符合，一般用代币名称的缩写，如 LBJ
    string public symbol;
    // 每个代币可细分的到多少位，即最小代币单位。18为默认值
    uint8 public decimals = 18;
　　　　//　代币总供应量，这里指的是一共有多少个以最小单位所计量的代币
    uint256 public totalSupply;


    // 用mapping保存每个地址对应的余额
    mapping (address => uint256) public balanceOf;


    // 存储对账号的控制，有两点需要注意的：１本合约账户可以授权其他账户转移token数量　２　其他账户授权该合约账户转移token数量
    mapping (address => mapping (address => uint256)) public allowance;


    // 事件，用来通知客户端交易发生
    event Transfer(address indexed from, address indexed to, uint256 value);


    // 事件，用来通知客户端代币被销毁
    event Burn(address indexed from, uint256 value);


    /**
     * 初始化构造，初始化后代币全部存储于合约创建者账户
     */
    function TokenLBJ(uint256 initialSupply, string tokenName, string tokenSymbol) public {
        totalSupply = initialSupply * 10 ** uint256(decimals);  // 供应的份额，份额跟最小的代币单位有关，份额 = 币数 * 10 ** decimals
        balanceOf[msg.sender] = totalSupply;                // 创建者拥有所有的代币
        name = tokenName;                                   // 代币名称
        symbol = tokenSymbol;                               // 代币符号
    }


    /**
     * 代币交易转移的内部实现,只能被本合约调用
     */
    function _transfer(address _from, address _to, uint _value) internal {
        // 确保目地地址不为0x0，因为0x0地址代表的是销毁
        require(_to != 0x0);
        // 确保发送者账户有足够的余额
        require(balanceOf[_from] >= _value);
        // 确保_value为正数，如果为负数，那相当于付款者账户钱越买越多～哈哈～
        require(balanceOf[_to] + _value > balanceOf[_to]);


        // 交易前，双方账户余额总和
        uint previousBalances = balanceOf[_from] + balanceOf[_to];
        // 将发送方账户余额减value
        balanceOf[_from] -= _value;
        // 将接收方账户余额加value
        balanceOf[_to] += _value;
　　　　　　　　//通知客户端交易发生
        Transfer(_from, _to, _value);


        // 用assert来检查代码逻辑,即交易前后双发账户余额的和应该是相同的
        assert(balanceOf[_from] + balanceOf[_to] == previousBalances);
    }


    /**
     * 从合约创建交易者账号发送`_value`个代币到 `_to`账号
     *　这种类似于现在很多项目的空头吧，很多空气项目其实也就是在以太坊上发个币，然后就割韭菜，所以学学区块链技术还是很有必要的
     * @param _to 接收者地址
     * @param _value 转移数额
     */
    function transfer(address _to, uint256 _value) public {
　　　　　　　　//_from始终是合约创建者的地址
        _transfer(msg.sender, _to, _value);
    }


    /**
     *批量转帐固定金额
    /
    function batchTransfer(address[] _to, uint _value) public{
        require(address.length > 0)
        for(uint i=0 ; i< address.length; i++){
           _transfer(msg.sender,address[i], _value);
         }
    }


    /**
　　　　　* Transfer tokens from other address
     * Send '_value' tokens to '_to' on behalf of '_from'
     * @param _from 发送者地址
     * @param _to 接收者地址
     * @param _value 转移数额
     */
    function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
        // _from 所授权　msg.sender 转移的代币数量
        require(_value <= allowance[_from][msg.sender]);
        allowance[_from][msg.sender] -= _value;
        _transfer(_from, _to, _value);
        return true;
    }


    /**
     *
     * 允许发送者`_spender` 花费不多于 `_value` 个代币
     *
     * @param _spender The address authorized to spend
     * @param _value the max amount they can spend
     */
    function approve(address _spender, uint256 _value) public
        returns (bool success) {
　　　　　　　　//具体结构如下：(msg.sender --> allowance[msg.sender])--> mapping(address => uint)
        // msg.sender　允许　_spender　最多花费的代币数量　
        allowance[msg.sender][_spender] = _value;
        return true;
    }


    /**
     * 设置允许一个地址（合约）以我（创建交易者）的名义可最多花费的代币数。
     *
     * @param _spender 被授权的地址（合约）
     * @param _value 最大可花费代币数
     * @param _extraData 发送给合约的附加数据
     */
    function approveAndCall(address _spender, uint256 _value, bytes _extraData)
        public
        returns (bool success) {
        tokenRecipient spender = tokenRecipient(_spender);
        if (approve(_spender, _value)) {
            // 通知合约
            spender.receiveApproval(msg.sender, _value, this, _extraData);
            return true;
        }
    }


    /**
     * 销毁合约账户中指定数量的代币
     */
    function burn(uint256 _value) public returns (bool success) {
　　　　　　　　// 检查合约账户是否有足够的代币
        require(balanceOf[msg.sender] >= _value);
　　　　　　　　// 将合约账户余额减少value
        balanceOf[msg.sender] -= _value;
　　　　　　　　// 对应代币总供应量也应该减少
        totalSupply -= _value;
        Burn(msg.sender, _value);
        return true;
    }


    /**
     * 销毁用户账户中指定个代币
     *
     * Remove `_value` tokens from the system irreversibly on behalf of `_from`.
     *
     * @param _from the address of the sender
     * @param _value the amount of money to burn
     */
    function burnFrom(address _from, uint256 _value) public returns (bool success) {
        require(balanceOf[_from] >= _value);                // Check if the targeted balance is enough
        require(_value <= allowance[_from][msg.sender]);    // Check allowance
        balanceOf[_from] -= _value;                         // Subtract from the targeted balance
        allowance[_from][msg.sender] -= _value;             // Subtract from the sender's allowance
        totalSupply -= _value;                              // Update totalSupply
        Burn(_from, _value);
        return true;
    }
}




# 给代币增加可管理、增发、兑换、冻结等功能




contract owned{
  
   address public owner;
   
   function owned(){
        owner = msg.sender;
    }


　　　//
   modifier onlyOwner {
        require(msg.sender == owner);
        _;
      }


   function transferOwnership(address newOwner) onlyOwner{
        owner = newOwner;
     }
 }


该合约中加入了一个函数修改器（Function Modifiers）onlyOwner，函数修改器是一个合约属性，可以被继承，还能被重写。它用于在函数执行前检查某种前置条件。


此时让TokenLBJ继承owned，使其拥有onlyOwner修改器。


## 代币增发




function mintToken(address target, uint256 mintedAmount) onlyOwner{


      balanceof[target] += mintedAmount;
      totalSupply += mintedAmount;
      Transfer(0,owner,mintedAmount);
      Transfer(owner, target, mintedAmount);
 }


注意onlyOwner修改器添加在函数末尾，这表示只有ower才能调用这用函数。他的功能很简单，就是给指定的账户增加代币，同时增加总供应量。


## 资产冻结


有时为了监管的需要，需要实现冻结某些账户，冻结后，其资产仍在账户，但是不允许交易，直到解除冻结。给合约添加以下的变量和方法（可以添加到合约的任何地方，但是建议把mapping加到和其他mapping一起，event也是如此）：


mapping(address => bool) public frozenAccount;


event FrozenFunds(address target, bool frozen);


function　freezeAccount(address target, bool freeze)　onlyOwner {
    frozenAccount[target] = freeze;
    FrozenFunds(target, freeze);
 }


单单以上的代码还无法冻结，需要把他加入到transfer函数中才能真正生效，因此修改transfer函数。


function transfer(address _to, uint256 _value){
    
    require(!frozenAccount[msg.sender])
    ...
 }


这样在转账前，对发起交易的账号做一次检查，只有没被冻结的账号才能转账。




## 代币买卖（兑换）


可以自己的货币中实现代币与其他数字货币（ether 或其他tokens）的兑换机制。有了这个功能，我们的合约就可以在一买一卖中赚利润了。


先来设置下买卖价格:


uint256 public sellPrice;
uint256 public buyPrice;


function setPrice (uint256 newSellPrice, uint256 newBuyPrice) onlyOwner{
      sellPrice = newSellPrice;
      buyPrice = newBuyPrice;
  }




setPrices()添加了onlyOwner修改器，注意买卖的价格单位是wei（最小的货币单位： 1 eth = 1000000000000000000 wei)。


添加买卖函数:


function buy() payable returns (uint amount){
   
   amount = msg.value / buyPrice;
   require(balanceof[this] >= amount);
   balanceof[msg.sender] += amount;
   balanceof[this] -= amount;
   Transfer(this, msg.sender,amount);
   return amount;
 }


function sell(uint amount) payable returns (uint revenue){


   require(balanceof[msg.sender] >= amount);
   balanceof[this] += amount;
   balanceof[msg.sender] -= amount;
   revenue = amount * sellPrice;
   msg.sender.transfer(revenue);
   Transfer(msg.sender, this, amount);
   return revenue;
 }


加入了买卖功能后，要求我们在创建合约时发送足够的以太币，以便合约有能力回购市面上的代币，否则合约将破产，用户没法先合约卖代币。


参考:[Create your own crypto-currency](https://ethereum.org/token)