以太坊：编写ERC20代币

1.ERC20的标准

contract ERC20 {
      function name() constant returns (string name)
      function symbol() constant returns (string symbol)
      function decimals() constant returns (uint8 decimals)
      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);
}

name：返回ERC20代币的名字，例如”My test token”。

symbol：返回代币的简称，例如：MTT，这个也是我们一般在代币交易所看到的名字。

decimals：返回token使用的小数点后几位。比如如果设置为3，就是支持0.001表示。

totalSupply：返回token的总供应量。

balanceOf：返回某个地址(账户)的账户余额。

transfer：从代币合约的调用者地址上转移_value的数量token到的地址_to，并且必须触发Transfer事件。

transferFrom：从地址_from发送数量为_value的token到地址_to,必须触发Transfer事件。

　　　　transferFrom方法用于允许合同代理某人转移token。条件是from账户必须经过了approve。这个后面会举例说明。

approve：允许_spender多次取回您的帐户，最高达_value金额。 如果再次调用此函数，它将以_value覆盖当前的余量。

allowance：返回_spender仍然被允许从_owner提取的金额。

后面三个方法不好理解，这里还需要补充说明一下：

approve是授权第三方（比如某个服务合约）从发送者账户转移代币，然后通过 transferFrom() 函数来执行具体的转移操作。

账户A有1000个ETH，想允许B账户随意调用他的100个ETH，过程如下：

• A账户按照以下形式调用approve函数approve(B,100)
• B账户想用这100个ETH中的10个ETH给C账户，调用transferFrom(A, C, 10)
• 调用allowance(A, B)可以查看B账户还能够调用A账户多少个token

2.编写代币合约

我这里的编译器版本用的是：0.5.17

pragma solidity >=0.4.16;

contract Token{
    uint256 public totalSupply;
    string public name;
    uint8 public decimals;
    string public symbol;

    function balanceOf(address _owner) public view returns (uint256 balance);
    function transfer(address _to, uint256 _value) public returns (bool success);
    function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
    function approve(address _spender, uint256 _value) public returns (bool success);
    function allowance(address _owner, address _spender) public view returns (uint256 remaining);

    event Transfer(address indexed _from, address indexed _to, uint256 _value);
    event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}

contract TokenERC20 is Token {
    
    constructor(uint256 _initialAmount, string memory _tokenName, uint8 _decimalUnits, string memory _tokenSymbol) public {
        totalSupply = _initialAmount * 10 ** uint256(_decimalUnits);
        balances[msg.sender] = totalSupply;
        
        name = _tokenName;                   
        decimals = _decimalUnits;          
        symbol = _tokenSymbol;
    }
    
    function transfer(address _to, uint256 _value) public returns (bool success) {
        require(balances[msg.sender] >= _value && balances[_to] + _value > balances[_to]);
        require(_to != address(0));
        balances[msg.sender] -= _value;
        balances[_to] += _value;
        emit Transfer(msg.sender, _to, _value);
        
        return true;
    }


    function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
        require(balances[_from] >= _value && allowed[_from][msg.sender] >= _value);
        balances[_to] += _value;
        balances[_from] -= _value;
        allowed[_from][msg.sender] -= _value;
        emit Transfer(_from, _to, _value);
        
        return true;
    }
    
    function balanceOf(address _owner) public view returns (uint256 balance) {
        return balances[_owner];
    }


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

    function allowance(address _owner, address _spender) public view returns (uint256 remaining) {
        return allowed[_owner][_spender];
    }
    
    mapping (address => uint256) balances;
    mapping (address => mapping (address => uint256)) allowed;
}

3.使用Remix部署合约

前提：使用MetaMask连接私链。

编译合约

 部署合约

 环境哪儿选择第二个，会连接到MetaMask

合约哪儿需要选择第二个，在参数哪儿输入构造信息，点击transact

 点击确认，确认部署合约。

 部署完成之后，即可看到这个。点击右上角，复制合约的地址。回到MetaMask。

4.钱包导入

 将复制的地址复制进地址，点击下一步，即可看到代币了。