BancorChanger

{
  "language": "Solidity",
  "sources": {
    "BancorChanger.sol": {
      "content": "pragma solidity ^0.4.11;\r\n\r\n/*\r\n    Overflow protected math functions\r\n*/\r\ncontract SafeMath {\r\n    /**\r\n        constructor\r\n    */\r\n    function SafeMath() {\r\n    }\r\n\r\n    /**\r\n        @dev returns the sum of _x and _y, asserts if the calculation overflows\r\n\r\n        @param _x   value 1\r\n        @param _y   value 2\r\n\r\n        @return sum\r\n    */\r\n    function safeAdd(uint256 _x, uint256 _y) internal returns (uint256) {\r\n        uint256 z = _x + _y;\r\n        assert(z >= _x);\r\n        return z;\r\n    }\r\n\r\n    /**\r\n        @dev returns the difference of _x minus _y, asserts if the subtraction results in a negative number\r\n\r\n        @param _x   minuend\r\n        @param _y   subtrahend\r\n\r\n        @return difference\r\n    */\r\n    function safeSub(uint256 _x, uint256 _y) internal returns (uint256) {\r\n        assert(_x >= _y);\r\n        return _x - _y;\r\n    }\r\n\r\n    /**\r\n        @dev returns the product of multiplying _x by _y, asserts if the calculation overflows\r\n\r\n        @param _x   factor 1\r\n        @param _y   factor 2\r\n\r\n        @return product\r\n    */\r\n    function safeMul(uint256 _x, uint256 _y) internal returns (uint256) {\r\n        uint256 z = _x * _y;\r\n        assert(_x == 0 || z / _x == _y);\r\n        return z;\r\n    }\r\n}\r\n\r\n/*\r\n    Owned contract interface\r\n*/\r\ncontract IOwned {\r\n    // this function isn't abstract since the compiler emits automatically generated getter functions as external\r\n    function owner() public constant returns (address owner) { owner; }\r\n\r\n    function transferOwnership(address _newOwner) public;\r\n    function acceptOwnership() public;\r\n}\r\n\r\n/*\r\n    Provides support and utilities for contract ownership\r\n*/\r\ncontract Owned is IOwned {\r\n    address public owner;\r\n    address public newOwner;\r\n\r\n    event OwnerUpdate(address _prevOwner, address _newOwner);\r\n\r\n    /**\r\n        @dev constructor\r\n    */\r\n    function Owned() {\r\n        owner = msg.sender;\r\n    }\r\n\r\n    // allows execution by the owner only\r\n    modifier ownerOnly {\r\n        assert(msg.sender == owner);\r\n        _;\r\n    }\r\n\r\n    /**\r\n        @dev allows transferring the contract ownership\r\n        the new owner still need to accept the transfer\r\n        can only be called by the contract owner\r\n\r\n        @param _newOwner    new contract owner\r\n    */\r\n    function transferOwnership(address _newOwner) public ownerOnly {\r\n        require(_newOwner != owner);\r\n        newOwner = _newOwner;\r\n    }\r\n\r\n    /**\r\n        @dev used by a new owner to accept an ownership transfer\r\n    */\r\n    function acceptOwnership() public {\r\n        require(msg.sender == newOwner);\r\n        OwnerUpdate(owner, newOwner);\r\n        owner = newOwner;\r\n        newOwner = 0x0;\r\n    }\r\n}\r\n\r\n/*\r\n    ERC20 Standard Token interface\r\n*/\r\ncontract IERC20Token {\r\n    // these functions aren't abstract since the compiler emits automatically generated getter functions as external\r\n    function name() public constant returns (string name) { name; }\r\n    function symbol() public constant returns (string symbol) { symbol; }\r\n    function decimals() public constant returns (uint8 decimals) { decimals; }\r\n    function totalSupply() public constant returns (uint256 totalSupply) { totalSupply; }\r\n    function balanceOf(address _owner) public constant returns (uint256 balance) { _owner; balance; }\r\n    function allowance(address _owner, address _spender) public constant returns (uint256 remaining) { _owner; _spender; remaining; }\r\n\r\n    function transfer(address _to, uint256 _value) public returns (bool success);\r\n    function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);\r\n    function approve(address _spender, uint256 _value) public returns (bool success);\r\n}\r\n\r\n/*\r\n    Token Holder interface\r\n*/\r\ncontract ITokenHolder is IOwned {\r\n    function withdrawTokens(IERC20Token _token, address _to, uint256 _amount) public;\r\n}\r\n\r\n/*\r\n    We consider every contract to be a 'token holder' since it's currently not possible\r\n    for a contract to deny receiving tokens.\r\n\r\n    The TokenHolder's contract sole purpose is to provide a safety mechanism that allows\r\n    the owner to send tokens that were sent to the contract by mistake back to their sender.\r\n*/\r\ncontract TokenHolder is ITokenHolder, Owned {\r\n    /**\r\n        @dev constructor\r\n    */\r\n    function TokenHolder() {\r\n    }\r\n\r\n    // validates an address - currently only checks that it isn't null\r\n    modifier validAddress(address _address) {\r\n        require(_address != 0x0);\r\n        _;\r\n    }\r\n\r\n    // verifies that the address is different than this contract address\r\n    modifier notThis(address _address) {\r\n        require(_address != address(this));\r\n        _;\r\n    }\r\n\r\n    /**\r\n        @dev withdraws tokens held by the contract and sends them to an account\r\n        can only be called by the owner\r\n\r\n        @param _token   ERC20 token contract address\r\n        @param _to      account to receive the new amount\r\n        @param _amount  amount to withdraw\r\n    */\r\n    function withdrawTokens(IERC20Token _token, address _to, uint256 _amount)\r\n        public\r\n        ownerOnly\r\n        validAddress(_token)\r\n        validAddress(_to)\r\n        notThis(_to)\r\n    {\r\n        assert(_token.transfer(_to, _amount));\r\n    }\r\n}\r\n\r\n/*\r\n    Smart Token interface\r\n*/\r\ncontract ISmartToken is ITokenHolder, IERC20Token {\r\n    function disableTransfers(bool _disable) public;\r\n    function issue(address _to, uint256 _amount) public;\r\n    function destroy(address _from, uint256 _amount) public;\r\n}\r\n\r\n/*\r\n    The smart token controller is an upgradable part of the smart token that allows\r\n    more functionality as well as fixes for bugs/exploits.\r\n    Once it accepts ownership of the token, it becomes the token's sole controller\r\n    that can execute any of its functions.\r\n\r\n    To upgrade the controller, ownership must be transferred to a new controller, along with\r\n    any relevant data.\r\n\r\n    The smart token must be set on construction and cannot be changed afterwards.\r\n    Wrappers are provided (as opposed to a single 'execute' function) for each of the token's functions, for easier access.\r\n\r\n    Note that the controller can transfer token ownership to a new controller that\r\n    doesn't allow executing any function on the token, for a trustless solution.\r\n    Doing that will also remove the owner's ability to upgrade the controller.\r\n*/\r\ncontract SmartTokenController is TokenHolder {\r\n    ISmartToken public token;   // smart token\r\n\r\n    /**\r\n        @dev constructor\r\n    */\r\n    function SmartTokenController(ISmartToken _token)\r\n        validAddress(_token)\r\n    {\r\n        token = _token;\r\n    }\r\n\r\n    // ensures that the controller is the token's owner\r\n    modifier active() {\r\n        assert(token.owner() == address(this));\r\n        _;\r\n    }\r\n\r\n    // ensures that the controller is not the token's owner\r\n    modifier inactive() {\r\n        assert(token.owner() != address(this));\r\n        _;\r\n    }\r\n\r\n    /**\r\n        @dev allows transferring the token ownership\r\n        the new owner still need to accept the transfer\r\n        can only be called by the contract owner\r\n\r\n        @param _newOwner    new token owner\r\n    */\r\n    function transferTokenOwnership(address _newOwner) public ownerOnly {\r\n        token.transferOwnership(_newOwner);\r\n    }\r\n\r\n    /**\r\n        @dev used by a new owner to accept a token ownership transfer\r\n        can only be called by the contract owner\r\n    */\r\n    function acceptTokenOwnership() public ownerOnly {\r\n        token.acceptOwnership();\r\n    }\r\n\r\n    /**\r\n        @dev disables/enables token transfers\r\n        can only be called by the contract owner\r\n\r\n        @param _disable    true to disable transfers, false to enable them\r\n    */\r\n    function disableTokenTransfers(bool _disable) public ownerOnly {\r\n        token.disableTransfers(_disable);\r\n    }\r\n\r\n    /**\r\n        @dev allows the owner to execute the token's issue function\r\n\r\n        @param _to         account to receive the new amount\r\n        @param _amount     amount to increase the supply by\r\n    */\r\n    function issueTokens(address _to, uint256 _amount) public ownerOnly {\r\n        token.issue(_to, _amount);\r\n    }\r\n\r\n    /**\r\n        @dev allows the owner to execute the token's destroy function\r\n\r\n        @param _from       account to remove the amount from\r\n        @param _amount     amount to decrease the supply by\r\n    */\r\n    function destroyTokens(address _from, uint256 _amount) public ownerOnly {\r\n        token.destroy(_from, _amount);\r\n    }\r\n\r\n    /**\r\n        @dev withdraws tokens held by the token and sends them to an account\r\n        can only be called by the owner\r\n\r\n        @param _token   ERC20 token contract address\r\n        @param _to      account to receive the new amount\r\n        @param _amount  amount to withdraw\r\n    */\r\n    function withdrawFromToken(IERC20Token _token, address _to, uint256 _amount) public ownerOnly {\r\n        token.withdrawTokens(_token, _to, _amount);\r\n    }\r\n}\r\n\r\n/*\r\n    Bancor Formula interface\r\n*/\r\ncontract IBancorFormula {\r\n    function calculatePurchaseReturn(uint256 _supply, uint256 _reserveBalance, uint16 _reserveRatio, uint256 _depositAmount) public constant returns (uint256);\r\n    function calculateSaleReturn(uint256 _supply, uint256 _reserveBalance, uint16 _reserveRatio, uint256 _sellAmount) public constant returns (uint256);\r\n}\r\n\r\n/*\r\n    EIP228 Token Changer interface\r\n*/\r\ncontract ITokenChanger {\r\n    function changeableTokenCount() public constant returns (uint16 count);\r\n    function changeableToken(uint16 _tokenIndex) public constant returns (address tokenAddress);\r\n    function getReturn(IERC20Token _fromToken, IERC20Token _toToken, uint256 _amount) public constant returns (uint256 amount);\r\n    function change(IERC20Token _fromToken, IERC20Token _toToken, uint256 _amount, uint256 _minReturn) public returns (uint256 amount);\r\n}\r\n\r\n/*\r\n    Open issues:\r\n    - Add miner front-running attack protection. The issue is somewhat mitigated by the use of _minReturn when changing\r\n    - Possibly add getters for reserve fields so that the client won't need to rely on the order in the struct\r\n*/\r\n\r\n/*\r\n    Bancor Changer v0.1\r\n\r\n    The Bancor version of the token changer, allows changing between a smart token and other ERC20 tokens and between different ERC20 tokens and themselves.\r\n\r\n    ERC20 reserve token balance can be virtual, meaning that the calculations are based on the virtual balance instead of relying on\r\n    the actual reserve balance. This is a security mechanism that prevents the need to keep a very large (and valuable) balance in a single contract.\r\n\r\n    The changer is upgradable (just like any SmartTokenController).\r\n\r\n    WARNING: It is NOT RECOMMENDED to use the changer with Smart Tokens that have less than 8 decimal digits\r\n             or with very small numbers because of precision loss\r\n*/\r\ncontract BancorChanger is ITokenChanger, SmartTokenController, SafeMath {\r\n    struct Reserve {\r\n        uint256 virtualBalance;         // virtual balance\r\n        uint8 ratio;                    // constant reserve ratio (CRR), 1-100\r\n        bool isVirtualBalanceEnabled;   // true if virtual balance is enabled, false if not\r\n        bool isPurchaseEnabled;         // is purchase of the smart token enabled with the reserve, can be set by the token owner\r\n        bool isSet;                     // used to tell if the mapping element is defined\r\n    }\r\n\r\n    string public version = '0.1';\r\n    string public changerType = 'bancor';\r\n\r\n    IBancorFormula public formula;                  // bancor calculation formula contract\r\n    address[] public reserveTokens;                 // ERC20 standard token addresses\r\n    mapping (address => Reserve) public reserves;   // reserve token addresses -> reserve data\r\n    uint8 private totalReserveRatio = 0;            // used to prevent increasing the total reserve ratio above 100% efficiently\r\n\r\n    // triggered when a change between two tokens occurs\r\n    event Change(address indexed _fromToken, address indexed _toToken, address indexed _trader, uint256 _amount, uint256 _return);\r\n\r\n    /**\r\n        @dev constructor\r\n\r\n        @param _token      smart token governed by the changer\r\n        @param _formula    address of a bancor formula contract\r\n    */\r\n    function BancorChanger(ISmartToken _token, IBancorFormula _formula, IERC20Token _reserveToken, uint8 _reserveRatio)\r\n        SmartTokenController(_token)\r\n        validAddress(_formula)\r\n    {\r\n        formula = _formula;\r\n\r\n        if (address(_reserveToken) != 0x0)\r\n            addReserve(_reserveToken, _reserveRatio, false);\r\n    }\r\n\r\n    // verifies that an amount is greater than zero\r\n    modifier validAmount(uint256 _amount) {\r\n        require(_amount > 0);\r\n        _;\r\n    }\r\n\r\n    // validates a reserve token address - verifies that the address belongs to one of the reserve tokens\r\n    modifier validReserve(address _address) {\r\n        require(reserves[_address].isSet);\r\n        _;\r\n    }\r\n\r\n    // validates a token address - verifies that the address belongs to one of the changeable tokens\r\n    modifier validToken(address _address) {\r\n        require(_address == address(token) || reserves[_address].isSet);\r\n        _;\r\n    }\r\n\r\n    // validates reserve ratio range\r\n    modifier validReserveRatio(uint8 _ratio) {\r\n        require(_ratio > 0 && _ratio <= 100);\r\n        _;\r\n    }\r\n\r\n    /**\r\n        @dev returns the number of reserve tokens defined\r\n\r\n        @return number of reserve tokens\r\n    */\r\n    function reserveTokenCount() public constant returns (uint16 count) {\r\n        return uint16(reserveTokens.length);\r\n    }\r\n\r\n    /**\r\n        @dev returns the number of changeable tokens supported by the contract\r\n        note that the number of changeable tokens is the number of reserve token, plus 1 (that represents the smart token)\r\n\r\n        @return number of changeable tokens\r\n    */\r\n    function changeableTokenCount() public constant returns (uint16 count) {\r\n        return reserveTokenCount() + 1;\r\n    }\r\n\r\n    /**\r\n        @dev given a changeable token index, returns the changeable token contract address\r\n\r\n        @param _tokenIndex  changeable token index\r\n\r\n        @return number of changeable tokens\r\n    */\r\n    function changeableToken(uint16 _tokenIndex) public constant returns (address tokenAddress) {\r\n        if (_tokenIndex == 0)\r\n            return token;\r\n        return reserveTokens[_tokenIndex - 1];\r\n    }\r\n\r\n    /*\r\n        @dev allows the owner to update the formula contract address\r\n\r\n        @param _formula    address of a bancor formula contract\r\n    */\r\n    function setFormula(IBancorFormula _formula)\r\n        public\r\n        ownerOnly\r\n        validAddress(_formula)\r\n        notThis(_formula)\r\n    {\r\n        require(_formula != formula); // validate input\r\n        formula = _formula;\r\n    }\r\n\r\n    /**\r\n        @dev defines a new reserve for the token\r\n        can only be called by the token owner while the changer is inactive\r\n\r\n        @param _token                  address of the reserve token\r\n        @param _ratio                  constant reserve ratio, 1-100\r\n        @param _enableVirtualBalance   true to enable virtual balance for the reserve, false to disable it\r\n    */\r\n    function addReserve(IERC20Token _token, uint8 _ratio, bool _enableVirtualBalance)\r\n        public\r\n        ownerOnly\r\n        inactive\r\n        validAddress(_token)\r\n        notThis(_token)\r\n        validReserveRatio(_ratio)\r\n    {\r\n        require(_token != address(token) && !reserves[_token].isSet && totalReserveRatio + _ratio <= 100); // validate input\r\n\r\n        reserves[_token].virtualBalance = 0;\r\n        reserves[_token].ratio = _ratio;\r\n        reserves[_token].isVirtualBalanceEnabled = _enableVirtualBalance;\r\n        reserves[_token].isPurchaseEnabled = true;\r\n        reserves[_token].isSet = true;\r\n        reserveTokens.push(_token);\r\n        totalReserveRatio += _ratio;\r\n    }\r\n\r\n    /**\r\n        @dev updates one of the token reserves\r\n        can only be called by the token owner\r\n\r\n        @param _reserveToken           address of the reserve token\r\n        @param _ratio                  constant reserve ratio, 1-100\r\n        @param _enableVirtualBalance   true to enable virtual balance for the reserve, false to disable it\r\n        @param _virtualBalance         new reserve's virtual balance\r\n    */\r\n    function updateReserve(IERC20Token _reserveToken, uint8 _ratio, bool _enableVirtualBalance, uint256 _virtualBalance)\r\n        public\r\n        ownerOnly\r\n        validReserve(_reserveToken)\r\n        validReserveRatio(_ratio)\r\n    {\r\n        Reserve reserve = reserves[_reserveToken];\r\n        require(totalReserveRatio - reserve.ratio + _ratio <= 100); // validate input\r\n\r\n        totalReserveRatio = totalReserveRatio - reserve.ratio + _ratio;\r\n        reserve.ratio = _ratio;\r\n        reserve.isVirtualBalanceEnabled = _enableVirtualBalance;\r\n        reserve.virtualBalance = _virtualBalance;\r\n    }\r\n\r\n    /**\r\n        @dev disables purchasing with the given reserve token in case the reserve token got compromised\r\n        can only be called by the token owner\r\n        note that selling is still enabled regardless of this flag and it cannot be disabled by the token owner\r\n\r\n        @param _reserveToken    reserve token contract address\r\n        @param _disable         true to disable the token, false to re-enable it\r\n    */\r\n    function disableReservePurchases(IERC20Token _reserveToken, bool _disable)\r\n        public\r\n        ownerOnly\r\n        validReserve(_reserveToken)\r\n    {\r\n        reserves[_reserveToken].isPurchaseEnabled = !_disable;\r\n    }\r\n\r\n    /**\r\n        @dev returns the reserve's virtual balance if one is defined, otherwise returns the actual balance\r\n\r\n        @param _reserveToken    reserve token contract address\r\n\r\n        @return reserve balance\r\n    */\r\n    function getReserveBalance(IERC20Token _reserveToken)\r\n        public\r\n        constant\r\n        validReserve(_reserveToken)\r\n        returns (uint256 balance)\r\n    {\r\n        Reserve reserve = reserves[_reserveToken];\r\n        return reserve.isVirtualBalanceEnabled ? reserve.virtualBalance : _reserveToken.balanceOf(this);\r\n    }\r\n\r\n    /**\r\n        @dev returns the expected return for changing a specific amount of _fromToken to _toToken\r\n\r\n        @param _fromToken  ERC20 token to change from\r\n        @param _toToken    ERC20 token to change to\r\n        @param _amount     amount to change, in fromToken\r\n\r\n        @return expected change return amount\r\n    */\r\n    function getReturn(IERC20Token _fromToken, IERC20Token _toToken, uint256 _amount)\r\n        public\r\n        constant\r\n        validToken(_fromToken)\r\n        validToken(_toToken)\r\n        returns (uint256 amount)\r\n    {\r\n        require(_fromToken != _toToken); // validate input\r\n\r\n        // change between the token and one of its reserves\r\n        if (_toToken == token)\r\n            return getPurchaseReturn(_fromToken, _amount);\r\n        else if (_fromToken == token)\r\n            return getSaleReturn(_toToken, _amount);\r\n\r\n        // change between 2 reserves\r\n        uint256 purchaseReturnAmount = getPurchaseReturn(_fromToken, _amount);\r\n        return getSaleReturn(_toToken, purchaseReturnAmount, safeAdd(token.totalSupply(), purchaseReturnAmount));\r\n    }\r\n\r\n    /**\r\n        @dev returns the expected return for buying the token for a reserve token\r\n\r\n        @param _reserveToken   reserve token contract address\r\n        @param _depositAmount  amount to deposit (in the reserve token)\r\n\r\n        @return expected purchase return amount\r\n    */\r\n    function getPurchaseReturn(IERC20Token _reserveToken, uint256 _depositAmount)\r\n        public\r\n        constant\r\n        active\r\n        validReserve(_reserveToken)\r\n        returns (uint256 amount)\r\n    {\r\n        Reserve reserve = reserves[_reserveToken];\r\n        require(reserve.isPurchaseEnabled); // validate input\r\n\r\n        uint256 tokenSupply = token.totalSupply();\r\n        uint256 reserveBalance = getReserveBalance(_reserveToken);\r\n        return formula.calculatePurchaseReturn(tokenSupply, reserveBalance, reserve.ratio, _depositAmount);\r\n    }\r\n\r\n    /**\r\n        @dev returns the expected return for selling the token for one of its reserve tokens\r\n\r\n        @param _reserveToken   reserve token contract address\r\n        @param _sellAmount     amount to sell (in the smart token)\r\n\r\n        @return expected sale return amount\r\n    */\r\n    function getSaleReturn(IERC20Token _reserveToken, uint256 _sellAmount) public constant returns (uint256 amount) {\r\n        return getSaleReturn(_reserveToken, _sellAmount, token.totalSupply());\r\n    }\r\n\r\n    /**\r\n        @dev changes a specific amount of _fromToken to _toToken\r\n\r\n        @param _fromToken  ERC20 token to change from\r\n        @param _toToken    ERC20 token to change to\r\n        @param _amount     amount to change, in fromToken\r\n        @param _minReturn  if the change results in an amount smaller than the minimum return - it is cancelled, must be nonzero\r\n\r\n        @return change return amount\r\n    */\r\n    function change(IERC20Token _fromToken, IERC20Token _toToken, uint256 _amount, uint256 _minReturn)\r\n        public\r\n        validToken(_fromToken)\r\n        validToken(_toToken)\r\n        returns (uint256 amount)\r\n    {\r\n        require(_fromToken != _toToken); // validate input\r\n\r\n        // change between the token and one of its reserves\r\n        if (_toToken == token)\r\n            return buy(_fromToken, _amount, _minReturn);\r\n        else if (_fromToken == token)\r\n            return sell(_toToken, _amount, _minReturn);\r\n\r\n        // change between 2 reserves\r\n        uint256 purchaseAmount = buy(_fromToken, _amount, 1);\r\n        return sell(_toToken, purchaseAmount, _minReturn);\r\n    }\r\n\r\n    /**\r\n        @dev buys the token by depositing one of its reserve tokens\r\n\r\n        @param _reserveToken   reserve token contract address\r\n        @param _depositAmount  amount to deposit (in the reserve token)\r\n        @param _minReturn      if the change results in an amount smaller than the minimum return - it is cancelled, must be nonzero\r\n\r\n        @return buy return amount\r\n    */\r\n    function buy(IERC20Token _reserveToken, uint256 _depositAmount, uint256 _minReturn)\r\n        public\r\n        validAmount(_minReturn)\r\n        returns (uint256 amount) {\r\n        amount = getPurchaseReturn(_reserveToken, _depositAmount);\r\n        assert(amount != 0 && amount >= _minReturn); // ensure the trade gives something in return and meets the minimum requested amount\r\n\r\n        // update virtual balance if relevant\r\n        Reserve reserve = reserves[_reserveToken];\r\n        if (reserve.isVirtualBalanceEnabled)\r\n            reserve.virtualBalance = safeAdd(reserve.virtualBalance, _depositAmount);\r\n\r\n        assert(_reserveToken.transferFrom(msg.sender, this, _depositAmount)); // transfer _depositAmount funds from the caller in the reserve token\r\n        token.issue(msg.sender, amount); // issue new funds to the caller in the smart token\r\n\r\n        Change(_reserveToken, token, msg.sender, _depositAmount, amount);\r\n        return amount;\r\n    }\r\n\r\n    /**\r\n        @dev sells the token by withdrawing from one of its reserve tokens\r\n\r\n        @param _reserveToken   reserve token contract address\r\n        @param _sellAmount     amount to sell (in the smart token)\r\n        @param _minReturn      if the change results in an amount smaller the minimum return - it is cancelled, must be nonzero\r\n\r\n        @return sell return amount\r\n    */\r\n    function sell(IERC20Token _reserveToken, uint256 _sellAmount, uint256 _minReturn)\r\n        public\r\n        validAmount(_minReturn)\r\n        returns (uint256 amount) {\r\n        require(_sellAmount <= token.balanceOf(msg.sender)); // validate input\r\n\r\n        amount = getSaleReturn(_reserveToken, _sellAmount);\r\n        assert(amount != 0 && amount >= _minReturn); // ensure the trade gives something in return and meets the minimum requested amount\r\n\r\n        uint256 reserveBalance = getReserveBalance(_reserveToken);\r\n        assert(amount <= reserveBalance); // ensure that the trade won't result in negative reserve\r\n\r\n        uint256 tokenSupply = token.totalSupply();\r\n        assert(amount < reserveBalance || _sellAmount == tokenSupply); // ensure that the trade will only deplete the reserve if the total supply is depleted as well\r\n\r\n        // update virtual balance if relevant\r\n        Reserve reserve = reserves[_reserveToken];\r\n        if (reserve.isVirtualBalanceEnabled)\r\n            reserve.virtualBalance = safeSub(reserve.virtualBalance, amount);\r\n\r\n        token.destroy(msg.sender, _sellAmount); // destroy _sellAmount from the caller's balance in the smart token\r\n        assert(_reserveToken.transfer(msg.sender, amount)); // transfer funds to the caller in the reserve token\r\n                                                            // note that it might fail if the actual reserve balance is smaller than the virtual balance\r\n        Change(token, _reserveToken, msg.sender, _sellAmount, amount);\r\n        return amount;\r\n    }\r\n\r\n    /**\r\n        @dev utility, returns the expected return for selling the token for one of its reserve tokens, given a total supply override\r\n\r\n        @param _reserveToken   reserve token contract address\r\n        @param _sellAmount     amount to sell (in the smart token)\r\n        @param _totalSupply    total token supply, overrides the actual token total supply when calculating the return\r\n\r\n        @return sale return amount\r\n    */\r\n    function getSaleReturn(IERC20Token _reserveToken, uint256 _sellAmount, uint256 _totalSupply)\r\n        private\r\n        constant\r\n        active\r\n        validReserve(_reserveToken)\r\n        validAmount(_totalSupply)\r\n        returns (uint256 amount)\r\n    {\r\n        Reserve reserve = reserves[_reserveToken];\r\n        uint256 reserveBalance = getReserveBalance(_reserveToken);\r\n        return formula.calculateSaleReturn(_totalSupply, reserveBalance, reserve.ratio, _sellAmount);\r\n    }\r\n}"
    }
  },
  "settings": {
    "compilationTarget": {
      "BancorChanger.sol": "BancorChanger"
    },
    "libraries": {},
    "optimizer": {
      "enabled": true,
      "runs": 200
    },
    "remappings": []
  }
}