Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta

Outline

• interface IDODOApprove
•    - function claimTokens(address token,ad ...
•    - function getDODOProxy()
•  contract InitializableOwnable
•    - function initOwner(address newOwner)
•    - function transferOwnership(address ne ...
•    - function claimOwnership()
• interface IDODOApproveProxy
•    - function isAllowedProxy(address _prox ...
•    - function claimTokens(address token,ad ...
•  contract DODOApproveProxy is Initi ...
•    - function init(address owner, address[ ...
•    - function unlockAddProxy(address newDo ...
•    - function lockAddProxy()
•    - function addDODOProxy()
•    - function removeDODOProxy (address old ...
•    - function claimTokens(
•    - function isAllowedProxy(address _prox ...
• interface IERC20
•    - function totalSupply()
•    - function decimals()
•    - function name()
•    - function symbol()
•    - function balanceOf(address account)
•    - function transfer(address recipient, ...
•    - function allowance(address owner, add ...
•    - function approve(address spender, uin ...
•    - function transferFrom(
• interface IWETH
•    - function totalSupply()
•    - function balanceOf(address account)
•    - function transfer(address recipient, ...
•    - function allowance(address owner, add ...
•    - function approve(address spender, uin ...
•    - function transferFrom(
•    - function deposit()
•    - function withdraw(uint256 wad)
• library SafeMath
•    - function mul(uint256 a, uint256 b)
•    - function div(uint256 a, uint256 b)
•    - function divCeil(uint256 a, uint256 b ...
•    - function sub(uint256 a, uint256 b)
•    - function add(uint256 a, uint256 b)
•    - function sqrt(uint256 x)
• library SafeERC20
•    - function safeTransfer(
•    - function safeTransferFrom(
•    - function safeApprove(
•    - function _callOptionalReturn(IERC20 t ...
• library DecimalMath
•    - function mulFloor(uint256 target, uin ...
•    - function mulCeil(uint256 target, uint ...
•    - function divFloor(uint256 target, uin ...
•    - function divCeil(uint256 target, uint ...
•    - function reciprocalFloor(uint256 targ ...
•    - function reciprocalCeil(uint256 targe ...
•  contract ReentrancyGuard
• interface IDSP
•    - function init(
•    - function _BASE_TOKEN_()
•    - function _QUOTE_TOKEN_()
•    - function _I_()
•    - function _MT_FEE_RATE_MODEL_()
•    - function getVaultReserve()
•    - function sellBase(address to)
•    - function sellQuote(address to)
•    - function buyShares(address to)
• interface ICloneFactory
•    - function clone(address prototype)
•  contract CloneFactory is ICloneFac ...
•    - function clone(address prototype)
• interface IDSPFactory
•    - function createDODOStablePool(
•  contract DSPFactory is Initializab ...
•    - function createDODOStablePool(
•    - function updateDSPTemplate(address _n ...
•    - function addPoolByAdmin(
•    - function removePoolByAdmin(
•    - function getDODOPool(address baseToke ...
•    - function getDODOPoolBidirection(addre ...
•    - function getDODOPoolByUser(address us ...
•  contract DODODspProxy is Reentranc ... *
•    - function createDODOStablePair(
•    - function addDSPLiquidity(
•    - function _addDSPLiquidity(
•    - function _deposit(

More Options

• Similar
• Submit Audit
• Compare

/**
 *Submitted for verification at polygonscan.com on 2021-06-11
*/

// File: contracts/intf/IDODOApprove.sol

/*

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

*/

pragma solidity 0.6.9;


interface IDODOApprove {
    function claimTokens(address token,address who,address dest,uint256 amount) external;
    function getDODOProxy() external view returns (address);
}

// File: contracts/lib/InitializableOwnable.sol


/**
 * @title Ownable
 * @author DODO Breeder
 *
 * @notice Ownership related functions
 */
contract InitializableOwnable {
    address public _OWNER_;
    address public _NEW_OWNER_;
    bool internal _INITIALIZED_;

    // ============ Events ============

    event OwnershipTransferPrepared(address indexed previousOwner, address indexed newOwner);

    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

    // ============ Modifiers ============

    modifier notInitialized() {
        require(!_INITIALIZED_, "DODO_INITIALIZED");
        _;
    }

    modifier onlyOwner() {
        require(msg.sender == _OWNER_, "NOT_OWNER");
        _;
    }

    // ============ Functions ============

    function initOwner(address newOwner) public notInitialized {
        _INITIALIZED_ = true;
        _OWNER_ = newOwner;
    }

    function transferOwnership(address newOwner) public onlyOwner {
        emit OwnershipTransferPrepared(_OWNER_, newOwner);
        _NEW_OWNER_ = newOwner;
    }

    function claimOwnership() public {
        require(msg.sender == _NEW_OWNER_, "INVALID_CLAIM");
        emit OwnershipTransferred(_OWNER_, _NEW_OWNER_);
        _OWNER_ = _NEW_OWNER_;
        _NEW_OWNER_ = address(0);
    }
}

// File: contracts/SmartRoute/DODOApproveProxy.sol



interface IDODOApproveProxy {
    function isAllowedProxy(address _proxy) external view returns (bool);
    function claimTokens(address token,address who,address dest,uint256 amount) external;
}

/**
 * @title DODOApproveProxy
 * @author DODO Breeder
 *
 * @notice Allow different version dodoproxy to claim from DODOApprove
 */
contract DODOApproveProxy is InitializableOwnable {
    
    // ============ Storage ============
    uint256 private constant _TIMELOCK_DURATION_ = 3 days;
    mapping (address => bool) public _IS_ALLOWED_PROXY_;
    uint256 public _TIMELOCK_;
    address public _PENDING_ADD_DODO_PROXY_;
    address public immutable _DODO_APPROVE_;

    // ============ Modifiers ============
    modifier notLocked() {
        require(
            _TIMELOCK_ <= block.timestamp,
            "SetProxy is timelocked"
        );
        _;
    }

    constructor(address dodoApporve) public {
        _DODO_APPROVE_ = dodoApporve;
    }

    function init(address owner, address[] memory proxies) external {
        initOwner(owner);
        for(uint i = 0; i < proxies.length; i++) 
            _IS_ALLOWED_PROXY_[proxies[i]] = true;
    }

    function unlockAddProxy(address newDodoProxy) public onlyOwner {
        _TIMELOCK_ = block.timestamp + _TIMELOCK_DURATION_;
        _PENDING_ADD_DODO_PROXY_ = newDodoProxy;
    }

    function lockAddProxy() public onlyOwner {
       _PENDING_ADD_DODO_PROXY_ = address(0);
       _TIMELOCK_ = 0;
    }


    function addDODOProxy() external onlyOwner notLocked() {
        _IS_ALLOWED_PROXY_[_PENDING_ADD_DODO_PROXY_] = true;
        lockAddProxy();
    }

    function removeDODOProxy (address oldDodoProxy) public onlyOwner {
        _IS_ALLOWED_PROXY_[oldDodoProxy] = false;
    }
    
    function claimTokens(
        address token,
        address who,
        address dest,
        uint256 amount
    ) external {
        require(_IS_ALLOWED_PROXY_[msg.sender], "DODOApproveProxy:Access restricted");
        IDODOApprove(_DODO_APPROVE_).claimTokens(
            token,
            who,
            dest,
            amount
        );
    }

    function isAllowedProxy(address _proxy) external view returns (bool) {
        return _IS_ALLOWED_PROXY_[_proxy];
    }
}

// File: contracts/intf/IERC20.sol


/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @dev Returns the amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

    function decimals() external view returns (uint8);

    function name() external view returns (string memory);

    function symbol() external view returns (string memory);

    /**
     * @dev Returns the amount of tokens owned by `account`.
     */
    function balanceOf(address account) external view returns (uint256);

    /**
     * @dev Moves `amount` tokens from the caller's account to `recipient`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address recipient, uint256 amount) external returns (bool);

    /**
     * @dev Returns the remaining number of tokens that `spender` will be
     * allowed to spend on behalf of `owner` through {transferFrom}. This is
     * zero by default.
     *
     * This value changes when {approve} or {transferFrom} are called.
     */
    function allowance(address owner, address spender) external view returns (uint256);

    /**
     * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * IMPORTANT: Beware that changing an allowance with this method brings the risk
     * that someone may use both the old and the new allowance by unfortunate
     * transaction ordering. One possible solution to mitigate this race
     * condition is to first reduce the spender's allowance to 0 and set the
     * desired value afterwards:
     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
     *
     * Emits an {Approval} event.
     */
    function approve(address spender, uint256 amount) external returns (bool);

    /**
     * @dev Moves `amount` tokens from `sender` to `recipient` using the
     * allowance mechanism. `amount` is then deducted from the caller's
     * allowance.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(
        address sender,
        address recipient,
        uint256 amount
    ) external returns (bool);
}

// File: contracts/intf/IWETH.sol



interface IWETH {
    function totalSupply() external view returns (uint256);

    function balanceOf(address account) external view returns (uint256);

    function transfer(address recipient, uint256 amount) external returns (bool);

    function allowance(address owner, address spender) external view returns (uint256);

    function approve(address spender, uint256 amount) external returns (bool);

    function transferFrom(
        address src,
        address dst,
        uint256 wad
    ) external returns (bool);

    function deposit() external payable;

    function withdraw(uint256 wad) external;
}

// File: contracts/lib/SafeMath.sol

/**
 * @title SafeMath
 * @author DODO Breeder
 *
 * @notice Math operations with safety checks that revert on error
 */
library SafeMath {
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        if (a == 0) {
            return 0;
        }

        uint256 c = a * b;
        require(c / a == b, "MUL_ERROR");

        return c;
    }

    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        require(b > 0, "DIVIDING_ERROR");
        return a / b;
    }

    function divCeil(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 quotient = div(a, b);
        uint256 remainder = a - quotient * b;
        if (remainder > 0) {
            return quotient + 1;
        } else {
            return quotient;
        }
    }

    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        require(b <= a, "SUB_ERROR");
        return a - b;
    }

    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        require(c >= a, "ADD_ERROR");
        return c;
    }

    function sqrt(uint256 x) internal pure returns (uint256 y) {
        uint256 z = x / 2 + 1;
        y = x;
        while (z < y) {
            y = z;
            z = (x / z + z) / 2;
        }
    }
}

// File: contracts/lib/SafeERC20.sol



/**
 * @title SafeERC20
 * @dev Wrappers around ERC20 operations that throw on failure (when the token
 * contract returns false). Tokens that return no value (and instead revert or
 * throw on failure) are also supported, non-reverting calls are assumed to be
 * successful.
 * To use this library you can add a `using SafeERC20 for ERC20;` statement to your contract,
 * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
 */
library SafeERC20 {
    using SafeMath for uint256;

    function safeTransfer(
        IERC20 token,
        address to,
        uint256 value
    ) internal {
        _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
    }

    function safeTransferFrom(
        IERC20 token,
        address from,
        address to,
        uint256 value
    ) internal {
        _callOptionalReturn(
            token,
            abi.encodeWithSelector(token.transferFrom.selector, from, to, value)
        );
    }

    function safeApprove(
        IERC20 token,
        address spender,
        uint256 value
    ) internal {
        // safeApprove should only be called when setting an initial allowance,
        // or when resetting it to zero. To increase and decrease it, use
        // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
        // solhint-disable-next-line max-line-length
        require(
            (value == 0) || (token.allowance(address(this), spender) == 0),
            "SafeERC20: approve from non-zero to non-zero allowance"
        );
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
    }

    /**
     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
     * on the return value: the return value is optional (but if data is returned, it must not be false).
     * @param token The token targeted by the call.
     * @param data The call data (encoded using abi.encode or one of its variants).
     */
    function _callOptionalReturn(IERC20 token, bytes memory data) private {
        // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
        // we're implementing it ourselves.

        // A Solidity high level call has three parts:
        //  1. The target address is checked to verify it contains contract code
        //  2. The call itself is made, and success asserted
        //  3. The return value is decoded, which in turn checks the size of the returned data.
        // solhint-disable-next-line max-line-length

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = address(token).call(data);
        require(success, "SafeERC20: low-level call failed");

        if (returndata.length > 0) {
            // Return data is optional
            // solhint-disable-next-line max-line-length
            require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
        }
    }
}

// File: contracts/lib/DecimalMath.sol


/**
 * @title DecimalMath
 * @author DODO Breeder
 *
 * @notice Functions for fixed point number with 18 decimals
 */
library DecimalMath {
    using SafeMath for uint256;

    uint256 internal constant ONE = 10**18;
    uint256 internal constant ONE2 = 10**36;

    function mulFloor(uint256 target, uint256 d) internal pure returns (uint256) {
        return target.mul(d) / (10**18);
    }

    function mulCeil(uint256 target, uint256 d) internal pure returns (uint256) {
        return target.mul(d).divCeil(10**18);
    }

    function divFloor(uint256 target, uint256 d) internal pure returns (uint256) {
        return target.mul(10**18).div(d);
    }

    function divCeil(uint256 target, uint256 d) internal pure returns (uint256) {
        return target.mul(10**18).divCeil(d);
    }

    function reciprocalFloor(uint256 target) internal pure returns (uint256) {
        return uint256(10**36).div(target);
    }

    function reciprocalCeil(uint256 target) internal pure returns (uint256) {
        return uint256(10**36).divCeil(target);
    }
}

// File: contracts/lib/ReentrancyGuard.sol


/**
 * @title ReentrancyGuard
 * @author DODO Breeder
 *
 * @notice Protect functions from Reentrancy Attack
 */
contract ReentrancyGuard {
    // https://solidity.readthedocs.io/en/latest/control-structures.html?highlight=zero-state#scoping-and-declarations
    // zero-state of _ENTERED_ is false
    bool private _ENTERED_;

    modifier preventReentrant() {
        require(!_ENTERED_, "REENTRANT");
        _ENTERED_ = true;
        _;
        _ENTERED_ = false;
    }
}

// File: contracts/DODOStablePool/intf/IDSP.sol


interface IDSP {
    function init(
        address maintainer,
        address baseTokenAddress,
        address quoteTokenAddress,
        uint256 lpFeeRate,
        address mtFeeRateModel,
        uint256 i,
        uint256 k,
        bool isOpenTWAP
    ) external;

    function _BASE_TOKEN_() external view returns (address);

    function _QUOTE_TOKEN_() external view returns (address);

    function _I_() external view returns (uint256);

    function _MT_FEE_RATE_MODEL_() external view returns (address);

    function getVaultReserve() external view returns (uint256 baseReserve, uint256 quoteReserve);

    function sellBase(address to) external returns (uint256);

    function sellQuote(address to) external returns (uint256);

    function buyShares(address to) external returns (uint256,uint256,uint256);
}

// File: contracts/lib/CloneFactory.sol


interface ICloneFactory {
    function clone(address prototype) external returns (address proxy);
}

// introduction of proxy mode design: https://docs.openzeppelin.com/upgrades/2.8/
// minimum implementation of transparent proxy: https://eips.ethereum.org/EIPS/eip-1167

contract CloneFactory is ICloneFactory {
    function clone(address prototype) external override returns (address proxy) {
        bytes20 targetBytes = bytes20(prototype);
        assembly {
            let clone := mload(0x40)
            mstore(clone, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)
            mstore(add(clone, 0x14), targetBytes)
            mstore(
                add(clone, 0x28),
                0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000
            )
            proxy := create(0, clone, 0x37)
        }
        return proxy;
    }
}

// File: contracts/Factory/DSPFactory.sol



interface IDSPFactory {
    function createDODOStablePool(
        address baseToken,
        address quoteToken,
        uint256 lpFeeRate,
        uint256 i,
        uint256 k,
        bool isOpenTWAP
    ) external returns (address newStablePool);
}

/**
 * @title DODO StablePool Factory
 * @author DODO Breeder
 *
 * @notice Create And Register DSP Pools
 */
contract DSPFactory is InitializableOwnable {
    // ============ Templates ============

    address public immutable _CLONE_FACTORY_;
    address public immutable _DEFAULT_MAINTAINER_;
    address public immutable _DEFAULT_MT_FEE_RATE_MODEL_;
    address public _DSP_TEMPLATE_;

    // ============ Registry ============

    // base -> quote -> DSP address list
    mapping(address => mapping(address => address[])) public _REGISTRY_;
    // creator -> DSP address list
    mapping(address => address[]) public _USER_REGISTRY_;

    // ============ Events ============

    event NewDSP(address baseToken, address quoteToken, address creator, address DSP);

    event RemoveDSP(address DSP);

    // ============ Functions ============

    constructor(
        address cloneFactory,
        address DSPTemplate,
        address defaultMaintainer,
        address defaultMtFeeRateModel
    ) public {
        _CLONE_FACTORY_ = cloneFactory;
        _DSP_TEMPLATE_ = DSPTemplate;
        _DEFAULT_MAINTAINER_ = defaultMaintainer;
        _DEFAULT_MT_FEE_RATE_MODEL_ = defaultMtFeeRateModel;
    }

    function createDODOStablePool(
        address baseToken,
        address quoteToken,
        uint256 lpFeeRate,
        uint256 i,
        uint256 k,
        bool isOpenTWAP
    ) external returns (address newStablePool) {
        newStablePool = ICloneFactory(_CLONE_FACTORY_).clone(_DSP_TEMPLATE_);
        {
            IDSP(newStablePool).init(
                _DEFAULT_MAINTAINER_,
                baseToken,
                quoteToken,
                lpFeeRate,
                _DEFAULT_MT_FEE_RATE_MODEL_,
                i,
                k,
                isOpenTWAP
            );
        }
        _REGISTRY_[baseToken][quoteToken].push(newStablePool);
        _USER_REGISTRY_[tx.origin].push(newStablePool);
        emit NewDSP(baseToken, quoteToken, tx.origin, newStablePool);
    }

    // ============ Admin Operation Functions ============

    function updateDSPTemplate(address _newDSPTemplate) external onlyOwner {
        _DSP_TEMPLATE_ = _newDSPTemplate;
    }

    function addPoolByAdmin(
        address creator,
        address baseToken,
        address quoteToken,
        address pool
    ) external onlyOwner {
        _REGISTRY_[baseToken][quoteToken].push(pool);
        _USER_REGISTRY_[creator].push(pool);
        emit NewDSP(baseToken, quoteToken, creator, pool);
    }

    function removePoolByAdmin(
        address creator,
        address baseToken,
        address quoteToken,
        address pool
    ) external onlyOwner {
        address[] memory registryList = _REGISTRY_[baseToken][quoteToken];
        for (uint256 i = 0; i < registryList.length; i++) {
            if (registryList[i] == pool) {
                registryList[i] = registryList[registryList.length - 1];
                break;
            }
        }
        _REGISTRY_[baseToken][quoteToken] = registryList;
        _REGISTRY_[baseToken][quoteToken].pop();
        address[] memory userRegistryList = _USER_REGISTRY_[creator];
        for (uint256 i = 0; i < userRegistryList.length; i++) {
            if (userRegistryList[i] == pool) {
                userRegistryList[i] = userRegistryList[userRegistryList.length - 1];
                break;
            }
        }
        _USER_REGISTRY_[creator] = userRegistryList;
        _USER_REGISTRY_[creator].pop();
        emit RemoveDSP(pool);
    }

    // ============ View Functions ============

    function getDODOPool(address baseToken, address quoteToken)
        external
        view
        returns (address[] memory machines)
    {
        return _REGISTRY_[baseToken][quoteToken];
    }

    function getDODOPoolBidirection(address token0, address token1)
        external
        view
        returns (address[] memory baseToken0Machines, address[] memory baseToken1Machines)
    {
        return (_REGISTRY_[token0][token1], _REGISTRY_[token1][token0]);
    }

    function getDODOPoolByUser(address user) external view returns (address[] memory machines) {
        return _USER_REGISTRY_[user];
    }
}

// File: contracts/SmartRoute/proxies/DODODspProxy.sol





/**
 * @title DODODspProxy
 * @author DODO Breeder
 *
 * @notice Entrance of DODO Stable Pair in DODO platform
 */
contract DODODspProxy is ReentrancyGuard {
    using SafeMath for uint256;

    // ============ Storage ============

    address constant _ETH_ADDRESS_ = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE;
    address public immutable _WETH_;
    address public immutable _DODO_APPROVE_PROXY_;
    address public immutable _DSP_FACTORY_;

    // ============ Modifiers ============

    modifier judgeExpired(uint256 deadLine) {
        require(deadLine >= block.timestamp, "DODODspProxy: EXPIRED");
        _;
    }

    fallback() external payable {}

    receive() external payable {}

    constructor(
        address dspFactory,
        address payable weth,
        address dodoApproveProxy
    ) public {
        _DSP_FACTORY_ = dspFactory;
        _WETH_ = weth;
        _DODO_APPROVE_PROXY_ = dodoApproveProxy;
    }

    // ============ DSP Functions (create & add liquidity) ============

    function createDODOStablePair(
        address baseToken,
        address quoteToken,
        uint256 baseInAmount,
        uint256 quoteInAmount,
        uint256 lpFeeRate,
        uint256 i,
        uint256 k,
        bool isOpenTWAP,
        uint256 deadLine
    )
        external
        payable
        preventReentrant
        judgeExpired(deadLine)
        returns (address newDODOStablePair, uint256 shares)
    {
        {
            address _baseToken = baseToken == _ETH_ADDRESS_ ? _WETH_ : baseToken;
            address _quoteToken = quoteToken == _ETH_ADDRESS_ ? _WETH_ : quoteToken;
            newDODOStablePair = IDSPFactory(_DSP_FACTORY_).createDODOStablePool(
                _baseToken,
                _quoteToken,
                lpFeeRate,
                i,
                k,
                isOpenTWAP
            );
        }

        {
            address _baseToken = baseToken;
            address _quoteToken = quoteToken;
            _deposit(
                msg.sender,
                newDODOStablePair,
                _baseToken,
                baseInAmount,
                _baseToken == _ETH_ADDRESS_
            );
            _deposit(
                msg.sender,
                newDODOStablePair,
                _quoteToken,
                quoteInAmount,
                _quoteToken == _ETH_ADDRESS_
            );
        }

        (shares, , ) = IDSP(newDODOStablePair).buyShares(msg.sender);
    }

    function addDSPLiquidity(
        address dspAddress,
        uint256 baseInAmount,
        uint256 quoteInAmount,
        uint256 baseMinAmount,
        uint256 quoteMinAmount,
        uint8 flag, // 0 - ERC20, 1 - baseInETH, 2 - quoteInETH
        uint256 deadLine
    )
        external
        payable
        preventReentrant
        judgeExpired(deadLine)
        returns (
            uint256 shares,
            uint256 baseAdjustedInAmount,
            uint256 quoteAdjustedInAmount
        )
    {
        address _dsp = dspAddress;
        (baseAdjustedInAmount, quoteAdjustedInAmount) = _addDSPLiquidity(
            _dsp,
            baseInAmount,
            quoteInAmount
        );
        require(
            baseAdjustedInAmount >= baseMinAmount && quoteAdjustedInAmount >= quoteMinAmount,
            "DODODspProxy: deposit amount is not enough"
        );

        _deposit(msg.sender, _dsp, IDSP(_dsp)._BASE_TOKEN_(), baseAdjustedInAmount, flag == 1);
        _deposit(msg.sender, _dsp, IDSP(_dsp)._QUOTE_TOKEN_(), quoteAdjustedInAmount, flag == 2);
        
        (shares, , ) = IDSP(_dsp).buyShares(msg.sender);

        // refund dust eth
        if (flag == 1 && msg.value > baseAdjustedInAmount) msg.sender.transfer(msg.value - baseAdjustedInAmount);
        if (flag == 2 && msg.value > quoteAdjustedInAmount) msg.sender.transfer(msg.value - quoteAdjustedInAmount);
    }


    // =================== internal functions =====================

    function _addDSPLiquidity(
        address dspAddress,
        uint256 baseInAmount,
        uint256 quoteInAmount
    ) internal view returns (uint256 baseAdjustedInAmount, uint256 quoteAdjustedInAmount) {
        (uint256 baseReserve, uint256 quoteReserve) = IDSP(dspAddress).getVaultReserve();
        if (quoteReserve == 0 && baseReserve == 0) {
            uint256 i = IDSP(dspAddress)._I_();
            uint256 shares = quoteInAmount < DecimalMath.mulFloor(baseInAmount, i)
                ? DecimalMath.divFloor(quoteInAmount, i)
                : baseInAmount;
            baseAdjustedInAmount = shares;
            quoteAdjustedInAmount = DecimalMath.mulFloor(shares, i);
        }
        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);
            }
        }
    }

    function _deposit(
        address from,
        address to,
        address token,
        uint256 amount,
        bool isETH
    ) internal {
        if (isETH) {
            if (amount > 0) {
                IWETH(_WETH_).deposit{value: amount}();
                if (to != address(this)) SafeERC20.safeTransfer(IERC20(_WETH_), to, amount);
            }
        } else {
            IDODOApproveProxy(_DODO_APPROVE_PROXY_).claimTokens(token, from, to, amount);
        }
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"dspFactory","type":"address"},{"internalType":"address payable","name":"weth","type":"address"},{"internalType":"address","name":"dodoApproveProxy","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"stateMutability":"payable","type":"fallback"},{"inputs":[],"name":"_DODO_APPROVE_PROXY_","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"_DSP_FACTORY_","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"_WETH_","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"dspAddress","type":"address"},{"internalType":"uint256","name":"baseInAmount","type":"uint256"},{"internalType":"uint256","name":"quoteInAmount","type":"uint256"},{"internalType":"uint256","name":"baseMinAmount","type":"uint256"},{"internalType":"uint256","name":"quoteMinAmount","type":"uint256"},{"internalType":"uint8","name":"flag","type":"uint8"},{"internalType":"uint256","name":"deadLine","type":"uint256"}],"name":"addDSPLiquidity","outputs":[{"internalType":"uint256","name":"shares","type":"uint256"},{"internalType":"uint256","name":"baseAdjustedInAmount","type":"uint256"},{"internalType":"uint256","name":"quoteAdjustedInAmount","type":"uint256"}],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"baseToken","type":"address"},{"internalType":"address","name":"quoteToken","type":"address"},{"internalType":"uint256","name":"baseInAmount","type":"uint256"},{"internalType":"uint256","name":"quoteInAmount","type":"uint256"},{"internalType":"uint256","name":"lpFeeRate","type":"uint256"},{"internalType":"uint256","name":"i","type":"uint256"},{"internalType":"uint256","name":"k","type":"uint256"},{"internalType":"bool","name":"isOpenTWAP","type":"bool"},{"internalType":"uint256","name":"deadLine","type":"uint256"}],"name":"createDODOStablePair","outputs":[{"internalType":"address","name":"newDODOStablePair","type":"address"},{"internalType":"uint256","name":"shares","type":"uint256"}],"stateMutability":"payable","type":"function"},{"stateMutability":"payable","type":"receive"}]

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

00000000000000000000000043c49f8dd240e1545f147211ec9f917376ac1e870000000000000000000000000d500b1d8e8ef31e21c99d1db9a6444d3adf127000000000000000000000000001feea29da5ae41b0b5f6b10b93ee34752ef80d7

-----Decoded View---------------
Arg [0] : dspFactory (address): 0x43C49f8DD240e1545F147211Ec9f917376Ac1e87
Arg [1] : weth (address): 0x0d500B1d8E8eF31E21C99d1Db9A6444d3ADf1270
Arg [2] : dodoApproveProxy (address): 0x01FEEA29da5Ae41B0b5F6b10b93EE34752eF80d7

-----Encoded View---------------
3 Constructor Arguments found :
Arg [0] : 00000000000000000000000043c49f8dd240e1545f147211ec9f917376ac1e87
Arg [1] : 0000000000000000000000000d500b1d8e8ef31e21c99d1db9a6444d3adf1270
Arg [2] : 00000000000000000000000001feea29da5ae41b0b5f6b10b93ee34752ef80d7

20206:5818:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;20415:31;;;;;;;;;;;;;:::i;:::-;;;;-1:-1:-1;;;;;20415:31:0;;;;;;;;;;;;;;21136:1499;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;21136:1499:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;-1:-1:-1;;;;;21136:1499:0;;;;;;;;;;;;;;;;;;;;;22643:1439;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;22643:1439:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;20453:45;;;;;;;;;;;;;:::i;20505:38::-;;;;;;;;;;;;;:::i;20415:31::-;;;:::o;21136:1499::-;21525:25;13408:9;;21525:25;;13408:9;;13407:10;13399:32;;;;;-1:-1:-1;;;13399:32:0;;;;;;;;;;;;-1:-1:-1;;;13399:32:0;;;;;;;;;;;;;;;13442:9;:16;;-1:-1:-1;;13442:16:0;13454:4;13442:16;;;21497:8;20669:15:::1;20657:27:::0;::::1;;20649:61;;;::::0;;-1:-1:-1;;;20649:61:0;;::::1;;::::0;::::1;::::0;::::1;::::0;;;;-1:-1:-1;;;20649:61:0;;;;;;;;;;;;;::::1;;21599:18:::2;-1:-1:-1::0;;;;;21620:26:0;::::2;20366:42;21620:26;:47;;21658:9;21620:47;;;21649:6;21620:47;21599:68:::0;-1:-1:-1;21682:19:0::2;-1:-1:-1::0;;;;;21704:27:0;::::2;20366:42;21704:27;:49;;21743:10;21704:49;;;21734:6;21704:49;21788:218;::::0;;-1:-1:-1;;;21788:218:0;;-1:-1:-1;;;;;21788:218:0;;::::2;;::::0;::::2;::::0;;;::::2;::::0;;;;;;;;;;;;;;;;;;;;;;;::::2;;::::0;;;;;;;;-1:-1:-1;21800:13:0::2;21788:47:::0;;::::2;::::0;::::2;::::0;:218;;;;;::::2;::::0;;;;;;;;;-1:-1:-1;21788:47:0;:218;::::2;;::::0;::::2;;;;::::0;::::2;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;;;::::0;::::2;;-1:-1:-1::0;21788:218:0;;-1:-1:-1;22066:9:0;;-1:-1:-1;22112:10:0;;-1:-1:-1;22137:194:0::2;22164:10;21788:218:::0;22066:9;22258:12;-1:-1:-1;;;;;22289:27:0;::::2;20366:42;22289:27;22137:8;:194::i;:::-;22346:197;22373:10;22402:17:::0;22438:11;22468:13;-1:-1:-1;;;;;22500:28:0;::::2;20366:42;22500:28;22346:8;:197::i;:::-;-1:-1:-1::0;;22582:45:0::2;::::0;;-1:-1:-1;;;22582:45:0;;22616:10:::2;22582:45;::::0;::::2;::::0;;;-1:-1:-1;;;;;22582:33:0;::::2;::::0;::::2;::::0;:45;;;;;::::2;::::0;;;;;;;;-1:-1:-1;22582:33:0;:45;::::2;;::::0;::::2;;;;::::0;::::2;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;;;::::0;::::2;;-1:-1:-1::0;22582:45:0;13493:5;13481:17;;-1:-1:-1;;13481:17:0;;;21136:1499;;22582:45;;-1:-1:-1;21136:1499:0;;-1:-1:-1;;;;;;;;;;21136:1499:0:o;22643:1439::-;23049:14;13408:9;;23049:14;;;;13408:9;;13407:10;13399:32;;;;;-1:-1:-1;;;13399:32:0;;;;;;;;;;;;-1:-1:-1;;;13399:32:0;;;;;;;;;;;;;;;13442:9;:16;;-1:-1:-1;;13442:16:0;13454:4;13442:16;;;23007:8;20669:15:::1;20657:27:::0;::::1;;20649:61;;;::::0;;-1:-1:-1;;;20649:61:0;;::::1;;::::0;::::1;::::0;::::1;::::0;;;;-1:-1:-1;;;20649:61:0;;;;;;;;;;;;;::::1;;23193:10:::0;23262:101:::2;23193:10:::0;23312:12;23339:13;23262:16:::2;:101::i;:::-;23214:149:::0;;-1:-1:-1;23214:149:0;-1:-1:-1;23396:37:0;;::::2;::::0;::::2;::::0;:80:::2;;;23462:14;23437:21;:39;;23396:80;23374:172;;;;-1:-1:-1::0;;;23374:172:0::2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23559:86;23568:10;23580:4;23591;-1:-1:-1::0;;;;;23586:23:0::2;;:25;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;;;::::0;::::2;;-1:-1:-1::0;23586:25:0;23613:20;23643:1:::2;23635:9;::::0;::::2;;23559:8;:86::i;:::-;23656:88;23665:10;23677:4;23688;-1:-1:-1::0;;;;;23683:24:0::2;;:26;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;;;::::0;::::2;;-1:-1:-1::0;23683:26:0;23711:21;23742:1:::2;23734:9;::::0;::::2;;23656:8;:88::i;:::-;23780:32;::::0;;-1:-1:-1;;;23780:32:0;;23801:10:::2;23780:32;::::0;::::2;::::0;;;-1:-1:-1;;;;;23780:20:0;::::2;::::0;::::2;::::0;:32;;;;;::::2;::::0;;;;;;;;-1:-1:-1;23780:20:0;:32;::::2;;::::0;::::2;;;;::::0;::::2;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;;;::::0;::::2;;-1:-1:-1::0;23780:32:0;;-1:-1:-1;23865:1:0::2;23857:9;::::0;::::2;;:45:::0;::::2;;;;23882:20;23870:9;:32;23857:45;23853:104;;;23904:53;::::0;:10:::2;::::0;23924:9:::2;:32:::0;;::::2;23904:53:::0;::::2;;;::::0;::::2;::::0;;;23924:32;23904:10;:53;::::2;;;;;;;;;;;;;::::0;::::2;;;;;;23853:104;23972:4;:9;;23980:1;23972:9;:46;;;;;23997:21;23985:9;:33;23972:46;23968:106;;;24020:54;::::0;:10:::2;::::0;24040:9:::2;:33:::0;;::::2;24020:54:::0;::::2;;;::::0;::::2;::::0;;;24040:33;24020:10;:54;::::2;;;;;;;;;;;;;::::0;::::2;;;;;;23968:106;-1:-1:-1::0;;13493:5:0;13481:17;;-1:-1:-1;;13481:17:0;;;22643:1439;;;;-1:-1:-1;22643:1439:0;;-1:-1:-1;22643:1439:0;-1:-1:-1;;;;;22643:1439:0:o;20453:45::-;;;:::o;20505:38::-;;;:::o;25526:495::-;25689:5;25685:329;;;25715:10;;25711:183;;25752:6;-1:-1:-1;;;;;25746:21:0;;25775:6;25746:38;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;25807:19:0;;25821:4;25807:19;;-1:-1:-1;25803:75:0;;25828:50;25858:6;25867:2;25871:6;25828:22;:50::i;:::-;25685:329;;;25926:76;;;-1:-1:-1;;;25926:76:0;;-1:-1:-1;;;;;25926:76:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;25944:20;25926:51;;;;;;:76;;;;;-1:-1:-1;;25926:76:0;;;;;;;;-1:-1:-1;25926:51:0;:76;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;25685:329;25526:495;;;;;:::o;24163:1355::-;24311:28;24341:29;24384:19;24405:20;24434:10;-1:-1:-1;;;;;24429:32:0;;:34;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;24429:34:0;;;;;;;;;-1:-1:-1;24429:34:0;-1:-1:-1;24478:17:0;;:37;;;;-1:-1:-1;24499:16:0;;24478:37;24474:393;;;24532:9;24549:10;-1:-1:-1;;;;;24544:20:0;;:22;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;24544:22:0;;-1:-1:-1;24581:14:0;24614:37;24635:12;24544:22;24614:20;:37::i;:::-;24598:13;:53;:143;;24729:12;24598:143;;;24671:38;24692:13;24707:1;24671:20;:38::i;:::-;24581:160;;24779:6;24756:29;;24824:31;24845:6;24853:1;24824:20;:31::i;:::-;24800:55;;24474:393;;;24896:1;24881:12;:16;:35;;;;;24915:1;24901:11;:15;24881:35;24877:634;;;24933:25;24961:47;24982:12;24996:11;24961:20;:47::i;:::-;24933:75;;25023:26;25052:49;25073:13;25088:12;25052:20;:49::i;:::-;25023:78;;25141:18;25120:17;:39;25116:384;;25203:12;25180:35;;25258:53;25279:12;25293:17;25258:20;:53::i;:::-;25234:77;;25116:384;;;25376:13;25352:37;;25431:53;25452:11;25465:18;25431:20;:53::i;:::-;25408:76;;25116:384;24877:634;;;24163:1355;;;;;;;;:::o;9201:211::-;9345:58;;;-1:-1:-1;;;;;9345:58:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;9345:58:0;-1:-1:-1;;;9345:58:0;;;9318:86;;9338:5;;9318:19;:86::i;:::-;9201:211;;;:::o;12150:127::-;12218:7;12262:6;12245:13;:6;12256:1;12245:13;:10;:13;:::i;:::-;:24;;;;;;12238:31;;12150:127;;;;;:::o;12424:128::-;12492:7;12519:25;12542:1;12519:18;:6;12530;12519:18;:10;:18;:::i;:::-;:22;:25;:22;:25;:::i;:::-;12512:32;12424:128;-1:-1:-1;;;12424:128:0:o;10774:1046::-;11434:12;11448:23;11483:5;-1:-1:-1;;;;;11475:19:0;11495:4;11475:25;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;11475:25:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;11433:67;;;;11519:7;11511:52;;;;;-1:-1:-1;;;11511:52:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;11580:17;;:21;11576:237;;11735:10;11724:30;;;;;;;;;;;;;;;-1:-1:-1;11724:30:0;11716:85;;;;-1:-1:-1;;;11716:85:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;10774:1046;;;;:::o;7426:226::-;7484:7;7508:6;7504:47;;-1:-1:-1;7538:1:0;7531:8;;7504:47;7575:5;;;7579:1;7575;:5;:1;7599:5;;;;;:10;7591:32;;;;;-1:-1:-1;;;7591:32:0;;;;;;;;;;;;-1:-1:-1;;;7591:32:0;;;;;;;;;;;;;;7660:141;7718:7;7750:1;7746;:5;7738:32;;;;;-1:-1:-1;;;7738:32:0;;;;;;;;;;;;-1:-1:-1;;;7738:32:0;;;;;;;;;;;;;;;7792:1;7788;:5;;;

ipfs://8d51889f52326d097ac1b39cac749a910c84c7ab5476eae7b0fcbcac0de8a2a2