您当前的位置: 首页  > 区块链网站首页区块链

ERC20 Token 合约代码分析

发布时间:2018-03-05编辑:Adwind查看次数:

    ERC20 Token 合约代码分析

    合约接口代码

    // https://github.com/ethereum/EIPs/issues/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);   // 代币分发(注意, 这个只有合约的Creator 可以调用)
          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
    }123456789101112131415161718192021

    上面的代码是一个标准的ERC20标准的代码, 他给出了框架, 我们只需要实现相应的函数就好了, 这里给出函数说明:

    接口函数

    • 函数的形参是局部有效, 所以前面使用下划线, 与其他的变量区别开来. 如 _owner.

    • totalSupply() 函数返回这个Token的总发行量;

    • balanceOf() 查询某个地址的Token数量 , 结合mapping实现

    • transfer() owner 使用这个进行发送代币

    • transferFrom () token的所有者用来发送token

    • allowance() 控制代币的交易,如可交易账号及资产, 控制Token的流通

    • approve() 允许用户可花费的代币数;

    事件函数

    这里两个Event是重点, 之前没弄懂, 现在倒是明白不少, 就是产生事件, 从而可以被前端代码捕获到, 从对事件使用事件服务函数进行处理 , 这里的参数,也将传递给服务函数

    • event Transfer() Token的转账事件

    • event Approval() 允许事件

    合约实现代码

    理解了上面的函数, 下面的代码,就实现了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;
        }
    }123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990

    上面的代码阅读难度不大, 也写了大多处的注释, 这里吧自己学的几个Point 提一下

    构造函数

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

    在Solidity里面, Contract 我们可以直接理解成一个Class吧. 如C++ 一样, 这里面也存在一个 
    构造函数而且他们的功能也是近乎相同, 在合约创建的时候执行一次.(没错 , 合约整个生命周期里只能执行这样一次) , 所以他的作用就是实现合约信息的初始化, 一旦数据写入区块数据, 将是无法更改的了(永固性).

    构造函数的是不能有返回值的(有也无法接受), 但是可以带参数, 像是此处代码, 把发行量, token的名称和token的 符号作为参数留出. 在合约初始化时候我们便可以自行定义.

    函数体中可见, 我们对货币总量, 名称和 符号进行赋值, 这样,这些值就永远的记录在了我们的合约的区块数据中了

    映射(mapping)

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

    这个形式,乍一眼看上去是没那么好懂. 其实慢慢的 也是理解了, 这里的映射, 通俗的讲,就是相当于我们的字典, 是一个键值对. 上述的代码也是建立了一个 address 到 uint类型的映射关系.

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

    这样简单的方法, 相当于对账户进行余额的赋值;

    事件(event)

    Solidity 是基于事件驱动(前面有说不是消息驱动), 事件也是连接前端的桥梁, 一个事件的触发, 可以被前端所捕获, 从而做出相应的响应.比如MeteMask的支付窗口一样. 点了支付 ,他就弹出来了对吧.

    // 事件,用来通知客户端Token交易发生
    event Transfer(address indexed from, address indexed to, uint256 value);
    
    // 下面是事件监听
    var ClientReceipt = web3.eth.contract(abi); //导入接口说明
    var clientReceipt = ClientReceipt.at(0x123 /* address */);  //合约地址
    // 对事件进行监听, 
    var event = clientReceipt.Deposit(function(error, result) {
        if (!error)
            console.log(result);
    });
    // 对事件进行绑定
         bindEvents: function() {
        $(document).on('click', '.btn-adopt', App.handleAdopt);
      },12345678910111213141516

    EG:

    事件 是合约和区块链通讯的一种机制。你的前端应用“监听”某些事件,并做出反应。

    // in contract
    // 这里建立事件
    event IntegersAdded(uint x, uint y, uint result);
    
    function add(uint _x, uint _y) public {
      uint result = _x + _y;
      //触发事件,通知app
      IntegersAdded(_x, _y, result);
      return result;
    }
    
    //in js
    // 你的 app 前端可以监听这个事件。JavaScript 实现如下:
    
    YourContract.IntegersAdded(function(error, result) { 
      // do something
    }123456789101112131415161718

    接口(interface)

    这个合约的第二行就是, 差点忘了… 这个也是一个相对重要的东西, 合约主要的作用个人理解来说就是实现与其他合约的交互.

    如果我们的合约需要和区块链上的其他的合约交互(比如使用其中的公有函数),则需先定义一个 interface (接口)。

    先举一个简单的例子子。 假设在区块链上有这么一个合约:

    contract LuckyNumber {
      mapping(address => uint) numbers;
    
      function setNum(uint _num) public {
        numbers[msg.sender] = _num;
      }
    
      function getNum(address _myAddress) public view returns (uint) {
        return numbers[_myAddress];
      }
    }123456789101112

    这是个很简单的合约,您可以用它存储自己的幸运号码,并将其与地址关联。 这样其他人就可以通过地址得到号码了。

    现在假设我们有一个外部合约,使用 getNum 函数可读取其中的数据。

    首先,我们定义 LuckyNumber 合约的 interface :

    interface NumberInterface {
      function getNum(address _myAddress) public view returns (uint);
    }1234

    首先,我们只用声明进行交互的函数 —— 在本例中为 getNum.(声明, 函数体是空的)

    然后我们在我们自己的合约中直接对接口进行访问, 就可以getnum 了.

    Ethereum 内部有一个散列函数keccak256,它用了SHA3版本。一个散列函数基本上就是把一个字符串转换为一个256位的16进制数字。字符串的一个微小变化会引起散列数据极大变化。

关键字词:代币、智能合约、ERC20

上一篇: web3.js与合约交互

下一篇: 没有下一篇了