@pendle/core-v2 2.29.1 → 2.29.2

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

@@ -0,0 +1,132 @@
+// 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,18 @@
+// 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,75 @@
+// 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,21 @@
+// 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,117 @@
+// 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,37 @@
+// 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,31 @@
+// 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,75 @@
+// 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;
+    }
+  }
+}