bancor去中心化交易所解析（3）Bancor交易所上币及合约

2018-09-12 本文已影响0人 gamefu_dl

介绍

接下来，我会分析在Bancor交易所上币的过程和带来的影响，以及相关的合约解析

上币流程

在Bancor交易所上币需要手动提交申请，提交申请后，需要质押一定数量的BNT和自己的代币，来锚定价格（同时通过广大人民群众的上币热情，来增加BNT的需求，来提高BNT的价格）。然后交易所就会为你创建连接BNT和你自己代币的中继代币，同时会在合约上注册你的代币。完成这一切后就可以在交易所交易你的币了

合约解析

合约地址

SmartToken

SmartToken就是智能代币合约

contract SmartToken is ISmartToken, Owned, ERC20Token, TokenHolder {
}

从声明可以看出，SmartToken本质上也是ERC20Token，只不过多实现了几个方法


    function issue(address _to, uint256 _amount)
        public
        ownerOnly
        validAddress(_to)
        notThis(_to)
    {
        totalSupply = safeAdd(totalSupply, _amount);
        balanceOf[_to] = safeAdd(balanceOf[_to], _amount);

        emit Issuance(_amount);
        emit Transfer(this, _to, _amount);
    }

    function destroy(address _from, uint256 _amount) public {
        require(msg.sender == _from || msg.sender == owner); // validate input

        balanceOf[_from] = safeSub(balanceOf[_from], _amount);
        totalSupply = safeSub(totalSupply, _amount);

        emit Transfer(_from, this, _amount);
        emit Destruction(_amount);
    }

从代码可以看出,issue方法可以增加总供应量，相当于创建智能代币, destroy可以减少总供应量，相当于可以销毁智能代币

BancorConverter

BancorConverter 是Bancor合约中非常重要的一个合约，这个合约的作用是用来兑换（基于某一种智能代币）,可以用某一种连接器代币购买某一种中继代币，也可以用中继代币来买某一种代币,还有就是实现基于这个智能代币的两种代币的转换。

根据之前说的流程，把智能代币创建好后，就需要在BancorConverter这个合约中创建两个连接器，一个连接至新代币，另一个连接到BNT

首先来看Connector在合约中的定义


struct Connector {
        uint256 virtualBalance;         // connector virtual balance
        uint32 weight;                  // connector weight, represented in ppm, 1-1000000 ppm = 百万分之一
        bool isVirtualBalanceEnabled;   // true if virtual balance is enabled, false if not
        bool isPurchaseEnabled;         // is purchase of the smart token enabled with the connector, can be set by the owner
        bool isSet;                     // used to tell if the mapping element is defined
    }
 mapping (address => Connector) public connectors;

首先Connetor是一个结构体，里面存储这对某个代币的必要信息，还有一个map，用来根据地址找到Connetor

这里需要注意的重点是这个virtualBalance，根据之前我们队协议的了解，我们可以知道，要计算价格，是必须要知道连接器代币储备量的，而且，这个储备量还要能动态调整。这个virtualBalance就是用来记外面的代币的储备量，交易的时候，储备量的变化，就会提现在这个值里。如果不设置virtualBalance，那么储备量会去直接读当前合约地址的balance

那么现在需要添加Connetor


function addConnector(IERC20Token _token, uint32 _weight, bool _enableVirtualBalance)
        public
        ownerOnly
        inactive
        validAddress(_token)
        notThis(_token)
        validConnectorWeight(_weight)
    {
        // 连接器token不等于smartToken, 连接器token没有被初始化过, 当前cw和加上传进来的cw不超过最大max_cw
        require(_token != token && !connectors[_token].isSet && totalConnectorWeight + _weight <= MAX_WEIGHT); // validate input

        connectors[_token].virtualBalance = 0;
        connectors[_token].weight = _weight;
        connectors[_token].isVirtualBalanceEnabled = _enableVirtualBalance;
        connectors[_token].isPurchaseEnabled = true;
        connectors[_token].isSet = true;
        connectorTokens.push(_token);
        totalConnectorWeight += _weight;
    }

可以看到，默认virtualBalance是0，如果是外部的代币，那么需要更改


function updateConnector(IERC20Token _connectorToken, uint32 _weight, bool _enableVirtualBalance, uint256 _virtualBalance)
        public
        ownerOnly
        validConnector(_connectorToken)
        validConnectorWeight(_weight)
    {
        Connector storage connector = connectors[_connectorToken];
        require(totalConnectorWeight - connector.weight + _weight <= MAX_WEIGHT); // validate input

        totalConnectorWeight = totalConnectorWeight - connector.weight + _weight;
        connector.weight = _weight;
        connector.isVirtualBalanceEnabled = _enableVirtualBalance;
        connector.virtualBalance = _virtualBalance;
    }

获取连接器余额

 function getConnectorBalance(IERC20Token _connectorToken)
        public
        view
        validConnector(_connectorToken)
        returns (uint256)
    {
        Connector storage connector = connectors[_connectorToken];
        // 如果设置了虚拟余额，则取虚拟余额，如果没有，就直接从合约地址取余额
        return connector.isVirtualBalanceEnabled ? connector.virtualBalance : _connectorToken.balanceOf(this);
    }

现在看看转化过程virtualBalance的变化

function convertInternal(IERC20Token _fromToken, IERC20Token _toToken, uint256 _amount, uint256 _minReturn)
        public
        bancorNetworkOnly
        conversionsAllowed
        greaterThanZero(_minReturn)
        returns (uint256)
    {
      
        ...
      // update the source token virtual balance if relevant
        Connector storage fromConnector = connectors[_fromToken];
        if (fromConnector.isVirtualBalanceEnabled)
            fromConnector.virtualBalance = safeAdd(fromConnector.virtualBalance, _amount);
        // update the target token virtual balance if relevant
        Connector storage toConnector = connectors[_toToken];
        if (toConnector.isVirtualBalanceEnabled)
            toConnector.virtualBalance = safeSub(toConnector.virtualBalance, amount);
     ...
    }