first commit

contracts/lib/DODOMath.sol

@@ -0,0 +1,117 @@
+/*
+
+    Copyright 2020 DODO ZOO.
+    SPDX-License-Identifier: Apache-2.0
+
+*/
+
+pragma solidity 0.6.9;
+pragma experimental ABIEncoderV2;
+
+import {SafeMath} from "./SafeMath.sol";
+import {DecimalMath} from "./DecimalMath.sol";
+
+/**
+ * @title DODOMath
+ * @author DODO Breeder
+ *
+ * @notice Functions for complex calculating. Including ONE Integration and TWO Quadratic solutions
+ */
+library DODOMath {
+    using SafeMath for uint256;
+
+    /*
+        Integrate dodo curve fron V1 to V2
+        require V0>=V1>=V2>0
+        res = (1-k)i(V1-V2)+ikV0*V0(1/V2-1/V1)
+        let V1-V2=delta
+        res = i*delta*(1-k+k(V0^2/V1/V2))
+    */
+    function _GeneralIntegrate(
+        uint256 V0,
+        uint256 V1,
+        uint256 V2,
+        uint256 i,
+        uint256 k
+    ) internal pure returns (uint256) {
+        uint256 fairAmount = DecimalMath.mul(i, V1.sub(V2)); // i*delta
+        uint256 V0V1 = DecimalMath.divCeil(V0, V1); // V0/V1
+        uint256 V0V2 = DecimalMath.divCeil(V0, V2); // V0/V2
+        uint256 penalty = DecimalMath.mul(DecimalMath.mul(k, V0V1), V0V2); // k(V0^2/V1/V2)
+        return DecimalMath.mul(fairAmount, DecimalMath.ONE.sub(k).add(penalty));
+    }
+
+    /*
+        The same with integration expression above, we have:
+        i*deltaB = (Q2-Q1)*(1-k+kQ0^2/Q1/Q2)
+        Given Q1 and deltaB, solve Q2
+        This is a quadratic function and the standard version is
+        aQ2^2 + bQ2 + c = 0, where
+        a=1-k
+        -b=(1-k)Q1-kQ0^2/Q1+i*deltaB
+        c=-kQ0^2
+        and Q2=(-b+sqrt(b^2+4(1-k)kQ0^2))/2(1-k)
+        note: another root is negative, abondan
+        if deltaBSig=true, then Q2>Q1
+        if deltaBSig=false, then Q2<Q1
+    */
+    function _SolveQuadraticFunctionForTrade(
+        uint256 Q0,
+        uint256 Q1,
+        uint256 ideltaB,
+        bool deltaBSig,
+        uint256 k
+    ) internal pure returns (uint256) {
+        // calculate -b value and sig
+        // -b = (1-k)Q1-kQ0^2/Q1+i*deltaB
+        uint256 kQ02Q1 = DecimalMath.mul(k, Q0).mul(Q0).div(Q1); // kQ0^2/Q1
+        uint256 b = DecimalMath.mul(DecimalMath.ONE.sub(k), Q1); // (1-k)Q1
+        bool minusbSig = true;
+        if (deltaBSig) {
+            b = b.add(ideltaB); // (1-k)Q1+i*deltaB
+        } else {
+            kQ02Q1 = kQ02Q1.add(ideltaB); // -i*(-deltaB)-kQ0^2/Q1
+        }
+        if (b >= kQ02Q1) {
+            b = b.sub(kQ02Q1);
+            minusbSig = true;
+        } else {
+            b = kQ02Q1.sub(b);
+            minusbSig = false;
+        }
+
+        // calculate sqrt
+        uint256 squareRoot = DecimalMath.mul(
+            DecimalMath.ONE.sub(k).mul(4),
+            DecimalMath.mul(k, Q0).mul(Q0)
+        ); // 4(1-k)kQ0^2
+        squareRoot = b.mul(b).add(squareRoot).sqrt(); // sqrt(b*b-4(1-k)kQ0*Q0)
+
+        // final res
+        uint256 denominator = DecimalMath.ONE.sub(k).mul(2); // 2(1-k)
+        if (minusbSig) {
+            return DecimalMath.divFloor(b.add(squareRoot), denominator);
+        } else {
+            return DecimalMath.divFloor(squareRoot.sub(b), denominator);
+        }
+    }
+
+    /*
+        Start from the integration function
+        i*deltaB = (Q2-Q1)*(1-k+kQ0^2/Q1/Q2)
+        Assume Q2=Q0, Given Q1 and deltaB, solve Q0
+        let fairAmount = i*deltaB
+    */
+    function _SolveQuadraticFunctionForTarget(
+        uint256 V1,
+        uint256 k,
+        uint256 fairAmount
+    ) internal pure returns (uint256 V0) {
+        // V0 = V1+V1*(sqrt-1)/2k
+        uint256 sqrt = DecimalMath.divFloor(DecimalMath.mul(k, fairAmount), V1).mul(4);
+        sqrt = sqrt.add(DecimalMath.ONE).mul(DecimalMath.ONE).sqrt();
+        uint256 premium = DecimalMath.divFloor(sqrt.sub(DecimalMath.ONE), k.mul(2));
+        // V0 is greater than or equal to V1 according to the solution
+        return DecimalMath.mul(V1, DecimalMath.ONE.add(premium));
+    }
+}

contracts/lib/DecimalMath.sol

@@ -0,0 +1,35 @@
+/*
+
+    Copyright 2020 DODO ZOO.
+    SPDX-License-Identifier: Apache-2.0
+
+*/
+
+pragma solidity 0.6.9;
+pragma experimental ABIEncoderV2;
+
+import {SafeMath} from "./SafeMath.sol";
+
+/**
+ * @title DecimalMath
+ * @author DODO Breeder
+ *
+ * @notice Functions for fixed point number with 18 decimals
+ */
+library DecimalMath {
+    using SafeMath for uint256;
+
+    uint256 constant ONE = 10**18;
+
+    function mul(uint256 target, uint256 d) internal pure returns (uint256) {
+        return target.mul(d) / ONE;
+    }
+
+    function divFloor(uint256 target, uint256 d) internal pure returns (uint256) {
+        return target.mul(ONE).div(d);
+    }
+
+    function divCeil(uint256 target, uint256 d) internal pure returns (uint256) {
+        return target.mul(ONE).divCeil(d);
+    }
+}

contracts/lib/Ownable.sol

@@ -0,0 +1,43 @@
+/*
+
+    Copyright 2020 DODO ZOO.
+    SPDX-License-Identifier: Apache-2.0
+
+*/
+
+pragma solidity 0.6.9;
+pragma experimental ABIEncoderV2;
+
+/**
+ * @title Ownable
+ * @author DODO Breeder
+ *
+ * @notice Ownership related functions
+ */
+contract Ownable {
+    address public _OWNER_;
+
+    // ============ Events ============
+
+    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
+
+    // ============ Modifiers ============
+
+    modifier onlyOwner() {
+        require(msg.sender == _OWNER_, "NOT_OWNER");
+        _;
+    }
+
+    // ============ Functions ============
+
+    constructor() internal {
+        _OWNER_ = msg.sender;
+        emit OwnershipTransferred(address(0), _OWNER_);
+    }
+
+    function transferOwnership(address newOwner) external onlyOwner {
+        require(newOwner != address(0), "INVALID_OWNER");
+        emit OwnershipTransferred(_OWNER_, newOwner);
+        _OWNER_ = newOwner;
+    }
+}

contracts/lib/ReentrancyGuard.sol

@@ -0,0 +1,32 @@
+/*
+
+    Copyright 2020 DODO ZOO.
+    SPDX-License-Identifier: Apache-2.0
+
+*/
+
+pragma solidity 0.6.9;
+pragma experimental ABIEncoderV2;
+
+import {Types} from "./Types.sol";
+
+/**
+ * @title ReentrancyGuard
+ * @author DODO Breeder
+ *
+ * @notice Protect functions from Reentrancy Attack
+ */
+contract ReentrancyGuard {
+    Types.EnterStatus private _ENTER_STATUS_;
+
+    constructor() internal {
+        _ENTER_STATUS_ = Types.EnterStatus.NOT_ENTERED;
+    }
+
+    modifier preventReentrant() {
+        require(_ENTER_STATUS_ != Types.EnterStatus.ENTERED, "ReentrancyGuard: reentrant call");
+        _ENTER_STATUS_ = Types.EnterStatus.ENTERED;
+        _;
+        _ENTER_STATUS_ = Types.EnterStatus.NOT_ENTERED;
+    }
+}

contracts/lib/SafeERC20.sol

@@ -0,0 +1,74 @@
+/*
+
+    Copyright 2020 DODO ZOO.
+    SPDX-License-Identifier: Apache-2.0
+    This is a simplified version of OpenZepplin's SafeERC20 library
+
+*/
+
+pragma solidity 0.6.9;
+pragma experimental ABIEncoderV2;
+
+import {IERC20} from "../intf/IERC20.sol";
+import {SafeMath} from "./SafeMath.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)
+        );
+    }
+
+    /**
+     * @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");
+        }
+    }
+}

contracts/lib/SafeMath.sol

@@ -0,0 +1,63 @@
+/*
+
+    Copyright 2020 DODO ZOO.
+    SPDX-License-Identifier: Apache-2.0
+
+*/
+
+pragma solidity 0.6.9;
+pragma experimental ABIEncoderV2;
+
+/**
+ * @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 + 1) / 2;
+        y = x;
+        while (z < y) {
+            y = z;
+            z = (x / z + z) / 2;
+        }
+    }
+}

contracts/lib/Types.sol

@@ -0,0 +1,14 @@
+/*
+
+    Copyright 2020 DODO ZOO.
+    SPDX-License-Identifier: Apache-2.0
+
+*/
+
+pragma solidity 0.6.9;
+pragma experimental ABIEncoderV2;
+
+library Types {
+    enum RStatus {ONE, ABOVE_ONE, BELOW_ONE}
+    enum EnterStatus {ENTERED, NOT_ENTERED}
+}