Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta

More Options

• Similar
• Submit Audit
• Compare

/**
 *Submitted for verification at Arbiscan.io on 2021-08-30
*/

// 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_MT_FEE_RATE_MODEL_;
    address public _DEFAULT_MAINTAINER_;
    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 updateDefaultMaintainer(address _newMaintainer) external onlyOwner {
        _DEFAULT_MAINTAINER_ = _newMaintainer;
    }

    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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

000000000000000000000000c8fe2440744dcd733246a4db14093664defd5a5300000000000000000000000082af49447d8a07e3bd95bd0d56f35241523fbab1000000000000000000000000311e670c3305a0bd55184c1c6580ebea1fa611f0

-----Decoded View---------------
Arg [0] : dspFactory (address): 0xC8fE2440744dcd733246a4dB14093664DEFD5A53
Arg [1] : weth (address): 0x82aF49447D8a07e3bd95BD0d56f35241523fBab1
Arg [2] : dodoApproveProxy (address): 0x311E670c3305a0BD55184c1C6580eBeA1FA611F0

-----Encoded View---------------
3 Constructor Arguments found :
Arg [0] : 000000000000000000000000c8fe2440744dcd733246a4db14093664defd5a53
Arg [1] : 00000000000000000000000082af49447d8a07e3bd95bd0d56f35241523fbab1
Arg [2] : 000000000000000000000000311e670c3305a0bd55184c1c6580ebea1fa611f0

20328:5818:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;20537:31;;;;;;;;;;;;;:::i;:::-;;;;-1:-1:-1;;;;;20537:31:0;;;;;;;;;;;;;;21258:1499;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;21258:1499:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;-1:-1:-1;;;;;21258:1499:0;;;;;;;;;;;;;;;;;;;;;22765:1439;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;22765:1439:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;20575:45;;;;;;;;;;;;;:::i;20627:38::-;;;;;;;;;;;;;:::i;20537:31::-;;;:::o;21258:1499::-;21647:25;13404:9;;21647:25;;13404:9;;13403:10;13395:32;;;;;-1:-1:-1;;;13395:32:0;;;;;;;;;;;;-1:-1:-1;;;13395:32:0;;;;;;;;;;;;;;;13438:9;:16;;-1:-1:-1;;13438:16:0;13450:4;13438:16;;;21619:8;20791:15:::1;20779:27:::0;::::1;;20771:61;;;::::0;;-1:-1:-1;;;20771:61:0;;::::1;;::::0;::::1;::::0;::::1;::::0;;;;-1:-1:-1;;;20771:61:0;;;;;;;;;;;;;::::1;;21721:18:::2;-1:-1:-1::0;;;;;21742:26:0;::::2;20488:42;21742:26;:47;;21780:9;21742:47;;;21771:6;21742:47;21721:68:::0;-1:-1:-1;21804:19:0::2;-1:-1:-1::0;;;;;21826:27:0;::::2;20488:42;21826:27;:49;;21865:10;21826:49;;;21856:6;21826:49;21910:218;::::0;;-1:-1:-1;;;21910:218:0;;-1:-1:-1;;;;;21910:218:0;;::::2;;::::0;::::2;::::0;;;::::2;::::0;;;;;;;;;;;;;;;;;;;;;;;::::2;;::::0;;;;;;;;-1:-1:-1;21922:13:0::2;21910:47:::0;;::::2;::::0;::::2;::::0;:218;;;;;::::2;::::0;;;;;;;;;-1:-1:-1;21910:47:0;:218;::::2;;::::0;::::2;;;;::::0;::::2;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;;;::::0;::::2;;-1:-1:-1::0;21910:218:0;;-1:-1:-1;22188:9:0;;-1:-1:-1;22234:10:0;;-1:-1:-1;22259:194:0::2;22286:10;21910:218:::0;22188:9;22380:12;-1:-1:-1;;;;;22411:27:0;::::2;20488:42;22411:27;22259:8;:194::i;:::-;22468:197;22495:10;22524:17:::0;22560:11;22590:13;-1:-1:-1;;;;;22622:28:0;::::2;20488:42;22622:28;22468:8;:197::i;:::-;-1:-1:-1::0;;22704:45:0::2;::::0;;-1:-1:-1;;;22704:45:0;;22738:10:::2;22704:45;::::0;::::2;::::0;;;-1:-1:-1;;;;;22704:33:0;::::2;::::0;::::2;::::0;:45;;;;;::::2;::::0;;;;;;;;-1:-1:-1;22704:33:0;:45;::::2;;::::0;::::2;;;;::::0;::::2;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;;;::::0;::::2;;-1:-1:-1::0;22704:45:0;13489:5;13477:17;;-1:-1:-1;;13477:17:0;;;21258:1499;;22704:45;;-1:-1:-1;21258:1499:0;;-1:-1:-1;;;;;;;;;;21258:1499:0:o;22765:1439::-;23171:14;13404:9;;23171:14;;;;13404:9;;13403:10;13395:32;;;;;-1:-1:-1;;;13395:32:0;;;;;;;;;;;;-1:-1:-1;;;13395:32:0;;;;;;;;;;;;;;;13438:9;:16;;-1:-1:-1;;13438:16:0;13450:4;13438:16;;;23129:8;20791:15:::1;20779:27:::0;::::1;;20771:61;;;::::0;;-1:-1:-1;;;20771:61:0;;::::1;;::::0;::::1;::::0;::::1;::::0;;;;-1:-1:-1;;;20771:61:0;;;;;;;;;;;;;::::1;;23315:10:::0;23384:101:::2;23315:10:::0;23434:12;23461:13;23384:16:::2;:101::i;:::-;23336:149:::0;;-1:-1:-1;23336:149:0;-1:-1:-1;23518:37:0;;::::2;::::0;::::2;::::0;:80:::2;;;23584:14;23559:21;:39;;23518:80;23496:172;;;;-1:-1:-1::0;;;23496:172:0::2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23681:86;23690:10;23702:4;23713;-1:-1:-1::0;;;;;23708:23:0::2;;:25;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;;;::::0;::::2;;-1:-1:-1::0;23708:25:0;23735:20;23765:1:::2;23757:9;::::0;::::2;;23681:8;:86::i;:::-;23778:88;23787:10;23799:4;23810;-1:-1:-1::0;;;;;23805:24:0::2;;:26;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;;;::::0;::::2;;-1:-1:-1::0;23805:26:0;23833:21;23864:1:::2;23856:9;::::0;::::2;;23778:8;:88::i;:::-;23902:32;::::0;;-1:-1:-1;;;23902:32:0;;23923:10:::2;23902:32;::::0;::::2;::::0;;;-1:-1:-1;;;;;23902:20:0;::::2;::::0;::::2;::::0;:32;;;;;::::2;::::0;;;;;;;;-1:-1:-1;23902:20:0;:32;::::2;;::::0;::::2;;;;::::0;::::2;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;;;::::0;::::2;;-1:-1:-1::0;23902:32:0;;-1:-1:-1;23987:1:0::2;23979:9;::::0;::::2;;:45:::0;::::2;;;;24004:20;23992:9;:32;23979:45;23975:104;;;24026:53;::::0;:10:::2;::::0;24046:9:::2;:32:::0;;::::2;24026:53:::0;::::2;;;::::0;::::2;::::0;;;24046:32;24026:10;:53;::::2;;;;;;;;;;;;;::::0;::::2;;;;;;23975:104;24094:4;:9;;24102:1;24094:9;:46;;;;;24119:21;24107:9;:33;24094:46;24090:106;;;24142:54;::::0;:10:::2;::::0;24162:9:::2;:33:::0;;::::2;24142:54:::0;::::2;;;::::0;::::2;::::0;;;24162:33;24142:10;:54;::::2;;;;;;;;;;;;;::::0;::::2;;;;;;24090:106;-1:-1:-1::0;;13489:5:0;13477:17;;-1:-1:-1;;13477:17:0;;;22765:1439;;;;-1:-1:-1;22765:1439:0;;-1:-1:-1;22765:1439:0;-1:-1:-1;;;;;22765:1439:0:o;20575:45::-;;;:::o;20627:38::-;;;:::o;25648:495::-;25811:5;25807:329;;;25837:10;;25833:183;;25874:6;-1:-1:-1;;;;;25868:21:0;;25897:6;25868:38;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;25929:19:0;;25943:4;25929:19;;-1:-1:-1;25925:75:0;;25950:50;25980:6;25989:2;25993:6;25950:22;:50::i;:::-;25807:329;;;26048:76;;;-1:-1:-1;;;26048:76:0;;-1:-1:-1;;;;;26048:76:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;26066:20;26048:51;;;;;;:76;;;;;-1:-1:-1;;26048:76:0;;;;;;;;-1:-1:-1;26048:51:0;:76;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;25807:329;25648:495;;;;;:::o;24285:1355::-;24433:28;24463:29;24506:19;24527:20;24556:10;-1:-1:-1;;;;;24551:32:0;;:34;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;24551:34:0;;;;;;;;;-1:-1:-1;24551:34:0;-1:-1:-1;24600:17:0;;:37;;;;-1:-1:-1;24621:16:0;;24600:37;24596:393;;;24654:9;24671:10;-1:-1:-1;;;;;24666:20:0;;:22;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;24666:22:0;;-1:-1:-1;24703:14:0;24736:37;24757:12;24666:22;24736:20;:37::i;:::-;24720:13;:53;:143;;24851:12;24720:143;;;24793:38;24814:13;24829:1;24793:20;:38::i;:::-;24703:160;;24901:6;24878:29;;24946:31;24967:6;24975:1;24946:20;:31::i;:::-;24922:55;;24596:393;;;25018:1;25003:12;:16;:35;;;;;25037:1;25023:11;:15;25003:35;24999:634;;;25055:25;25083:47;25104:12;25118:11;25083:20;:47::i;:::-;25055:75;;25145:26;25174:49;25195:13;25210:12;25174:20;:49::i;:::-;25145:78;;25263:18;25242:17;:39;25238:384;;25325:12;25302:35;;25380:53;25401:12;25415:17;25380:20;:53::i;:::-;25356:77;;25238:384;;;25498:13;25474:37;;25553:53;25574:11;25587:18;25553:20;:53::i;:::-;25530:76;;25238:384;24999:634;;;24285:1355;;;;;;;;:::o;9197:211::-;9341:58;;;-1:-1:-1;;;;;9341:58:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;9341:58:0;-1:-1:-1;;;9341:58:0;;;9314:86;;9334:5;;9314:19;:86::i;:::-;9197:211;;;:::o;12146:127::-;12214:7;12258:6;12241:13;:6;12252:1;12241:13;:10;:13;:::i;:::-;:24;;;;;;12234:31;;12146:127;;;;;:::o;12420:128::-;12488:7;12515:25;12538:1;12515:18;:6;12526;12515:18;:10;:18;:::i;:::-;:22;:25;:22;:25;:::i;:::-;12508:32;12420:128;-1:-1:-1;;;12420:128:0:o;10770:1046::-;11430:12;11444:23;11479:5;-1:-1:-1;;;;;11471:19:0;11491:4;11471:25;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;11471:25:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;11429:67;;;;11515:7;11507:52;;;;;-1:-1:-1;;;11507:52:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;11576:17;;:21;11572:237;;11731:10;11720:30;;;;;;;;;;;;;;;-1:-1:-1;11720:30:0;11712:85;;;;-1:-1:-1;;;11712:85:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;10770:1046;;;;:::o;7424:226::-;7482:7;7506:6;7502:47;;-1:-1:-1;7536:1:0;7529:8;;7502:47;7573:5;;;7577:1;7573;:5;:1;7597:5;;;;;:10;7589:32;;;;;-1:-1:-1;;;7589:32:0;;;;;;;;;;;;-1:-1:-1;;;7589:32:0;;;;;;;;;;;;;;7658:141;7716:7;7748:1;7744;:5;7736:32;;;;;-1:-1:-1;;;7736:32:0;;;;;;;;;;;;-1:-1:-1;;;7736:32:0;;;;;;;;;;;;;;;7790:1;7786;:5;;;

ipfs://682a6e06aafa710ef8913041876dab17bdc543dc8f4174dee4a624f973b18c91