@pendle/core-v2 3.0.0-beta-10 → 3.0.0-beta-12

package/contracts/core/StandardizedYield/implementations/Kyber/libraries/FullMath.sol

@@ -0,0 +1,123 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.8.0;
+
+/**
+ *      ---------      [DIRECT COPIED FROM KYBERSWAP]      ---------
+ */
+
+/// @title Contains 512-bit math functions
+/// @notice Facilitates multiplication and division that can have overflow of an intermediate value without any loss of precision
+/// @dev Handles "phantom overflow" i.e., allows multiplication and division where an intermediate value overflows 256 bits
+/// @dev Code has been modified to be compatible with sol 0.8
+library FullMath {
+    /// @notice Calculates floor(a×b÷denominator) with full precision. Throws if result overflows a uint256 or denominator == 0
+    /// @param a The multiplicand
+    /// @param b The multiplier
+    /// @param denominator The divisor
+    /// @return result The 256-bit result
+    /// @dev Credit to Remco Bloemen under MIT license https://xn--2-umb.com/21/muldiv
+    function mulDivFloor(uint256 a, uint256 b, uint256 denominator) internal pure returns (uint256 result) {
+        // 512-bit multiply [prod1 prod0] = a * b
+        // Compute the product mod 2**256 and mod 2**256 - 1
+        // then use the Chinese Remainder Theorem to reconstruct
+        // the 512 bit result. The result is stored in two 256
+        // variables such that product = prod1 * 2**256 + prod0
+        uint256 prod0; // Least significant 256 bits of the product
+        uint256 prod1; // Most significant 256 bits of the product
+        assembly {
+            let mm := mulmod(a, b, not(0))
+            prod0 := mul(a, b)
+            prod1 := sub(sub(mm, prod0), lt(mm, prod0))
+        }
+
+        // Handle non-overflow cases, 256 by 256 division
+        if (prod1 == 0) {
+            require(denominator > 0, "0 denom");
+            assembly {
+                result := div(prod0, denominator)
+            }
+            return result;
+        }
+
+        // Make sure the result is less than 2**256.
+        // Also prevents denominator == 0
+        require(denominator > prod1, "denom <= prod1");
+
+        ///////////////////////////////////////////////
+        // 512 by 256 division.
+        ///////////////////////////////////////////////
+
+        // Make division exact by subtracting the remainder from [prod1 prod0]
+        // Compute remainder using mulmod
+        uint256 remainder;
+        assembly {
+            remainder := mulmod(a, b, denominator)
+        }
+        // Subtract 256 bit number from 512 bit number
+        assembly {
+            prod1 := sub(prod1, gt(remainder, prod0))
+            prod0 := sub(prod0, remainder)
+        }
+
+        // Factor powers of two out of denominator
+        // Compute largest power of two divisor of denominator.
+        // Always >= 1.
+        uint256 twos = denominator & (~denominator + 1);
+        // Divide denominator by power of two
+        assembly {
+            denominator := div(denominator, twos)
+        }
+
+        // Divide [prod1 prod0] by the factors of two
+        assembly {
+            prod0 := div(prod0, twos)
+        }
+        // Shift in bits from prod1 into prod0. For this we need
+        // to flip `twos` such that it is 2**256 / twos.
+        // If twos is zero, then it becomes one
+        assembly {
+            twos := add(div(sub(0, twos), twos), 1)
+        }
+        unchecked {
+            prod0 |= prod1 * twos;
+
+            // Invert denominator mod 2**256
+            // Now that denominator is an odd number, it has an inverse
+            // modulo 2**256 such that denominator * inv = 1 mod 2**256.
+            // Compute the inverse by starting with a seed that is correct
+            // correct for four bits. That is, denominator * inv = 1 mod 2**4
+            uint256 inv = (3 * denominator) ^ 2;
+
+            // Now use Newton-Raphson iteration to improve the precision.
+            // Thanks to Hensel's lifting lemma, this also works in modular
+            // arithmetic, doubling the correct bits in each step.
+            inv *= 2 - denominator * inv; // inverse mod 2**8
+            inv *= 2 - denominator * inv; // inverse mod 2**16
+            inv *= 2 - denominator * inv; // inverse mod 2**32
+            inv *= 2 - denominator * inv; // inverse mod 2**64
+            inv *= 2 - denominator * inv; // inverse mod 2**128
+            inv *= 2 - denominator * inv; // inverse mod 2**256
+
+            // Because the division is now exact we can divide by multiplying
+            // with the modular inverse of denominator. This will give us the
+            // correct result modulo 2**256. Since the precoditions guarantee
+            // that the outcome is less than 2**256, this is the final result.
+            // We don't need to compute the high bits of the result and prod1
+            // is no longer required.
+            result = prod0 * inv;
+        }
+        return result;
+    }
+
+    /// @notice Calculates ceil(a×b÷denominator) with full precision. Throws if result overflows a uint256 or denominator == 0
+    /// @param a The multiplicand
+    /// @param b The multiplier
+    /// @param denominator The divisor
+    /// @return result The 256-bit result
+    function mulDivCeiling(uint256 a, uint256 b, uint256 denominator) internal pure returns (uint256 result) {
+        result = mulDivFloor(a, b, denominator);
+        if (mulmod(a, b, denominator) > 0) {
+            result++;
+        }
+    }
+}

package/contracts/core/StandardizedYield/implementations/Kyber/libraries/LiqDeltaMath.sol

@@ -0,0 +1,17 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.8.0;
+
+/**
+ *      ---------      [DIRECT COPIED FROM KYBERSWAP]      ---------
+ */
+
+/// @title Contains helper function to add or remove uint128 liquidityDelta to uint128 liquidity
+library LiqDeltaMath {
+    function applyLiquidityDelta(
+        uint128 liquidity,
+        uint128 liquidityDelta,
+        bool isAddLiquidity
+    ) internal pure returns (uint128) {
+        return isAddLiquidity ? liquidity + liquidityDelta : liquidity - liquidityDelta;
+    }
+}

package/contracts/core/StandardizedYield/implementations/Kyber/libraries/LiquidityMath.sol

@@ -0,0 +1,74 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import {MathConstants as C} from "./MathConstants.sol";
+import {FullMath} from "./FullMath.sol";
+import {SafeCast} from "./SafeCast.sol";
+
+/**
+ *      ---------      [DIRECT COPIED FROM KYBERSWAP]      ---------
+ */
+
+library LiquidityMath {
+    using SafeCast for uint256;
+
+    /// @notice Gets liquidity from qty 0 and the price range
+    /// qty0 = liquidity * (sqrt(upper) - sqrt(lower)) / (sqrt(upper) * sqrt(lower))
+    /// => liquidity = qty0 * (sqrt(upper) * sqrt(lower)) / (sqrt(upper) - sqrt(lower))
+    /// @param lowerSqrtP A lower sqrt price
+    /// @param upperSqrtP An upper sqrt price
+    /// @param qty0 amount of token0
+    /// @return liquidity amount of returned liquidity to not exceed the qty0
+    function getLiquidityFromQty0(
+        uint160 lowerSqrtP,
+        uint160 upperSqrtP,
+        uint256 qty0
+    ) internal pure returns (uint128) {
+        uint256 liq = FullMath.mulDivFloor(lowerSqrtP, upperSqrtP, C.TWO_POW_96);
+        unchecked {
+            return FullMath.mulDivFloor(liq, qty0, upperSqrtP - lowerSqrtP).toUint128();
+        }
+    }
+
+    /// @notice Gets liquidity from qty 1 and the price range
+    /// @dev qty1 = liquidity * (sqrt(upper) - sqrt(lower))
+    ///   thus, liquidity = qty1 / (sqrt(upper) - sqrt(lower))
+    /// @param lowerSqrtP A lower sqrt price
+    /// @param upperSqrtP An upper sqrt price
+    /// @param qty1 amount of token1
+    /// @return liquidity amount of returned liquidity to not exceed to qty1
+    function getLiquidityFromQty1(
+        uint160 lowerSqrtP,
+        uint160 upperSqrtP,
+        uint256 qty1
+    ) internal pure returns (uint128) {
+        unchecked {
+            return FullMath.mulDivFloor(qty1, C.TWO_POW_96, upperSqrtP - lowerSqrtP).toUint128();
+        }
+    }
+
+    /// @notice Gets liquidity given price range and 2 qties of token0 and token1
+    /// @param currentSqrtP current price
+    /// @param lowerSqrtP A lower sqrt price
+    /// @param upperSqrtP An upper sqrt price
+    /// @param qty0 amount of token0 - at most
+    /// @param qty1 amount of token1 - at most
+    /// @return liquidity amount of returned liquidity to not exceed the given qties
+    function getLiquidityFromQties(
+        uint160 currentSqrtP,
+        uint160 lowerSqrtP,
+        uint160 upperSqrtP,
+        uint256 qty0,
+        uint256 qty1
+    ) internal pure returns (uint128) {
+        if (currentSqrtP <= lowerSqrtP) {
+            return getLiquidityFromQty0(lowerSqrtP, upperSqrtP, qty0);
+        }
+        if (currentSqrtP >= upperSqrtP) {
+            return getLiquidityFromQty1(lowerSqrtP, upperSqrtP, qty1);
+        }
+        uint128 liq0 = getLiquidityFromQty0(currentSqrtP, upperSqrtP, qty0);
+        uint128 liq1 = getLiquidityFromQty1(lowerSqrtP, currentSqrtP, qty1);
+        return liq0 < liq1 ? liq0 : liq1;
+    }
+}

package/contracts/core/StandardizedYield/implementations/Kyber/libraries/MathConstants.sol

@@ -0,0 +1,19 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.8.0;
+
+/**
+ *      ---------      [DIRECT COPIED FROM KYBERSWAP]      ---------
+ */
+
+/// @title Contains constants needed for math libraries
+library MathConstants {
+    uint256 internal constant TWO_FEE_UNITS = 200_000;
+    uint256 internal constant TWO_POW_96 = 2 ** 96;
+    uint128 internal constant MIN_LIQUIDITY = 100;
+    uint8 internal constant RES_96 = 96;
+    uint24 internal constant FEE_UNITS = 100000;
+    // it is strictly less than 5% price movement if jumping MAX_TICK_DISTANCE ticks
+    int24 internal constant MAX_TICK_DISTANCE = 480;
+    // max number of tick travel when inserting if data changes
+    uint256 internal constant MAX_TICK_TRAVEL = 10;
+}

package/contracts/core/StandardizedYield/implementations/Kyber/libraries/QtyDeltaMath.sol

@@ -0,0 +1,103 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.8.0;
+
+import {MathConstants as C} from "./MathConstants.sol";
+import {TickMath} from "./TickMath.sol";
+import {FullMath} from "./FullMath.sol";
+import {SafeCast} from "./SafeCast.sol";
+
+/**
+ *      ---------      [DIRECT COPIED FROM KYBERSWAP]      ---------
+ */
+
+/// @title Contains helper functions for calculating
+/// token0 and token1 quantites from differences in prices
+/// or from burning reinvestment tokens
+library QtyDeltaMath {
+    using SafeCast for uint256;
+    using SafeCast for int128;
+
+    function calcUnlockQtys(uint160 initialSqrtP) internal pure returns (uint256 qty0, uint256 qty1) {
+        qty0 = FullMath.mulDivCeiling(C.MIN_LIQUIDITY, C.TWO_POW_96, initialSqrtP);
+        qty1 = FullMath.mulDivCeiling(C.MIN_LIQUIDITY, initialSqrtP, C.TWO_POW_96);
+    }
+
+    /// @notice Gets the qty0 delta between two prices
+    /// @dev Calculates liquidity / sqrt(lower) - liquidity / sqrt(upper),
+    /// i.e. liquidity * (sqrt(upper) - sqrt(lower)) / (sqrt(upper) * sqrt(lower))
+    /// rounds up if adding liquidity, rounds down if removing liquidity
+    /// @param lowerSqrtP The lower sqrt price.
+    /// @param upperSqrtP The upper sqrt price. Should be >= lowerSqrtP
+    /// @param liquidity Liquidity quantity
+    /// @param isAddLiquidity true = add liquidity, false = remove liquidity
+    /// @return token0 qty required for position with liquidity between the 2 sqrt prices
+    function calcRequiredQty0(
+        uint160 lowerSqrtP,
+        uint160 upperSqrtP,
+        uint128 liquidity,
+        bool isAddLiquidity
+    ) internal pure returns (int256) {
+        uint256 numerator1 = uint256(liquidity) << C.RES_96;
+        uint256 numerator2;
+        unchecked {
+            numerator2 = upperSqrtP - lowerSqrtP;
+        }
+        return
+            isAddLiquidity
+                ? (divCeiling(FullMath.mulDivCeiling(numerator1, numerator2, upperSqrtP), lowerSqrtP)).toInt256()
+                : (FullMath.mulDivFloor(numerator1, numerator2, upperSqrtP) / lowerSqrtP).revToInt256();
+    }
+
+    /// @notice Gets the token1 delta quantity between two prices
+    /// @dev Calculates liquidity * (sqrt(upper) - sqrt(lower))
+    /// rounds up if adding liquidity, rounds down if removing liquidity
+    /// @param lowerSqrtP The lower sqrt price.
+    /// @param upperSqrtP The upper sqrt price. Should be >= lowerSqrtP
+    /// @param liquidity Liquidity quantity
+    /// @param isAddLiquidity true = add liquidity, false = remove liquidity
+    /// @return token1 qty required for position with liquidity between the 2 sqrt prices
+    function calcRequiredQty1(
+        uint160 lowerSqrtP,
+        uint160 upperSqrtP,
+        uint128 liquidity,
+        bool isAddLiquidity
+    ) internal pure returns (int256) {
+        unchecked {
+            return
+                isAddLiquidity
+                    ? (FullMath.mulDivCeiling(liquidity, upperSqrtP - lowerSqrtP, C.TWO_POW_96)).toInt256()
+                    : (FullMath.mulDivFloor(liquidity, upperSqrtP - lowerSqrtP, C.TWO_POW_96)).revToInt256();
+        }
+    }
+
+    /// @notice Calculates the token0 quantity proportion to be sent to the user
+    /// for burning reinvestment tokens
+    /// @param sqrtP Current pool sqrt price
+    /// @param liquidity Difference in reinvestment liquidity due to reinvestment token burn
+    /// @return token0 quantity to be sent to the user
+    function getQty0FromBurnRTokens(uint160 sqrtP, uint256 liquidity) internal pure returns (uint256) {
+        return FullMath.mulDivFloor(liquidity, C.TWO_POW_96, sqrtP);
+    }
+
+    /// @notice Calculates the token1 quantity proportion to be sent to the user
+    /// for burning reinvestment tokens
+    /// @param sqrtP Current pool sqrt price
+    /// @param liquidity Difference in reinvestment liquidity due to reinvestment token burn
+    /// @return token1 quantity to be sent to the user
+    function getQty1FromBurnRTokens(uint160 sqrtP, uint256 liquidity) internal pure returns (uint256) {
+        return FullMath.mulDivFloor(liquidity, sqrtP, C.TWO_POW_96);
+    }
+
+    /// @notice Returns ceil(x / y)
+    /// @dev division by 0 has unspecified behavior, and must be checked externally
+    /// @param x The dividend
+    /// @param y The divisor
+    /// @return z The quotient, ceil(x / y)
+    function divCeiling(uint256 x, uint256 y) internal pure returns (uint256 z) {
+        // return x / y + ((x % y == 0) ? 0 : 1);
+        require(y > 0);
+        assembly {
+            z := add(div(x, y), gt(mod(x, y), 0))
+        }
+    }
+}

package/contracts/core/StandardizedYield/implementations/Kyber/libraries/QuadMath.sol

@@ -0,0 +1,31 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.8.0;
+
+/**
+ *      ---------      [DIRECT COPIED FROM KYBERSWAP]      ---------
+ */
+
+library QuadMath {
+    // our equation is ax^2 - 2bx + c = 0, where a, b and c > 0
+    // the qudratic formula to obtain the smaller root is (2b - sqrt((2*b)^2 - 4ac)) / 2a
+    // which can be simplified to (b - sqrt(b^2 - ac)) / a
+    function getSmallerRootOfQuadEqn(uint256 a, uint256 b, uint256 c) internal pure returns (uint256 smallerRoot) {
+        smallerRoot = (b - sqrt(b * b - a * c)) / a;
+    }
+
+    // babylonian method (https://en.wikipedia.org/wiki/Methods_of_computing_square_roots#Babylonian_method)
+    function sqrt(uint256 y) internal pure returns (uint256 z) {
+        unchecked {
+            if (y > 3) {
+                z = y;
+                uint256 x = y / 2 + 1;
+                while (x < z) {
+                    z = x;
+                    x = (y / x + x) / 2;
+                }
+            } else if (y != 0) {
+                z = 1;
+            }
+        }
+    }
+}

package/contracts/core/StandardizedYield/implementations/Kyber/libraries/ReinvestmentMath.sol

@@ -0,0 +1,26 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.8.0;
+
+import {MathConstants as C} from "./MathConstants.sol";
+import {FullMath} from "./FullMath.sol";
+
+/**
+ *      ---------      [DIRECT COPIED FROM KYBERSWAP]      ---------
+ */
+
+/// @title Contains helper function to calculate the number of reinvestment tokens to be minted
+library ReinvestmentMath {
+    /// @dev calculate the mint amount with given reinvestL, reinvestLLast, baseL and rTotalSupply
+    /// contribution of lp to the increment is calculated by the proportion of baseL with reinvestL + baseL
+    /// then rMintQty is calculated by mutiplying this with the liquidity per reinvestment token
+    /// rMintQty = rTotalSupply * (reinvestL - reinvestLLast) / reinvestLLast * baseL / (baseL + reinvestL)
+    function calcrMintQty(
+        uint256 reinvestL,
+        uint256 reinvestLLast,
+        uint128 baseL,
+        uint256 rTotalSupply
+    ) internal pure returns (uint256 rMintQty) {
+        uint256 lpContribution = FullMath.mulDivFloor(baseL, reinvestL - reinvestLLast, baseL + reinvestL);
+        rMintQty = FullMath.mulDivFloor(rTotalSupply, lpContribution, reinvestLLast);
+    }
+}

package/contracts/core/StandardizedYield/implementations/Kyber/libraries/SafeCast.sol

@@ -0,0 +1,73 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+pragma solidity >=0.8.0;
+
+/**
+ *      ---------      [DIRECT COPIED FROM KYBERSWAP]      ---------
+ */
+
+/// @title Safe casting methods
+/// @notice Contains methods for safely casting between types
+library SafeCast {
+    /// @notice Cast a uint256 to uint32, revert on overflow
+    /// @param y The uint256 to be downcasted
+    /// @return z The downcasted integer, now type uint32
+    function toUint32(uint256 y) internal pure returns (uint32 z) {
+        require((z = uint32(y)) == y);
+    }
+
+    /// @notice Cast a uint128 to a int128, revert on overflow
+    /// @param y The uint256 to be casted
+    /// @return z The casted integer, now type int256
+    function toInt128(uint128 y) internal pure returns (int128 z) {
+        require(y < 2 ** 127);
+        z = int128(y);
+    }
+
+    /// @notice Cast a uint256 to a uint128, revert on overflow
+    /// @param y the uint256 to be downcasted
+    /// @return z The downcasted integer, now type uint128
+    function toUint128(uint256 y) internal pure returns (uint128 z) {
+        require((z = uint128(y)) == y);
+    }
+
+    /// @notice Cast a int128 to a uint128 and reverses the sign.
+    /// @param y The int128 to be casted
+    /// @return z = -y, now type uint128
+    function revToUint128(int128 y) internal pure returns (uint128 z) {
+        unchecked {
+            return type(uint128).max - uint128(y) + 1;
+        }
+    }
+
+    /// @notice Cast a uint256 to a uint160, revert on overflow
+    /// @param y The uint256 to be downcasted
+    /// @return z The downcasted integer, now type uint160
+    function toUint160(uint256 y) internal pure returns (uint160 z) {
+        require((z = uint160(y)) == y);
+    }
+
+    /// @notice Cast a uint256 to a int256, revert on overflow
+    /// @param y The uint256 to be casted
+    /// @return z The casted integer, now type int256
+    function toInt256(uint256 y) internal pure returns (int256 z) {
+        require(y < 2 ** 255);
+        z = int256(y);
+    }
+
+    /// @notice Cast a uint256 to a int256 and reverses the sign, revert on overflow
+    /// @param y The uint256 to be casted
+    /// @return z = -y, now type int256
+    function revToInt256(uint256 y) internal pure returns (int256 z) {
+        require(y < 2 ** 255);
+        z = -int256(y);
+    }
+
+    /// @notice Cast a int256 to a uint256 and reverses the sign.
+    /// @param y The int256 to be casted
+    /// @return z = -y, now type uint256
+    function revToUint256(int256 y) internal pure returns (uint256 z) {
+        unchecked {
+            return type(uint256).max - uint256(y) + 1;
+        }
+    }
+}