dodo-contractV2/contracts/SmartRoute/DODOV2Proxy01.sol

/*

    Copyright 2020 DODO ZOO.
    SPDX-License-Identifier: Apache-2.0

*/

pragma solidity 0.6.9;

import {IDODOV2Proxy01} from "../intf/IDODOV2Proxy01.sol";
import {IDODOV2} from "../intf/IDODOV2.sol";
import {IERC20} from "../intf/IERC20.sol";
import {IWETH} from "../intf/IWETH.sol";
import {SafeMath} from "../lib/SafeMath.sol";
import {UniversalERC20} from "../lib/UniversalERC20.sol";
import {DecimalMath} from "../lib/DecimalMath.sol";

contract DODOV2Proxy01 is IDODOV2Proxy01 {
    using SafeMath for uint256;
    using UniversalERC20 for IERC20;

    address constant ETH_ADDRESS = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE;
    address payable public _WETH_;
    address public smartApprove;
    address public dodoSellHelper;
    address public dvmFactory;
    address public dppFactory;

    modifier judgeExpired(uint256 deadline) {
        require(deadline >= block.timestamp, 'DODOV2Proxy01: EXPIRED');
        _;
    }

    //============================== events ==================================
    event OrderHistory(
        address indexed fromToken,
        address indexed toToken,
        address indexed sender,
        uint256 fromAmount,
        uint256 returnAmount,
        uint256 timeStamp
    );

    event ExternalRecord(address indexed to, address indexed sender);
    //========================================================================



    constructor(
        address _dvmFactory,
        address _dppFactory,
        address payable _weth,
        address _smartApprove,
        address _dodoSellHelper
    ) public {
        dvmFactory = _dvmFactory;
        dppFactory = _dppFactory;
        _WETH_ = _weth;
        smartApprove = _smartApprove;
        dodoSellHelper = _dodoSellHelper;
    }
    
    //TODO:ETH
    function createDODOVendingMachine(
        address baseToken,
        address quoteToken,
        uint256 baseInAmount,
        uint256 quoteInAmount,
        uint256 lpFeeRate,
        uint256 mtFeeRate,
        uint256 i,
        uint256 k,
        uint256 deadline
    ) external virtual override payable judgeExpired(deadline) returns (address newVendingMachine,uint256 shares) {
        require(k > 0 && k<= 10**18, "DODOV2Proxy01: K OUT OF RANGE");
        newVendingMachine = IDODOV2(dvmFactory).createDODOVendingMachine(baseToken,quoteToken,lpFeeRate,mtFeeRate,i,k);
        if(baseInAmount > 0) 
            IDODOV2(smartApprove).claimTokens(baseToken, msg.sender, newVendingMachine, baseInAmount);
        if(quoteInAmount > 0)
            IDODOV2(smartApprove).claimTokens(quoteToken, msg.sender, newVendingMachine, quoteInAmount);
        (shares,,) = IDODOV2(newVendingMachine).buyShares(msg.sender);
    }


    function _addDVMLiquidity(
        address DVMAddress,
        uint256 baseInAmount,
        uint256 quoteInAmount
    ) internal virtual view returns (uint baseAdjustedInAmount, uint quoteAdjustedInAmount) {
        (uint256 baseReserve, uint256 quoteReserve) = IDODOV2(DVMAddress).getVaultReserve();
        if (quoteReserve == 0 && baseReserve == 0) {
            baseAdjustedInAmount = baseInAmount;
            quoteAdjustedInAmount = quoteInAmount;
        }
        //TODO: 若init时候 baseInAmount > 0 quoteReserve = 0 之后没法添加quote？
        if (quoteReserve == 0 && baseReserve > 0) {
            baseAdjustedInAmount = baseInAmount;
            quoteAdjustedInAmount = 0;
        }
        if (quoteReserve > 0 && baseReserve > 0) {
            uint256 baseIncreaseRatio = DecimalMath.divFloor(baseInAmount, baseReserve);
            uint256 quoteIncreaseRatio = DecimalMath.divFloor(quoteInAmount, quoteReserve);
            if (baseIncreaseRatio <= quoteIncreaseRatio) {
                baseAdjustedInAmount = baseInAmount;
                quoteAdjustedInAmount = DecimalMath.mulFloor(quoteReserve, baseIncreaseRatio);
            } else {
                quoteAdjustedInAmount = quoteInAmount;
                baseAdjustedInAmount = DecimalMath.mulFloor(baseReserve, quoteIncreaseRatio);
            }
        }
    }

    //TODO:ETH 
    function addDVMLiquidity(
        address DVMAddress,
        address to,
        uint256 baseInAmount,
        uint256 quoteInAmount,
        uint256 baseMinAmount,
        uint256 quoteMinAmount,
        uint256 deadline
    ) external virtual override payable judgeExpired(deadline) returns (uint256 shares,uint256 baseActualInAmount,uint256 quoteActualInAmount) {
        (uint256 baseAdjustedInAmount, uint256 quoteAdjustedInAmount) = _addDVMLiquidity(DVMAddress,baseInAmount,quoteInAmount);
        address _dvm = DVMAddress;
        if(baseAdjustedInAmount > 0)
            IDODOV2(smartApprove).claimTokens(IDODOV2(_dvm)._BASE_TOKEN_(), msg.sender, _dvm, baseAdjustedInAmount);
        if(quoteAdjustedInAmount > 0)
            IDODOV2(smartApprove).claimTokens(IDODOV2(_dvm)._QUOTE_TOKEN_(), msg.sender, _dvm, quoteAdjustedInAmount);
        (shares,baseActualInAmount,quoteActualInAmount) = IDODOV2(_dvm).buyShares(to);
        require(baseActualInAmount >= baseMinAmount && quoteActualInAmount >= quoteMinAmount, "DODOV2Proxy01: deposit amount is not enough");
    }

    //TODO:ETH 构造data
    function removeDVMLiquidity(
        address DVMAddress,
        address to,
        uint256 shares,
        uint256 baseOutMinAmount,
        uint256 quoteOutMinAmount,
        uint256 deadline
    ) external virtual override payable judgeExpired(deadline) returns (uint256 baseOutAmount,uint256 quoteOutAmount) {
        require(shares > 0, "DODOV2Proxy01: Insufficient_Liquidity");
        (baseOutAmount,quoteOutAmount) = IDODOV2(DVMAddress).sellShares(to, shares, "");
        require(baseOutAmount >= baseOutMinAmount && quoteOutAmount >= quoteOutMinAmount,"DODOV2Proxy01: withdraw amount is not enough");
    }

    //TODO:ETH 
    function createDODOPrivatePool(
        address baseToken,
        address quoteToken,
        uint256 baseInAmount,
        uint256 quoteInAmount,
        uint256 lpFeeRate,
        uint256 mtFeeRate,
        uint256 i,
        uint256 k,
        uint256 deadline
    ) external virtual override payable judgeExpired(deadline) returns (address newPrivatePool) {
        newPrivatePool = IDODOV2(dppFactory).createDODOPrivatePool(baseToken, quoteToken, lpFeeRate, mtFeeRate, i, k);
        if(baseInAmount > 0) 
            IDODOV2(smartApprove).claimTokens(baseToken, msg.sender, newPrivatePool, baseInAmount);
        if(quoteInAmount > 0)
            IDODOV2(smartApprove).claimTokens(quoteToken, msg.sender, newPrivatePool, quoteInAmount);
        IDODOV2(newPrivatePool).initTargetAndReserve();
    }

    //TODO:ETH
    function resetDODOPrivatePool(
        address DPPAddress,
        uint256 newLpFeeRate,
        uint256 newMtFeeRate,
        uint256 newI,
        uint256 newK,
        uint256 baseInAmount,
        uint256 quoteInAmount,
        uint256 baseOutAmount,
        uint256 quoteOutAmount,
        uint256 deadline
    ) external virtual override payable judgeExpired(deadline) {
        if(baseInAmount > 0) 
            IDODOV2(smartApprove).claimTokens(IDODOV2(DPPAddress)._BASE_TOKEN_(), msg.sender, DPPAddress, baseInAmount);
        if(quoteInAmount > 0)
            IDODOV2(smartApprove).claimTokens(IDODOV2(DPPAddress)._QUOTE_TOKEN_(), msg.sender, DPPAddress, quoteInAmount);
        IDODOV2(DPPAddress).reset(
            newLpFeeRate,
            newMtFeeRate,
            newI,
            newK,
            baseOutAmount,
            quoteOutAmount
        );
    }

    function dodoSwap(
        address fromToken,
        address toToken,
        uint256 fromTokenAmount,
        uint256 minReturnAmount,
        address[] memory dodoPairs,
        uint256[] memory directions,
        uint256 deadline
    ) external virtual override payable judgeExpired(deadline) returns (uint256 returnAmount) {
        require(minReturnAmount > 0, "DODOV2Proxy01: Min return should be bigger than 0.");
        require(dodoPairs.length > 0, "DODOV2Proxy01: pairs should exists.");

        if (fromToken != ETH_ADDRESS) {
            IDODOV2(smartApprove).claimTokens(fromToken, msg.sender, dodoPairs[0], fromTokenAmount);
        } else {
            require(msg.value == fromTokenAmount, "DODOV2Proxy01: ETH_AMOUNT_NOT_MATCH");
            IWETH(_WETH_).deposit{value: fromTokenAmount}();
            IWETH(_WETH_).transfer(dodoPairs[0],IWETH(_WETH_).balanceOf(address(this)));
        }

        for (uint256 i = 0; i < dodoPairs.length; i++) {
            address curTo;
            if(i == dodoPairs.length - 1){
                curTo = address(this);
            } else {
                curTo = dodoPairs[i+1];
            }
            if (directions[i] == 0) {
                IDODOV2(dodoPairs[i]).sellBase(curTo);
            } else {
                IDODOV2(dodoPairs[i]).sellQuote(curTo);
            }
        }
        IERC20(fromToken).universalTransfer(msg.sender, IERC20(fromToken).universalBalanceOf(address(this)));

        if (toToken == ETH_ADDRESS) {
            uint256 wethAmount = IWETH(_WETH_).balanceOf(address(this));
            IWETH(_WETH_).withdraw(wethAmount);
        }

        returnAmount = IERC20(toToken).universalBalanceOf(address(this));

        require(returnAmount >= minReturnAmount, "DODOV2Proxy01: Return amount is not enough");
        IERC20(toToken).universalTransfer(msg.sender, returnAmount);
        emit OrderHistory(fromToken, toToken, msg.sender, fromTokenAmount, returnAmount, block.timestamp);
    }

    function externalSwap(
        address fromToken,
        address toToken,
        address approveTarget,
        address to,
        uint256 gasSwap,
        uint256 fromTokenAmount,
        uint256 minReturnAmount,
        bytes memory callDataConcat,
        uint256 deadline
    ) external virtual override payable judgeExpired(deadline) returns (uint256 returnAmount) {
        
        require(minReturnAmount > 0, "DODOV2Proxy01: Min return should be bigger then 0.");

        if (fromToken != ETH_ADDRESS) {
            IDODOV2(smartApprove).claimTokens(fromToken, msg.sender, address(this), fromTokenAmount);
            IERC20(fromToken).universalApprove(approveTarget, fromTokenAmount);
        }

        (bool success, ) = to.call{value: fromToken == ETH_ADDRESS ? msg.value : 0, gas: gasSwap}(
            callDataConcat
        );

        require(success, "DODOV2Proxy01: Contract Swap execution Failed");

        IERC20(fromToken).universalTransfer(msg.sender, IERC20(fromToken).universalBalanceOf(address(this)));
        returnAmount = IERC20(toToken).universalBalanceOf(address(this));

        require(returnAmount >= minReturnAmount, "DODOV2Proxy01: Return amount is not enough");
        IERC20(toToken).universalTransfer(msg.sender, returnAmount);
        emit OrderHistory(fromToken, toToken, msg.sender, fromTokenAmount, returnAmount, block.timestamp);
        emit ExternalRecord(to, msg.sender);
    }

    //====================== temporary for test ======================
    // function sellBaseOnDVM(
    //     address DVMAddress,
    //     address to,
    //     uint256 baseAmount,
    //     uint256 minReceive
    // ) public returns (uint256 receiveAmount) {
    //     IERC20(IDVM(DVMAddress)._BASE_TOKEN_()).safeTransferFrom(
    //         msg.sender,
    //         DVMAddress,
    //         baseAmount
    //     );
    //     receiveAmount = IDVM(DVMAddress).sellBase(to);
    //     require(receiveAmount >= minReceive, "RECEIVE_NOT_ENOUGH");
    //     return receiveAmount;
    // }

    // function sellQuoteOnDVM(
    //     address DVMAddress,
    //     address to,
    //     uint256 quoteAmount,
    //     uint256 minReceive
    // ) public returns (uint256 receiveAmount) {
    //     IERC20(IDVM(DVMAddress)._QUOTE_TOKEN_()).safeTransferFrom(
    //         msg.sender,
    //         DVMAddress,
    //         quoteAmount
    //     );
    //     receiveAmount = IDVM(DVMAddress).sellQuote(to);
    //     require(receiveAmount >= minReceive, "RECEIVE_NOT_ENOUGU");
    //     return receiveAmount;
    // }

    // function depositToDVM(
    //     address DVMAddress,
    //     address to,
    //     uint256 baseAmount,
    //     uint256 quoteAmount
    // ) public returns (uint256 shares) {
    //     uint256 adjustedBaseAmount;
    //     uint256 adjustedQuoteAmount;
    //     (uint256 baseReserve, uint256 quoteReserve) = IDVM(DVMAddress).getVaultReserve();
    //     if (quoteReserve == 0 && baseReserve == 0) {
    //         adjustedBaseAmount = baseAmount;
    //         adjustedQuoteAmount = quoteAmount;
    //     }
    //     if (quoteReserve == 0 && baseReserve > 0) {
    //         adjustedBaseAmount = baseAmount;
    //         adjustedQuoteAmount = 0;
    //     }
    //     if (quoteReserve > 0 && baseReserve > 0) {
    //         uint256 baseIncreaseRatio = DecimalMath.divFloor(baseAmount, baseReserve);
    //         uint256 quoteIncreaseRatio = DecimalMath.divFloor(quoteAmount, quoteReserve);
    //         if (baseIncreaseRatio <= quoteIncreaseRatio) {
    //             adjustedBaseAmount = baseAmount;
    //             adjustedQuoteAmount = DecimalMath.mulFloor(quoteReserve, baseIncreaseRatio);
    //         } else {
    //             adjustedQuoteAmount = quoteAmount;
    //             adjustedBaseAmount = DecimalMath.mulFloor(baseReserve, quoteIncreaseRatio);
    //         }
    //     }
    //     IERC20(IDVM(DVMAddress)._BASE_TOKEN_()).safeTransferFrom(
    //         msg.sender,
    //         DVMAddress,
    //         adjustedBaseAmount
    //     );
    //     IERC20(IDVM(DVMAddress)._QUOTE_TOKEN_()).safeTransferFrom(
    //         msg.sender,
    //         DVMAddress,
    //         adjustedQuoteAmount
    //     );
    //     shares = IDVM(DVMAddress).buyShares(to);
    //     return shares;
    // }
}