以太坊代币智能合约示例

学习以太坊智能合约开发的最佳方式是结合具体的应用场景，如投票、众筹、ERC20或ERC721代币发行等，通过实例的实现，边学边练。 在本教程中如何查看以太坊的智能合约，我们将使用以太坊solidity实现一个遵循以太坊ERC20代币规范的智能合约，并给出最终solidity实现的全部代码。

如果你想马上开始学习以太坊DApp开发，可以访问汇智网提供的优秀在线互动教程：

ERC20规范

ERC20规定了一个token合约需要实现的接口，具体见ERC20

// 接口标准
  contract ERC20 {
      function totalSupply() constant returns (uint totalSupply);   // 总发行量
      function balanceOf(address _owner) constant returns (uint balance);
      // 代币分发(注意, 这个只有合约的Creator 可以调用)
      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);
      // Token信息
      string public constant name = "4FunCoin";
      string public constant symbol = "4FC";
      uint8 public constant decimals = 18;  // token的精度, 大部分都是18
}

以上代码是标准的ERC20标准代码。 规范给出了框架。 我们只需要实现相应的功能即可。 下面是功能说明。

接口功能说明

函数的形式参数是局部有效的，所以在前面加了下划线，以区别于其他变量。 比如_owner。

事件功能说明

这里的两个事件是重点。 前端js代码可以捕获事件并进行相应处理：

ERC20代币合约实施

理解了上面的功能后，下面的代码实现了Token合约的功能填充

pragma solidity ^0.4.16;
interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) public; }  // token的 接受者 这里声明接口, 将会在我们的ABI里
contract TokenERC20 {
/*********Token的属性说明************/
    string public name = 4FunCoin;
    string public symbol = 4FC;
    uint8 public decimals = 18;  // 18 是建议的默认值
    uint256 public totalSupply; // 发行量
    // 建立映射 地址对应了 uint' 便是他的余额
    mapping (address => uint256) public balanceOf;   
    // 地址对应余额
    mapping (address => mapping (address => uint256)) public allowance;
     // 事件，用来通知客户端Token交易发生
    event Transfer(address indexed from, address indexed to, uint256 value);
     // 事件，用来通知客户端代币被消耗(这里就不是转移, 是token用了就没了)
    event Burn(address indexed from, uint256 value);
    // 这里是构造函数, 实例创建时候执行
    function TokenERC20(uint256 initialSupply, string tokenName, string tokenSymbol) public {
        totalSupply = initialSupply * 10 ** uint256(decimals);  // 这里确定了总发行量
        balanceOf[msg.sender] = totalSupply;    // 这里就比较重要, 这里相当于实现了, 把token 全部给合约的Creator
        name = tokenName;
        symbol = tokenSymbol;
    }
    // token的发送函数
    function _transfer(address _from, address _to, uint _value) internal {
        require(_to != 0x0);    // 不是零地址
        require(balanceOf[_from] >= _value);        // 有足够的余额来发送
        require(balanceOf[_to] + _value > balanceOf[_to]);  // 这里也有意思, 不能发送负数的值(hhhh)
        uint previousBalances = balanceOf[_from] + balanceOf[_to];  // 这个是为了校验, 避免过程出错, 总量不变对吧?
        balanceOf[_from] -= _value; //发钱 不多说
        balanceOf[_to] += _value;
        Transfer(_from, _to, _value);   // 这里触发了转账的事件 , 见上event
        assert(balanceOf[_from] + balanceOf[_to] == previousBalances);  // 判断总额是否一致, 避免过程出错
    }
    function transfer(address _to, uint256 _value) public {
        _transfer(msg.sender, _to, _value); // 这里已经储存了 合约创建者的信息, 这个函数是只能被合约创建者使用
    }
    function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
        require(_value <= allowance[_from][msg.sender]);     // 这句很重要, 地址对应的合约地址(也就是token余额)
        allowance[_from][msg.sender] -= _value;
        _transfer(_from, _to, _value);
        return true;
    }
    function approve(address _spender, uint256 _value) public
        returns (bool success) {
        allowance[msg.sender][_spender] = _value;   // 这里是可花费总量
        return true;
    }
    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;
        }
    }
    // 正如其名, 这个是烧币(SB)的.. ,用于把创建者的 token 烧掉
    function burn(uint256 _value) public returns (bool success) {
        require(balanceOf[msg.sender] >= _value);   // 必须要有这么多
        balanceOf[msg.sender] -= _value;
        totalSupply -= _value;
        Burn(msg.sender, _value);
        return true;
    }
    // 这个是用户销毁token.....
    function burnFrom(address _from, uint256 _value) public returns (bool success) {
        require(balanceOf[_from] >= _value);        // 一样要有这么多
        require(_value <= allowance[_from][msg.sender]);    // 
        balanceOf[_from] -= _value;
        allowance[_from][msg.sender] -= _value;
        totalSupply -= _value;
        Burn(_from, _value);
        return true;
    }
}

上面的代码不难读，大部分注释都写好了。 这里有几个要点：

构造器

// 这里是构造函数, 实例创建时候执行
function TokenERC20(uint256 initialSupply, string tokenName, string tokenSymbol) public {
    totalSupply = initialSupply * 10 ** uint256(decimals);  // 这里确定了总发行量
        balanceOf[msg.sender] = totalSupply;    // 这里就比较重要, 这里相当于实现了, 把token 全部给合约的Creator
        name = tokenName;
        symbol = tokenSymbol;
    }

在Solidity中，Contract可以直接理解为一个Class。 和C++一样，也有构造函数，它们的功能几乎一样。 它在创建合约时执行一次。 （是的，在合约的整个生命周期中只能执行一次），所以他的作用是实现合约信息的初始化，数据一旦写入区块数据如何查看以太坊的智能合约，将无法更改（永恒的）。

构造函数不能有返回值（不能接受），但是可以带参数，比如这里的代码，把流通量、代币名称和代币符号作为参数。 合约初始化的时候，我们可以自己定义。

在函数体中可以看到，我们为货币、名称和符号的总量赋值，让这些值永久记录在我们合约的区块数据中

映射

    // 建立映射 地址对应了 uint' 便是他的余额
    mapping (address => uint256) public balanceOf;   
    // 地址对应余额
    mapping (address => mapping (address => uint256)) public allowance;

这种形式乍一看不是那么容易理解。 其实也是慢慢明白的。 这里的映射，通俗的说，就相当于我们的字典，是一个键值对。 上面的代码还创建了地址到uint类型的映射关系。

balanceOf[msg.sender] = 10000;  //msg.sender 是一个地址

这种简单的方法相当于给账户分配了余额；