DeFi Saver

function executeOperation(
    address[] memory _assets,
    uint256[] memory _amounts,
    uint256[] memory _fees,
    address _initiator,
    bytes memory _params
) public returns (bool) {
    require(msg.sender == AAVE_LENDING_POOL, ERR_ONLY_AAVE_CALLER);
    require(_initiator == address(this), ERR_SAME_CALLER);

    (Task memory currTask, address proxy) = abi.decode(_params, (Task, address));

    // Send FL amounts to user proxy
    for (uint256 i = 0; i < _assets.length; ++i) {
        _assets[i].withdrawTokens(proxy, _amounts[i]);
    }

    address payable taskExecutor = payable(registry.getAddr(TASK_EXECUTOR_ID));

    // call Action execution
    IDSProxy(proxy).execute{value: address(this).balance}(
        taskExecutor,
        abi.encodeWithSelector(CALLBACK_SELECTOR, currTask, bytes32(_amounts[0] + _fees[0]))
    );

    // return FL
    for (uint256 i = 0; i < _assets.length; i++) {
        _assets[i].approveToken(address(AAVE_LENDING_POOL), _amounts[i] + _fees[i]);
    }

    return true;
}

    function getSellRate(address _srcAddr, address _destAddr, uint _srcAmount, bytes memory) public override view returns (uint rate) {
        (rate, ) = KyberNetworkProxyInterface(KYBER_INTERFACE)
            .getExpectedRate(IERC20(_srcAddr), IERC20(_destAddr), _srcAmount);

        // multiply with decimal difference in src token
        rate = rate * (10**(18 - getDecimals(_srcAddr)));
        // divide with decimal difference in dest token
        rate = rate / (10**(18 - getDecimals(_destAddr)));
    }

function enterMarket(address _cTokenAddr) public {
    address[] memory markets = new address[](1);
    markets[0] = _cTokenAddr;

    IComptroller(COMPTROLLER_ADDR).enterMarkets(markets);
}

/// @notice Exits the Compound market
/// @param _cTokenAddr CToken address of the token
function exitMarket(address _cTokenAddr) public {
    IComptroller(COMPTROLLER_ADDR).exitMarket(_cTokenAddr);
}

function pullTokens(
    address _token,
    address _from,
    uint256 _amount
) internal returns (uint256) {
    // handle max uint amount
    if (_amount == type(uint256).max) {
        uint256 allowance = IERC20(_token).allowance(address(this), _from);
        uint256 balance = getBalance(_token, _from);

        _amount = (balance > allowance) ? allowance : balance;
    }

    if (_from != address(0) && _from != address(this) && _token != ETH_ADDR && _amount != 0) {
        IERC20(_token).safeTransferFrom(_from, address(this), _amount);
    }

    return _amount;
}

   function getSellRate(address _srcAddr, address _destAddr, uint _srcAmount, bytes memory) public override view returns (uint rate) {
        (rate, ) = KyberNetworkProxyInterface(KYBER_INTERFACE)
            .getExpectedRate(IERC20(_srcAddr), IERC20(_destAddr), _srcAmount);

        // multiply with decimal difference in src token
        rate = rate * (10**(18 - getDecimals(_srcAddr)));
        // divide with decimal difference in dest token
        rate = rate / (10**(18 - getDecimals(_destAddr)));
    }

    /// @notice Return a rate for which we can buy an amount of tokens
    /// @param _srcAddr From token
    /// @param _destAddr To token
    /// @param _destAmount To amount
    /// @return rate Rate
    function getBuyRate(address _srcAddr, address _destAddr, uint _destAmount, bytes memory _additionalData) public override view returns (uint rate) {
        uint256 srcRate = getSellRate(_destAddr, _srcAddr, _destAmount, _additionalData);
        uint256 srcAmount = wmul(srcRate, _destAmount);

        rate = getSellRate(_srcAddr, _destAddr, srcAmount, _additionalData);

        // increase rate by 3% too account for inaccuracy between sell/buy conversion
        rate = rate + (rate / 30);
    }

uint256 tokensBefore = _exData.destAddr.getBalance(address(this));
(success, ) = _exData.offchainData.exchangeAddr.call{value: _exData.offchainData.protocolFee}(_exData.offchainData.callData);
uint256 tokensSwaped = 0;

if (success) {
    // get the current balance of the swaped tokens
    tokensSwaped = _exData.destAddr.getBalance(address(this)) - tokensBefore;
    require(tokensSwaped > 0, ERR_TOKENS_SWAPED_ZERO);
}

uint256 tokensBefore = _exData.destAddr.getBalance(address(this));
(success, ) = _exData.offchainData.exchangeAddr.call{value: _exData.offchainData.protocolFee}(_exData.offchainData.callData);
uint256 tokensSwaped = 0;

if (success) {
    // get the current balance of the swaped tokens
    tokensSwaped = _exData.destAddr.getBalance(address(this)) - tokensBefore;
    require(tokensSwaped > 0, ERR_TOKENS_SWAPED_ZERO);
}

function _sell(ExchangeData memory exData) internal returns (address, uint256) {
    uint256 amountWithoutFee = exData.srcAmount;
    address wrapper = exData.offchainData.wrapper;
    bool offChainSwapSuccess;

    uint256 destBalanceBefore = exData.destAddr.getBalance(address(this));

    // Takes DFS exchange fee
    exData.srcAmount -= getFee(
        exData.srcAmount,
        exData.user,
        exData.srcAddr,
        exData.dfsFeeDivider
    );

    // Try 0x first and then fallback on specific wrapper
    if (exData.offchainData.price > 0) {
        (offChainSwapSuccess, ) = offChainSwap(exData, ExchangeActionType.SELL);
    }

    // fallback to desired wrapper if 0x failed
    if (!offChainSwapSuccess) {
        onChainSwap(exData, ExchangeActionType.SELL);
        wrapper = exData.wrapper;
    }

    uint256 destBalanceAfter = exData.destAddr.getBalance(address(this));
    uint256 amountBought = sub(destBalanceAfter, destBalanceBefore);

    // check slippage
    require(amountBought >= wmul(exData.minPrice, exData.srcAmount), ERR_SLIPPAGE_HIT);

    // revert back exData changes to keep it consistent
    exData.srcAmount = amountWithoutFee;

    return (wrapper, amountBought);
}

function _buy(ExchangeData memory exData) internal returns (address, uint256) {
    require(exData.destAmount != 0, ERR_DEST_AMOUNT_MISSING);

    uint256 amountWithoutFee = exData.srcAmount;
    address wrapper = exData.offchainData.wrapper;
    bool offChainSwapSuccess;

    uint256 destBalanceBefore = exData.destAddr.getBalance(address(this));

    // Takes DFS exchange fee
    exData.srcAmount -= getFee(
        exData.srcAmount,
        exData.user,
        exData.srcAddr,
        exData.dfsFeeDivider
    );

    // Try 0x first and then fallback on specific wrapper
    if (exData.offchainData.price > 0) {
        (offChainSwapSuccess, ) = offChainSwap(exData, ExchangeActionType.BUY);
    }

    // fallback to desired wrapper if 0x failed
    if (!offChainSwapSuccess) {
        onChainSwap(exData, ExchangeActionType.BUY);
        wrapper = exData.wrapper;
    }

    uint256 destBalanceAfter = exData.destAddr.getBalance(address(this));
    uint256 amountBought = sub(destBalanceAfter, destBalanceBefore);

    // check slippage
    require(amountBought >= exData.destAmount, ERR_SLIPPAGE_HIT);

    // revert back exData changes to keep it consistent
    exData.srcAmount = amountWithoutFee;

    return (wrapper, amountBought);
}

function _borrow(
    address _market,
    address _tokenAddr,
    uint256 _amount,
    uint256 _rateMode,
    address _to,
    address _onBehalf
) internal returns (uint256) {
    ILendingPoolV2 lendingPool = getLendingPool(_market);

    // defaults to onBehalf of proxy
    if (_onBehalf == address(0)) {
        _onBehalf = address(this);
    }

    lendingPool.borrow(_tokenAddr, _amount, _rateMode, AAVE_REFERRAL_CODE, _onBehalf);

    _tokenAddr.withdrawTokens(_to, _amount);

    logger.Log(
        address(this),
        msg.sender,
        "AaveBorrow",
        abi.encode(_market, _tokenAddr, _amount, _rateMode, _to, _onBehalf)
    );

    return _amount;
}

function withdrawTokens(
    address _token,
    address _to,
    uint256 _amount
) internal returns (uint256) {
    if (_amount == type(uint256).max) {
        _amount = getBalance(_token, address(this));
    }

function Log(
    address _contract,
    address _caller,
    string memory _logName,
    bytes memory _data
) public {
    emit LogEvent(_contract, _caller, _logName, _data);
}

    DefisaverLogger public constant logger = DefisaverLogger(
        0x5c55B921f590a89C1Ebe84dF170E655a82b62126
    );

    AdminVault public constant adminVault = AdminVault(0xCCf3d848e08b94478Ed8f46fFead3008faF581fD);

    address public constant REGISTRY_ADDR = 0xB0e1682D17A96E8551191c089673346dF7e1D467;

function _executeActionsFromFL(Task memory _currTask, bytes32 _flAmount) public payable {

function sell(ExchangeData memory exData, address payable _user) public payable   {

    exData.dfsFeeDivider = SERVICE_FEE;
    exData.user = _user;

    // Perform the exchange
    (address wrapper, uint destAmount) = _sell(exData);

    // send back any leftover ether or tokens
    sendLeftover(exData.srcAddr, exData.destAddr, _user);

    // log the event
    logger.Log(address(this), msg.sender, "ExchangeSell", abi.encode(wrapper, exData.srcAddr, exData.destAddr, exData.srcAmount, destAmount));
}

function setServiceFee(address _user, uint256 _fee) public {
    require(msg.sender == owner, "Only owner");
    require(_fee >= MAX_SERVICE_FEE || _fee == 0, "Wrong fee value");

    serviceFees[_user] = CustomServiceFee({active: true, amount: _fee});
}

function getFee(
    uint256 _amount,
    address _user,
    address _token,
    uint256 _dfsFeeDivider
) internal returns (uint256 feeAmount) {
    if (_dfsFeeDivider != 0 && Discount(DISCOUNT_ADDRESS).isCustomFeeSet(_user)) {
        _dfsFeeDivider = Discount(DISCOUNT_ADDRESS).getCustomServiceFee(_user);
    }

    if (_dfsFeeDivider == 0) {
        feeAmount = 0;
    } else {
        feeAmount = _amount / _dfsFeeDivider;

        // fee can't go over 10% of the whole amount
        if (feeAmount > (_amount / 10)) {
            feeAmount = _amount / 10;
        }

        address walletAddr = feeRecipient.getFeeAddr();

        _token.withdrawTokens(walletAddr, feeAmount);
    }
}

function takeOrder(
    ExchangeData memory _exData,
    ExchangeActionType _type
) override public payable returns (bool success, uint256) {
    // check that contract have enough balance for exchange and protocol fee
    require(_exData.srcAddr.getBalance(address(this)) >= _exData.srcAmount, ERR_SRC_AMOUNT);
    require(TokenUtils.ETH_ADDR.getBalance(address(this)) >= _exData.offchainData.protocolFee, ERR_PROTOCOL_FEE);

/**
 * @dev Deprecated. This function has issues similar to the ones found in
 * {ERC20-approve}, and its usage is discouraged.
 */
function safeApprove(
    IERC20 token,
    address spender,
    uint256 value
) internal {
    _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, 0));
    _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}

uint internal constant RECIPIE_FEE = 400;

function sendLeftOver(address _srcAddr) internal {
    msg.sender.transfer(address(this).balance);

    if (_srcAddr != KYBER_ETH_ADDRESS) {
        IERC20(_srcAddr).safeTransfer(msg.sender, IERC20(_srcAddr).balanceOf(address(this)));
    }
}

/// @notice User borrows tokens to the Aave protocol
/// @param _market Address provider for specific market
/// @param _tokenAddr The address of the token to be borrowed
/// @param _amount Amount of tokens to be borrowed
/// @param _rateMode Send 1 for stable rate and 2 for variable
/// @param _to The address we are sending the borrowed tokens to
/// @param _onBehalf From what user we are borrow the tokens, defaults to proxy
function _borrow(
    address _market,
    address _tokenAddr,
    uint256 _amount,
    uint256 _rateMode,
    address _to,
    address _onBehalf
) internal returns (uint256) {

/// @notice User borrows tokens to the Compound protocol
/// @param _cTokenAddr Address of the cToken we are borrowing
/// @param _amount Amount of tokens to be borrowed
/// @param _to The address we are sending the borrowed tokens to
function _borrow(
    address _cTokenAddr,
    uint256 _amount,
    address _to
) internal returns (uint256) {

function _executeAction(
    Task memory _currTask,
    uint256 _index,
    bytes32[] memory _returnValues
) internal returns (bytes32 response) {
    response = IDSProxy(address(this)).execute{value: address(this).balance}(
        registry.getAddr(_currTask.actionIds[_index]),
        abi.encodeWithSignature(
            "executeAction(bytes[],bytes[],uint8[],bytes32[])",
            _currTask.callData[_index],
            _currTask.subData[_index],
            _currTask.paramMapping[_index],
            _returnValues
        )
    );
}

uint256 compClaimed = compBalanceAfter - compBalanceBefore;

_amount = tokenBalanceAfter - tokenBalanceBefore;

_uniData.tokenA.withdrawTokens(_uniData.to, (_uniData.amountADesired - amountA));
_uniData.tokenB.withdrawTokens(_uniData.to, (_uniData.amountBDesired - amountB));

IDSProxy(proxy).execute{value: address(this).balance}(
    taskExecutor,
    abi.encodeWithSelector(CALLBACK_SELECTOR, currTask, bytes32(_amounts[0] + _fees[0]))
);

// return FL
for (uint256 i = 0; i < _assets.length; i++) {
    _assets[i].approveToken(address(AAVE_LENDING_POOL), _amounts[i] + _fees[i]);
}

exData.srcAmount -= getFee(

tokensSwaped = _exData.destAddr.getBalance(address(this)) - tokensBefore;

function _flAaveV2(FLAaveV2Data memory _flData, bytes memory _params) internal returns (uint) {

    ILendingPoolV2(AAVE_LENDING_POOL).flashLoan(
        payable(registry.getAddr(FL_AAVE_V2_ID)),
        _flData.tokens,
        _flData.amounts,
        _flData.modes,
        _flData.onBehalfOf,
        _params,
        AAVE_REFERRAL_CODE
    );

    logger.Log(
        address(this),
        msg.sender,
        "FLAaveV2",
        abi.encode(_flData.tokens, _flData.amounts, _flData.modes, _flData.onBehalfOf)
    );

    return _flData.amounts[0];
}

function _flDyDx(
    uint256 _amount,
    address _token,
    bytes memory _data
) internal returns (uint256) {

    address payable receiver = payable(registry.getAddr(FL_DYDX_ID));

    ISoloMargin solo = ISoloMargin(SOLO_MARGIN_ADDRESS);

    // Get marketId from token address
    uint256 marketId = _getMarketIdFromTokenAddress(SOLO_MARGIN_ADDRESS, _token);

    uint256 repayAmount = _getRepaymentAmountInternal(_amount);

    IERC20(_token).safeApprove(SOLO_MARGIN_ADDRESS, repayAmount);

    Actions.ActionArgs[] memory operations = new Actions.ActionArgs[](3);

    operations[0] = _getWithdrawAction(marketId, _amount, receiver);
    operations[1] = _getCallAction(_data, receiver);
    operations[2] = _getDepositAction(marketId, repayAmount, address(this));

    Account.Info[] memory accountInfos = new Account.Info[](1);
    accountInfos[0] = _getAccountInfo();

    solo.operate(accountInfos, operations);

    logger.Log(address(this), msg.sender, "FLDyDx", abi.encode(_amount, _token));

    return _amount;
}