SwapsUser.sol

/**
 * Copyright 2017-2021, bZeroX, LLC <https://bzx.network/>. All Rights Reserved.
 * Licensed under the Apache License, Version 2.0.
 */

pragma solidity 0.5.17;

import "../core/State.sol";
import "../feeds/IPriceFeeds.sol";
import "../events/SwapsEvents.sol";
import "../mixins/FeesHelper.sol";
import "./connectors/SwapsImplSovrynSwapLib.sol";

/**
 * @title Perform token swaps for loans and trades.
 * */
contract SwapsUser is State, SwapsEvents, FeesHelper {
    /**
     * @notice Internal loan swap.
     *
     * @param loanId The ID of the loan.
     * @param sourceToken The address of the source tokens.
     * @param destToken The address of destination tokens.
     * @param user The user address.
     * @param minSourceTokenAmount The minimum amount of source tokens to swap.
     * @param maxSourceTokenAmount The maximum amount of source tokens to swap.
     * @param requiredDestTokenAmount The required amount of destination tokens.
     * @param bypassFee To bypass or not the fee.
     * @param loanDataBytes The payload for the call. These loan DataBytes are
     *   additional loan data (not in use for token swaps).
     *
     * @return destTokenAmountReceived
     * @return sourceTokenAmountUsed
     * @return sourceToDestSwapRate
     * */
    function _loanSwap(
        bytes32 loanId,
        address sourceToken,
        address destToken,
        address user,
        uint256 minSourceTokenAmount,
        uint256 maxSourceTokenAmount,
        uint256 requiredDestTokenAmount,
        bool bypassFee,
        bytes memory loanDataBytes
    )
        internal
        returns (
            uint256 destTokenAmountReceived,
            uint256 sourceTokenAmountUsed,
            uint256 sourceToDestSwapRate
        )
    {
        (destTokenAmountReceived, sourceTokenAmountUsed) = _swapsCall(
            [
                sourceToken,
                destToken,
                address(this), // receiver
                address(this), // returnToSender
                user
            ],
            [minSourceTokenAmount, maxSourceTokenAmount, requiredDestTokenAmount],
            loanId,
            bypassFee,
            loanDataBytes,
            false // swap external flag, set to false so that it will use the tradingFeePercent
        );

        /// Will revert if swap size too large.
        _checkSwapSize(sourceToken, sourceTokenAmountUsed);

        /// Will revert if disagreement found.
        sourceToDestSwapRate = IPriceFeeds(priceFeeds).checkPriceDisagreement(
            sourceToken,
            destToken,
            sourceTokenAmountUsed,
            destTokenAmountReceived,
            maxDisagreement
        );

        emit LoanSwap(
            loanId,
            sourceToken,
            destToken,
            user,
            sourceTokenAmountUsed,
            destTokenAmountReceived
        );
    }

    /**
     * @notice Calculate amount of source and destination tokens.
     *
     * @dev Wrapper for _swapsCall_internal function.
     *
     * @param addrs The array of addresses.
     * @param vals The array of values.
     * @param loanId The Id of the associated loan.
     * @param miscBool True/false to bypassFee.
     * @param loanDataBytes Additional loan data (not in use yet).
     *
     * @return destTokenAmountReceived The amount of destination tokens received.
     * @return sourceTokenAmountUsed The amount of source tokens used.
     * */
    function _swapsCall(
        address[5] memory addrs,
        uint256[3] memory vals,
        bytes32 loanId,
        bool miscBool, /// bypassFee
        bytes memory loanDataBytes,
        bool isSwapExternal
    ) internal returns (uint256, uint256) {
        /// addrs[0]: sourceToken
        /// addrs[1]: destToken
        /// addrs[2]: receiver
        /// addrs[3]: returnToSender
        /// addrs[4]: user
        /// vals[0]:  minSourceTokenAmount
        /// vals[1]:  maxSourceTokenAmount
        /// vals[2]:  requiredDestTokenAmount

        require(vals[0] != 0 || vals[1] != 0, "min or max source token amount needs to be set");

        if (vals[1] == 0) {
            vals[1] = vals[0];
        }
        require(vals[0] <= vals[1], "sourceAmount larger than max");

        uint256 destTokenAmountReceived;
        uint256 sourceTokenAmountUsed;

        uint256 tradingFee;
        if (!miscBool) {
            /// bypassFee
            if (vals[2] == 0) {
                /// condition: vals[0] will always be used as sourceAmount

                if (isSwapExternal) {
                    tradingFee = _getSwapExternalFee(vals[0]);
                } else {
                    tradingFee = _getTradingFee(vals[0]);
                }

                if (tradingFee != 0) {
                    _payTradingFee(
                        addrs[4], /// user
                        loanId,
                        addrs[0], /// sourceToken (feeToken)
                        addrs[1], /// pairToken (used to check if there is any special rebates or not) -- to pay fee reward
                        tradingFee
                    );

                    vals[0] = vals[0].sub(tradingFee);
                }
            } else {
                /// Condition: unknown sourceAmount will be used.

                if (isSwapExternal) {
                    tradingFee = _getSwapExternalFee(vals[2]);
                } else {
                    tradingFee = _getTradingFee(vals[2]);
                }

                if (tradingFee != 0) {
                    vals[2] = vals[2].add(tradingFee);
                }
            }
        }

        require(loanDataBytes.length == 0, "invalid state");

        (destTokenAmountReceived, sourceTokenAmountUsed) = _swapsCall_internal(addrs, vals);

        if (vals[2] == 0) {
            /// There's no minimum destTokenAmount, but all of vals[0]
            /// (minSourceTokenAmount) must be spent.
            require(sourceTokenAmountUsed == vals[0], "swap too large to fill");

            if (tradingFee != 0) {
                sourceTokenAmountUsed = sourceTokenAmountUsed.add(tradingFee);
            }
        } else {
            /// There's a minimum destTokenAmount required, but
            /// sourceTokenAmountUsed won't be greater
            /// than vals[1] (maxSourceTokenAmount)
            require(sourceTokenAmountUsed <= vals[1], "swap fill too large");
            require(destTokenAmountReceived >= vals[2], "insufficient swap liquidity");

            if (tradingFee != 0) {
                _payTradingFee(
                    addrs[4], /// user
                    loanId, /// loanId,
                    addrs[1], /// destToken (feeToken)
                    addrs[0], /// pairToken (used to check if there is any special rebates or not) -- to pay fee reward
                    tradingFee
                );

                destTokenAmountReceived = destTokenAmountReceived.sub(tradingFee);
            }
        }

        return (destTokenAmountReceived, sourceTokenAmountUsed);
    }

    /**
     * @notice Calculate amount of source and destination tokens.
     *
     * @dev Calls swapsImpl::internalSwap
     *
     * @param addrs The array of addresses.
     * @param vals The array of values.
     *
     * @return destTokenAmountReceived The amount of destination tokens received.
     * @return sourceTokenAmountUsed The amount of source tokens used.
     * */
    function _swapsCall_internal(
        address[5] memory addrs,
        uint256[3] memory vals
    ) internal returns (uint256 destTokenAmountReceived, uint256 sourceTokenAmountUsed) {
        SwapsImplSovrynSwapLib.SwapParams memory swapParams;

        swapParams.sourceTokenAddress = addrs[0];
        swapParams.destTokenAddress = addrs[1];
        swapParams.receiverAddress = addrs[2];
        swapParams.returnToSenderAddress = addrs[3];
        swapParams.minSourceTokenAmount = vals[0];
        swapParams.maxSourceTokenAmount = vals[1];
        swapParams.requiredDestTokenAmount = vals[2];

        (destTokenAmountReceived, sourceTokenAmountUsed) = SwapsImplSovrynSwapLib.swap(swapParams);
    }

    /**
     * @notice Calculate expected amount of destination tokens.
     *
     * @dev Calls swapsImpl::internalExpectedReturn
     *
     * @param sourceToken The address of the source tokens.
     * @param destToken The address of the destination tokens.
     * @param sourceTokenAmount The amount of the source tokens.
     *
     * @param destTokenAmount The amount of destination tokens.
     * */
    function _swapsExpectedReturn(
        address sourceToken,
        address destToken,
        uint256 sourceTokenAmount
    ) internal view returns (uint256 destTokenAmount) {
        destTokenAmount = SwapsImplSovrynSwapLib.getExpectedReturn(
            sourceToken,
            destToken,
            sourceTokenAmount
        );
    }

    /**
     * @notice Verify that the amount of tokens are under the swap limit.
     *
     * @dev Calls priceFeeds::amountInEth
     *
     * @param tokenAddress The address of the token to calculate price.
     * @param amount The amount of tokens to calculate price.
     * */
    function _checkSwapSize(address tokenAddress, uint256 amount) internal view {
        uint256 _maxSwapSize = maxSwapSize;
        if (_maxSwapSize != 0) {
            uint256 amountInEth;
            if (tokenAddress == address(wrbtcToken)) {
                amountInEth = amount;
            } else {
                amountInEth = IPriceFeeds(priceFeeds).amountInEth(tokenAddress, amount);
            }
            require(amountInEth <= _maxSwapSize, "swap too large");
        }
    }
}