Done refactoring

contracts/connectors/1inch.sol

@@ -95,7 +95,7 @@ contract OneHelpers is Stores, DSMath {
     }
 
     function getReferralAddr() internal pure returns (address) {
-        return 0xa7615CD307F323172331865181DC8b80a2834324;
+        return 0xa7615CD307F323172331865181DC8b80a2834324;  // TODO - change address
     }
 
     function convert18ToDec(uint _dec, uint256 _amt) internal pure returns (uint256 amt) {
@@ -152,7 +152,7 @@ contract OneHelpers is Stores, DSMath {
             uint feeCollectorAmt = wmul(feeAmount, 3 * 10 ** 17);
             uint restAmt = sub(feeAmount, feeCollectorAmt);
             _transfer(payable(feeCollector), IERC20(token), feeCollectorAmt);
-            _transfer(payable(getReferralAddr()), IERC20(token), restAmt); // TODO - change address
+            _transfer(payable(getReferralAddr()), IERC20(token), restAmt);
         } else {
             leftAmt = amount;
         }
@@ -171,16 +171,23 @@ contract Resolver is OneHelpers {
         isOk = sig == getOneInchSig();
     }
 
-    function oneProtoSwap(
+    struct OneProtoData {
-        OneProtoInterface oneSplitContract,
+        TokenInterface sellToken;
-        TokenInterface _sellAddr,
+        TokenInterface buyToken;
-        TokenInterface _buyAddr,
+        uint _sellAmt;
-        uint _sellAmt,
+        uint _buyAmt;
-        uint unitAmt,
+        uint unitAmt;
-        uint[] memory distribution,
+        address feeCollector;
-        uint disableDexes
+        uint256 feeAmount;
-    ) internal returns (uint buyAmt){
+        uint[] distribution;
-        uint _slippageAmt = getSlippageAmt(_buyAddr, _sellAddr, _sellAmt, unitAmt);
+        uint disableDexes;
+    }
+    function oneProtoSwap(OneProtoInterface oneSplitContract, OneProtoData memory oneProtoData) internal returns (uint buyAmt){
+        TokenInterface _sellAddr = oneProtoData.sellToken;
+        TokenInterface _buyAddr = oneProtoData.buyToken;
+        uint _sellAmt = oneProtoData._sellAmt;
+
+        uint _slippageAmt = getSlippageAmt(_buyAddr, _sellAddr, _sellAmt, oneProtoData.unitAmt);
 
         uint ethAmt;
         if (address(_sellAddr) == getEthAddr()) {
@@ -196,8 +203,8 @@ contract Resolver is OneHelpers {
             _buyAddr,
             _sellAmt,
             _slippageAmt,
-            distribution,
+            oneProtoData.distribution,
-            disableDexes,
+            oneProtoData.disableDexes,
             getReferralAddr(),
             0
         );
@@ -208,17 +215,24 @@ contract Resolver is OneHelpers {
         require(_slippageAmt <= buyAmt, "Too much slippage");
     }
 
-    function oneProtoSwapMulti(
+    struct OneProtoMultiData {
-        address[] memory tokens,
+        address[] tokens;
-        TokenInterface _sellAddr,
+        TokenInterface sellToken;
-        TokenInterface _buyAddr,
+        TokenInterface buyToken;
-        uint _sellAmt,
+        uint _sellAmt;
-        uint unitAmt,
+        uint _buyAmt;
-        uint[] memory distribution,
+        uint unitAmt;
-        uint[] memory disableDexes
+        address feeCollector;
-    ) internal returns (uint buyAmt){
+        uint256 feeAmount;
+        uint[] distribution;
+        uint[] disableDexes;
+    }
+    function oneProtoSwapMulti(OneProtoMultiData memory oneProtoData) internal returns (uint buyAmt){
         OneProtoInterface oneSplitContract = OneProtoInterface(getOneProtoAddress());
-        uint _slippageAmt = getSlippageAmt(_buyAddr, _sellAddr, _sellAmt, unitAmt);
+        TokenInterface _sellAddr = oneProtoData.sellToken;
+        TokenInterface _buyAddr = oneProtoData.buyToken;
+        uint _sellAmt = oneProtoData._sellAmt;
+        uint _slippageAmt = getSlippageAmt(_buyAddr, _sellAddr, _sellAmt, oneProtoData.unitAmt);
 
         uint ethAmt;
         if (address(_sellAddr) == getEthAddr()) {
@@ -229,11 +243,11 @@ contract Resolver is OneHelpers {
 
         uint initalBal = getTokenBal(_buyAddr);
         oneSplitContract.swapWithReferralMulti.value(ethAmt)(
-            convertToTokenInterface(tokens),
+            convertToTokenInterface(oneProtoData.tokens),
             _sellAmt,
             _slippageAmt,
-            distribution,
+            oneProtoData.distribution,
-            disableDexes,
+            oneProtoData.disableDexes,
             getReferralAddr(),
             0
         );
@@ -266,6 +280,7 @@ contract Resolver is OneHelpers {
 
         require(_slippageAmt <= buyAmt, "Too much slippage");
     }
+
 }
 
 contract OneProtoEventResolver is Resolver {
@@ -278,22 +293,64 @@ contract OneProtoEventResolver is Resolver {
         uint256 setId
     );
 
-    function emitLogSell(
+    event LogSellFee(
-        address buyToken,
+        address indexed buyToken,
-        address sellToken,
+        address indexed sellToken,
         uint256 buyAmt,
         uint256 sellAmt,
-        address feeCollector,
+        address indexed collector,
-        uint256 feePercent,
+        uint256 fee,
+        uint256 getId,
+        uint256 setId
+    );
+
+    function emitLogSell(
+        OneProtoData memory oneProtoData,
         uint256 getId,
         uint256 setId
     ) internal {
         bytes32 _eventCode;
         bytes memory _eventParam;
-        if (feeCollector == address(0)) {
+        if (oneProtoData.feeCollector == address(0)) {
-            emit LogSell(buyToken, sellToken, buyAmt, sellAmt, getId, setId);
+            emit LogSell(
+                address(oneProtoData.buyToken),
+                address(oneProtoData.sellToken),
+                oneProtoData._buyAmt,
+                oneProtoData._sellAmt,
+                getId,
+                setId
+            );
             _eventCode = keccak256("LogSell(address,address,uint256,uint256,uint256,uint256)");
-            _eventParam = abi.encode(buyToken, sellToken, buyAmt, sellAmt, getId, setId);
+            _eventParam = abi.encode(
+                address(oneProtoData.buyToken),
+                address(oneProtoData.sellToken),
+                oneProtoData._buyAmt,
+                oneProtoData._sellAmt,
+                getId,
+                setId
+            );
+        } else {
+            emit LogSellFee(
+                address(oneProtoData.buyToken),
+                address(oneProtoData.sellToken),
+                oneProtoData._buyAmt,
+                oneProtoData._sellAmt,
+                oneProtoData.feeCollector,
+                oneProtoData.feeAmount,
+                getId,
+                setId
+            );
+            _eventCode = keccak256("LogSellFee(address,address,uint256,uint256,uint256,uint256)");
+            _eventParam = abi.encode(
+                address(oneProtoData.buyToken),
+                address(oneProtoData.sellToken),
+                oneProtoData._buyAmt,
+                oneProtoData._sellAmt,
+                oneProtoData.feeCollector,
+                oneProtoData.feeAmount,
+                getId,
+                setId
+            );
         }
         emitEvent(_eventCode, _eventParam);
     }
@@ -306,23 +363,65 @@ contract OneProtoEventResolver is Resolver {
         uint256 getId,
         uint256 setId
     );
-    
+
-    function emitLogSellTwo(
+     event LogSellFeeTwo(
-        address buyToken,
+        address indexed buyToken,
-        address sellToken,
+        address indexed sellToken,
         uint256 buyAmt,
         uint256 sellAmt,
-        address feeCollector,
+        address indexed collector,
-        uint256 feePercent,
+        uint256 fee,
+        uint256 getId,
+        uint256 setId
+    );
+
+    function emitLogSellTwo(
+        OneProtoData memory oneProtoData,
         uint256 getId,
         uint256 setId
     ) internal {
         bytes32 _eventCode;
         bytes memory _eventParam;
-        if (feeCollector == address(0)) {
+        if (oneProtoData.feeCollector == address(0)) {
-            emit LogSellTwo(buyToken, sellToken, buyAmt, sellAmt, getId, setId);
+            emit LogSellTwo(
+                address(oneProtoData.buyToken),
+                address(oneProtoData.sellToken),
+                oneProtoData._buyAmt,
+                oneProtoData._sellAmt,
+                getId,
+                setId
+            );
             _eventCode = keccak256("LogSellTwo(address,address,uint256,uint256,uint256,uint256)");
-            _eventParam = abi.encode(buyToken, sellToken, buyAmt, sellAmt, getId, setId);
+            _eventParam = abi.encode(
+                address(oneProtoData.buyToken),
+                address(oneProtoData.sellToken),
+                oneProtoData._buyAmt,
+                oneProtoData._sellAmt,
+                getId,
+                setId
+            );
+        } else {
+            emit LogSellFeeTwo(
+                address(oneProtoData.buyToken),
+                address(oneProtoData.sellToken),
+                oneProtoData._buyAmt,
+                oneProtoData._sellAmt,
+                oneProtoData.feeCollector,
+                oneProtoData.feeAmount,
+                getId,
+                setId
+            );
+            _eventCode = keccak256("LogSellFeeTwo(address,address,uint256,uint256,uint256,uint256)");
+            _eventParam = abi.encode(
+                address(oneProtoData.buyToken),
+                address(oneProtoData.sellToken),
+                oneProtoData._buyAmt,
+                oneProtoData._sellAmt,
+                oneProtoData.feeCollector,
+                oneProtoData.feeAmount,
+                getId,
+                setId
+            );
         }
         emitEvent(_eventCode, _eventParam);
     }
@@ -336,32 +435,173 @@ contract OneProtoEventResolver is Resolver {
         uint256 getId,
         uint256 setId
     );
-    
+
-    function emitLogSellMulti(
+     event LogSellFeeMulti(
-        address[] memory tokens,
+        address[] tokens,
+        address indexed buyToken,
+        address indexed sellToken,
         uint256 buyAmt,
         uint256 sellAmt,
-        address feeCollector,
+        address indexed collector,
-        uint256 feePercent,
+        uint256 fee,
+        uint256 getId,
+        uint256 setId
+    );
+
+    function emitLogSellMulti(
+        OneProtoMultiData memory oneProtoData,
         uint256 getId,
         uint256 setId
     ) internal {
-        address buyToken = tokens[tokens.length - 1];
-        address sellToken = tokens[0];
         bytes32 _eventCode;
         bytes memory _eventParam;
-        if (feeCollector == address(0)) {
+        if (oneProtoData.feeCollector == address(0)) {
-            emit LogSellMulti(tokens, buyToken, sellToken, buyAmt, sellAmt, getId, setId);
+            emit LogSellMulti(
+                oneProtoData.tokens,
+                address(oneProtoData.buyToken),
+                address(oneProtoData.sellToken),
+                oneProtoData._buyAmt,
+                oneProtoData._sellAmt,
+                getId,
+                setId
+            );
             _eventCode = keccak256("LogSellMulti(address[],address,address,uint256,uint256,uint256,uint256)");
-            _eventParam = abi.encode(tokens, buyToken, sellToken, buyAmt, sellAmt, getId, setId);
+            _eventParam = abi.encode(
+                oneProtoData.tokens,
+                address(oneProtoData.buyToken),
+                address(oneProtoData.sellToken),
+                oneProtoData._buyAmt,
+                oneProtoData._sellAmt,
+                getId,
+                setId
+            );
+        } else {
+            emit LogSellFeeMulti(
+                oneProtoData.tokens,
+                address(oneProtoData.buyToken),
+                address(oneProtoData.sellToken),
+                oneProtoData._buyAmt,
+                oneProtoData._sellAmt,
+                oneProtoData.feeCollector,
+                oneProtoData.feeAmount,
+                getId,
+                setId
+            );
+            _eventCode = keccak256("LogSellFeeMulti(address[],address,address,uint256,uint256,uint256,uint256)");
+            _eventParam = abi.encode(
+                oneProtoData.tokens,
+                address(oneProtoData.buyToken),
+                address(oneProtoData.sellToken),
+                oneProtoData._buyAmt,
+                oneProtoData._sellAmt,
+                oneProtoData.feeCollector,
+                oneProtoData.feeAmount,
+                getId,
+                setId
+            );
         }
         emitEvent(_eventCode, _eventParam);
     }
 
 }
-contract OneProtoResolver is OneProtoEventResolver {
+contract OneProtoResolverHelpers is OneProtoEventResolver {
+    function _sell(
+        OneProtoData memory oneProtoData,
+        uint256 feePercent,
+        uint256 getId,
+        uint256 setId
+    ) internal {
+        uint _sellAmt = getUint(getId, oneProtoData._sellAmt);
+        
+        oneProtoData._sellAmt = _sellAmt == uint(-1) ?
+            getTokenBal(oneProtoData.sellToken) :
+            _sellAmt;
+
+        OneProtoInterface oneSplitContract = OneProtoInterface(getOneProtoAddress());
+
+        (, oneProtoData.distribution) = oneSplitContract.getExpectedReturn(
+                oneProtoData.sellToken,
+                oneProtoData.buyToken,
+                oneProtoData._sellAmt,
+                5,
+                0
+            );
+
+        oneProtoData._buyAmt = oneProtoSwap(
+            oneSplitContract,
+            oneProtoData
+        );
+
+        (uint feeAmount, uint leftBuyAmt) = takeFee(
+            address(oneProtoData.buyToken),
+            oneProtoData._buyAmt,
+            oneProtoData.feeCollector,
+            feePercent
+        );
+        setUint(setId, leftBuyAmt);
+        oneProtoData.feeAmount = feeAmount;
+
+        emitLogSell(oneProtoData, getId, setId);
+    }
+
+    function _sellTwo(
+        OneProtoData memory oneProtoData,
+        uint256 feePercent,
+        uint getId,
+        uint setId
+    ) internal {
+        uint _sellAmt = getUint(getId, oneProtoData._sellAmt);
+
+        oneProtoData._sellAmt = _sellAmt == uint(-1) ?
+            getTokenBal(oneProtoData.sellToken) :
+            _sellAmt;
+
+        oneProtoData._buyAmt = oneProtoSwap(
+            OneProtoInterface(getOneProtoAddress()),
+            oneProtoData
+        );
+
+        (uint feeAmount, uint leftBuyAmt) = takeFee(
+            address(oneProtoData.buyToken),
+            oneProtoData._buyAmt,
+            oneProtoData.feeCollector,
+            feePercent
+        );
+        setUint(setId, leftBuyAmt);
+        oneProtoData.feeAmount = feeAmount;
+
+        emitLogSellTwo(oneProtoData, getId, setId);
+    }
+
+    function _sellMulti(
+        OneProtoMultiData memory oneProtoData,
+        uint256 feePercent,
+        uint getId,
+        uint setId
+    ) internal {
+        uint _sellAmt = getUint(getId, oneProtoData._sellAmt);
+        
+        oneProtoData._sellAmt = _sellAmt == uint(-1) ?
+            getTokenBal(oneProtoData.sellToken) :
+            _sellAmt;
+
+        oneProtoData._buyAmt = oneProtoSwapMulti(oneProtoData);
+        uint leftBuyAmt;
+        (oneProtoData.feeAmount, leftBuyAmt) = takeFee(
+            address(oneProtoData.buyToken),
+            oneProtoData._buyAmt,
+            oneProtoData.feeCollector,
+            feePercent
+        );
+        setUint(setId, leftBuyAmt);
+
+        emitLogSellMulti(oneProtoData, getId, setId);
+    }
+}
+
+contract OneProtoResolver is OneProtoResolverHelpers {
     /**
-     * @dev Sell ETH/ERC20_Token using 1split.
+     * @dev Sell ETH/ERC20_Token using 1proto.
      * @param buyAddr buying token address.(For ETH: 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE)
      * @param sellAddr selling token amount.(For ETH: 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE)
      * @param sellAmt selling token amount.
@@ -377,40 +617,63 @@ contract OneProtoResolver is OneProtoEventResolver {
         uint getId,
         uint setId
     ) external payable {
-        uint _sellAmt = getUint(getId, sellAmt);
+        OneProtoData memory oneProtoData = OneProtoData({
+            buyToken: TokenInterface(buyAddr),
+            sellToken: TokenInterface(sellAddr),
+            unitAmt: unitAmt,
+            distribution: new uint[](0),
+            feeCollector: address(0),
+            _sellAmt: sellAmt,
+            _buyAmt: 0,
+            disableDexes: 0,
+            feeAmount: 0
+        });
 
-        TokenInterface _buyAddr = TokenInterface(buyAddr);
+        _sell(oneProtoData, 0, getId, setId);
-        TokenInterface _sellAddr = TokenInterface(sellAddr);
 
-        _sellAmt = _sellAmt == uint(-1) ? getTokenBal(_sellAddr) : _sellAmt;
-
-        OneProtoInterface oneSplitContract = OneProtoInterface(getOneProtoAddress());
-
-        (, uint[] memory distribution) = oneSplitContract.getExpectedReturn(
-                _sellAddr,
-                _buyAddr,
-                _sellAmt,
-                5,
-                0
-            );
-
-        uint _buyAmt = oneProtoSwap(
-            oneSplitContract,
-            _sellAddr,
-            _buyAddr,
-            _sellAmt,
-            unitAmt,
-            distribution,
-            0
-        );
-
-        setUint(setId, _buyAmt);
-
-        emitLogSell(address(_buyAddr), address(_sellAddr), _buyAmt, _sellAmt, address(0), 0, getId, setId);
     }
 
     /**
-     * @dev Sell ETH/ERC20_Token using 1split.
+     * @dev Sell ETH/ERC20_Token using 1proto.
+     * @param buyAddr buying token address.(For ETH: 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE)
+     * @param sellAddr selling token amount.(For ETH: 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE)
+     * @param sellAmt selling token amount.
+     * @param unitAmt unit amount of buyAmt/sellAmt with slippage.
+     * @param feeCollector Fee amount to transfer.
+     * @param feePercent Fee percentage on buyAmt.
+     * @param getId Get token amount at this ID from `InstaMemory` Contract.
+     * @param setId Set token amount at this ID in `InstaMemory` Contract.
+    */
+    function sellFee(
+        address buyAddr,
+        address sellAddr,
+        uint sellAmt,
+        uint unitAmt,
+        address feeCollector,
+        uint feePercent,
+        uint getId,
+        uint setId
+    ) external payable {
+        require(feePercent > 0 && feePercent <= 2*10*16, "Fee more than 2%");
+        require(feeCollector != address(0), "feeCollector is not vaild address");
+
+        OneProtoData memory oneProtoData = OneProtoData({
+            buyToken: TokenInterface(buyAddr),
+            sellToken: TokenInterface(sellAddr),
+            unitAmt: unitAmt,
+            distribution: new uint[](0),
+            feeCollector: feeCollector,
+            _sellAmt: sellAmt,
+            _buyAmt: 0,
+            disableDexes: 0,
+            feeAmount: 0
+        });
+
+        _sell(oneProtoData, feePercent, getId, setId);
+    }
+
+    /**
+     * @dev Sell ETH/ERC20_Token using 1proto.
      * @param buyAddr buying token address.(For ETH: 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE)
      * @param sellAddr selling token amount.(For ETH: 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE)
      * @param sellAmt selling token amount.
@@ -430,30 +693,66 @@ contract OneProtoResolver is OneProtoEventResolver {
         uint getId,
         uint setId
     ) external payable {
-        uint _sellAmt = getUint(getId, sellAmt);
+        OneProtoData memory oneProtoData = OneProtoData({
+            buyToken: TokenInterface(buyAddr),
+            sellToken: TokenInterface(sellAddr),
+            unitAmt: unitAmt,
+            distribution: distribution,
+            disableDexes: disableDexes,
+            _sellAmt: sellAmt,
+            feeCollector: address(0),
+            _buyAmt: 0,
+            feeAmount: 0
+        });
 
-        TokenInterface _buyAddr = TokenInterface(buyAddr);
+        _sellTwo(oneProtoData, 0, getId, setId);
-        TokenInterface _sellAddr = TokenInterface(sellAddr);
+    }
 
-        _sellAmt = _sellAmt == uint(-1) ? getTokenBal(_sellAddr) : _sellAmt;
 
-        uint _buyAmt = oneProtoSwap(
+    /**
-            OneProtoInterface(getOneProtoAddress()),
+     * @dev Sell ETH/ERC20_Token using 1proto.
-            _sellAddr,
+     * @param buyAddr buying token address.(For ETH: 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE)
-            _buyAddr,
+     * @param sellAddr selling token amount.(For ETH: 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE)
-            _sellAmt,
+     * @param sellAmt selling token amount.
-            unitAmt,
+     * @param unitAmt unit amount of buyAmt/sellAmt with slippage.
-            distribution,
+     * @param distribution distribution of swap across different dex.
-            disableDexes
+     * @param disableDexes disable a dex. (To disable none: 0)
-        );
+     * @param feeCollector Fee amount to transfer.
+     * @param feePercent Fee percentage on buyAmt.
+     * @param getId Get token amount at this ID from `InstaMemory` Contract.
+     * @param setId Set token amount at this ID in `InstaMemory` Contract.
+    */
+    function sellFeeTwo(
+        address buyAddr,
+        address sellAddr,
+        uint sellAmt,
+        uint unitAmt,
+        uint[] calldata distribution,
+        uint disableDexes,
+        address feeCollector,
+        uint feePercent,
+        uint getId,
+        uint setId
+    ) external payable {
+        require(feePercent > 0 && feePercent <= 2*10*16, "Fee more than 2%");
+        require(feeCollector != address(0), "feeCollector is not vaild address");
+        OneProtoData memory oneProtoData = OneProtoData({
+            buyToken: TokenInterface(buyAddr),
+            sellToken: TokenInterface(sellAddr),
+            unitAmt: unitAmt,
+            distribution: distribution,
+            disableDexes: disableDexes,
+            feeCollector: feeCollector,
+            _sellAmt: sellAmt,
+            _buyAmt: 0,
+            feeAmount: 0
+        });
 
-        setUint(setId, _buyAmt);
+        _sellTwo(oneProtoData, feePercent, getId, setId);
-
-        emitLogSellTwo(address(_buyAddr), address(_sellAddr), _buyAmt, _sellAmt, address(0), 0, getId, setId);
     }
 
     /**
-     * @dev Sell ETH/ERC20_Token using 1split using muliple token.
+     * @dev Sell ETH/ERC20_Token using 1proto using muliple token.
      * @param tokens buying token address.(For ETH: 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE)
      * @param sellAmt selling token amount.
      * @param unitAmt unit amount of buyAmt/sellAmt with slippage.
@@ -471,29 +770,64 @@ contract OneProtoResolver is OneProtoEventResolver {
         uint getId,
         uint setId
     ) external payable {
-        uint _sellAmt = getUint(getId, sellAmt);
+        OneProtoMultiData memory oneProtoData = OneProtoMultiData({
-        require(tokens.length >= 2, "token tokens.lengthgth is less than 2");
+            tokens: tokens,
-        TokenInterface _sellAddr = TokenInterface(address(tokens[0]));
+            buyToken: TokenInterface(address(tokens[tokens.length - 1])),
-        TokenInterface _buyAddr = TokenInterface(address(tokens[tokens.length-1]));
+            sellToken: TokenInterface(address(tokens[0])),
+            unitAmt: unitAmt,
+            distribution: distribution,
+            disableDexes: disableDexes,
+            _sellAmt: sellAmt,
+            feeCollector: address(0),
+            _buyAmt: 0,
+            feeAmount: 0
+        });
 
-        _sellAmt = _sellAmt == uint(-1) ? getTokenBal(_sellAddr) : _sellAmt;
+        _sellMulti(oneProtoData, 0, getId, setId);
+    }
 
-        uint _buyAmt = oneProtoSwapMulti(
+    /**
-            tokens,
+     * @dev Sell ETH/ERC20_Token using 1proto using muliple token.
-            _sellAddr,
+     * @param tokens buying token address.(For ETH: 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE)
-            _buyAddr,
+     * @param sellAmt selling token amount.
-            _sellAmt,
+     * @param unitAmt unit amount of buyAmt/sellAmt with slippage.
-            unitAmt,
+     * @param distribution distribution of swap across different dex.
-            distribution,
+     * @param disableDexes disable a dex. (To disable none: 0)
-            disableDexes
+     * @param feeCollector Fee amount to transfer.
-        );
+     * @param feePercent Fee percentage on buyAmt.
+     * @param getId Get token amount at this ID from `InstaMemory` Contract.
+     * @param setId Set token amount at this ID in `InstaMemory` Contract.
+    */
+    function sellFeeMulti(
+        address[] calldata tokens,
+        uint sellAmt,
+        uint unitAmt,
+        uint[] calldata distribution,
+        uint[] calldata disableDexes,
+        address feeCollector,
+        uint feePercent,
+        uint getId,
+        uint setId
+    ) external payable {
+        require(feePercent > 0 && feePercent <= 2*10*16, "Fee more than 2%");
+        require(feeCollector != address(0), "feeCollector is not vaild address");
+        TokenInterface buyToken = TokenInterface(address(tokens[tokens.length-1]));
+        OneProtoMultiData memory oneProtoData = OneProtoMultiData({
+            tokens: tokens,
+            buyToken: buyToken,
+            sellToken: TokenInterface(address(tokens[0])),
+            unitAmt: unitAmt,
+            distribution: distribution,
+            feeCollector: feeCollector,
+            disableDexes: disableDexes,
+            _sellAmt: sellAmt,
+            _buyAmt: 0,
+            feeAmount: 0
+        });
 
-        setUint(setId, _buyAmt);
+        _sellMulti(oneProtoData, feePercent, getId, setId);
-
-        emitLogSellMulti(tokens, _buyAmt, _sellAmt, address(0), 0, getId, setId);
     }
 }
-
 contract OneInchResolver is OneProtoResolver {
     event LogSellThree(
         address indexed buyToken,
@@ -542,6 +876,85 @@ contract OneInchResolver is OneProtoResolver {
         bytes memory _eventParam = abi.encode(address(_buyAddr), address(_sellAddr), buyAmt, sellAmt, 0, setId);
         emitEvent(_eventCode, _eventParam);
     }
+
+    event LogSellFeeThree(
+        address indexed buyToken,
+        address indexed sellToken,
+        uint256 buyAmt,
+        uint256 sellAmt,
+        address indexed collector,
+        uint256 fee,
+        uint256 getId,
+        uint256 setId
+    );
+
+     /**
+     * @dev Sell ETH/ERC20_Token using 1split.
+     * @param buyAddr buying token address.(For ETH: 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE)
+     * @param sellAddr selling token amount.(For ETH: 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE)
+     * @param sellAmt selling token amount.
+     * @param unitAmt unit amount of buyAmt/sellAmt with slippage.
+     * @param callData Data from 1inch API.
+     * @param setId Set token amount at this ID in `InstaMemory` Contract.
+    */
+    function sellFeeThree(
+        address buyAddr,
+        address sellAddr,
+        uint sellAmt,
+        uint unitAmt,
+        bytes calldata callData,
+        address feeCollector,
+        uint feePercent,
+        uint setId
+    ) external payable {
+        require(feePercent > 0 && feePercent <= 2*10*16, "Fee more than 2%");
+        require(feeCollector != address(0), "feeCollector is not vaild address");
+
+        TokenInterface _buyAddr = TokenInterface(buyAddr);
+        TokenInterface _sellAddr = TokenInterface(sellAddr);
+
+        uint ethAmt;
+        if (address(_sellAddr) == getEthAddr()) {
+            ethAmt = sellAmt;
+        } else {
+            TokenInterface(_sellAddr).approve(getOneInchTokenTaker(), sellAmt);
+        }
+
+        require(checkOneInchSig(callData), "Not-swap-function");
+
+        uint buyAmt = oneInchSwap(_buyAddr, _sellAddr, callData, sellAmt, unitAmt, ethAmt);
+
+        (uint feeAmount, uint leftBuyAmt) = takeFee(
+            address(_buyAddr),
+            buyAmt,
+            feeCollector,
+            feePercent
+        );
+        setUint(setId, leftBuyAmt);
+
+        emit LogSellFeeThree(
+            address(_buyAddr),
+            address(_sellAddr),
+            buyAmt,
+            sellAmt,
+            feeCollector,
+            feeAmount,
+            0,
+            setId
+        );
+        bytes32 _eventCode = keccak256("LogSellThree(address,address,uint256,uint256,uint256,uint256)");
+        bytes memory _eventParam = abi.encode(
+            address(_buyAddr),
+            address(_sellAddr),
+            buyAmt,
+            sellAmt,
+            feeCollector,
+            feeAmount,
+            0,
+            setId
+        );
+        emitEvent(_eventCode, _eventParam);
+    }
 }
 contract ConnectOne is OneInchResolver {
     string public name = "1Inch-1proto-v1";