pragma solidity ^0.7.0; pragma experimental ABIEncoderV2; /** * @title 1Inch. * @dev On-chain DEX Aggregator. */ // import files from common directory import { TokenInterface , MemoryInterface } from "../../common/interfaces.sol"; import { Stores } from "../../common/stores.sol"; import { OneInchInterace, OneInchData } from "./interface.sol"; import { Helpers } from "./helpers.sol"; import { Events } from "./events.sol"; abstract contract OneInchResolver is Helpers, Events { /** * @dev 1inch swap uses `.call()`. This function restrict it to call only swap/trade functionality * @param callData - calldata to extract the first 4 bytes for checking function signature */ function checkOneInchSig(bytes memory callData) internal pure returns(bool isOk) { bytes memory _data = callData; bytes4 sig; // solium-disable-next-line security/no-inline-assembly assembly { sig := mload(add(_data, 32)) } isOk = sig == oneInchSig; } /** * @dev 1inch API swap handler * @param oneInchData - contains data returned from 1inch API. Struct defined in interfaces.sol * @param ethAmt - Eth to swap for .value() */ function oneInchSwap( OneInchData memory oneInchData, uint ethAmt ) internal returns (uint buyAmt) { TokenInterface buyToken = oneInchData.buyToken; (uint _buyDec, uint _sellDec) = getTokensDec(buyToken, oneInchData.sellToken); uint _sellAmt18 = convertTo18(_sellDec, oneInchData._sellAmt); uint _slippageAmt = convert18ToDec(_buyDec, wmul(oneInchData.unitAmt, _sellAmt18)); uint initalBal = getTokenBal(buyToken); // solium-disable-next-line security/no-call-value (bool success, ) = oneInchAddr.call{value: ethAmt}(oneInchData.callData); if (!success) revert("1Inch-swap-failed"); uint finalBal = getTokenBal(buyToken); buyAmt = sub(finalBal, initalBal); require(_slippageAmt <= buyAmt, "Too much slippage"); } } abstract contract OneInchResolverHelpers is OneInchResolver { /** * @dev Gets the swapping data from 1inch's API. * @param oneInchData Struct with multiple swap data defined in interfaces.sol * @param setId Set token amount at this ID in `InstaMemory` Contract. */ function _sell( OneInchData memory oneInchData, uint setId ) internal returns (OneInchData memory) { TokenInterface _sellAddr = oneInchData.sellToken; uint ethAmt; if (address(_sellAddr) == ethAddr) { ethAmt = oneInchData._sellAmt; } else { TokenInterface(_sellAddr).approve(oneInchAddr, oneInchData._sellAmt); } require(checkOneInchSig(oneInchData.callData), "Not-swap-function"); oneInchData._buyAmt = oneInchSwap(oneInchData, ethAmt); setUint(setId, oneInchData._buyAmt); return oneInchData; // emitLogSellThree(oneInchData, setId); } } abstract contract OneInch is OneInchResolverHelpers { /** * @dev Sell ETH/ERC20_Token using 1Inch. * @notice Swap tokens from exchanges like kyber, 0x etc, with calculation done off-chain. * @param buyAddr The address of the token to buy.(For ETH: 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE) * @param sellAddr The address of the token to sell.(For ETH: 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE) * @param sellAmt The amount of the token to sell. * @param unitAmt The amount of buyAmt/sellAmt with slippage. * @param callData Data from 1inch API. * @param setId ID stores the amount of token brought. */ function sell( address buyAddr, address sellAddr, uint sellAmt, uint unitAmt, bytes calldata callData, uint setId ) external payable returns (string memory _eventName, bytes memory _eventParam) { OneInchData memory oneInchData = OneInchData({ buyToken: TokenInterface(buyAddr), sellToken: TokenInterface(sellAddr), unitAmt: unitAmt, callData: callData, _sellAmt: sellAmt, _buyAmt: 0 }); oneInchData = _sell(oneInchData, setId); _eventName = "LogSell(address,address,uint256,uint256,uint256,uint256)"; _eventParam = abi.encode(buyAddr, sellAddr, oneInchData._buyAmt, oneInchData._sellAmt, 0, setId); } } contract ConnectV2OneInch is OneInch { string public name = "1Inch-v1"; }