@pendle/core-v2 2.29.4 → 2.30.1

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

@@ -1,37 +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;
-  }
+    // 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;
+    // 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;
+            }
         }
-      } else if (y != 0) {
-        z = 1;
-      }
     }
-  }
 }

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

@@ -1,9 +1,8 @@
 // SPDX-License-Identifier: MIT
 pragma solidity >=0.8.0;
 
-import {MathConstants as C} from './MathConstants.sol';
-import {FullMath} from './FullMath.sol';
-
+import {MathConstants as C} from "./MathConstants.sol";
+import {FullMath} from "./FullMath.sol";
 
 /**
  *      ---------      [DIRECT COPIED FROM KYBERSWAP]      ---------
@@ -11,21 +10,17 @@ import {FullMath} from './FullMath.sol';
 
 /// @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);
-  }
+    /// @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

@@ -1,75 +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 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 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 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 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 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, 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 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;
+    /// @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;
+        }
     }
-  }
 }

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

@@ -1,17 +1,15 @@
 // SPDX-License-Identifier: MIT
 pragma solidity >=0.8.0;
 
-import { MathConstants as C } from "./MathConstants.sol";
-import { FullMath } from "./FullMath.sol";
-import { QuadMath } from "./QuadMath.sol";
-import { SafeCast } from "./SafeCast.sol";
-
+import {MathConstants as C} from "./MathConstants.sol";
+import {FullMath} from "./FullMath.sol";
+import {QuadMath} from "./QuadMath.sol";
+import {SafeCast} from "./SafeCast.sol";
 
 /**
  *      ---------      [DIRECT COPIED FROM KYBERSWAP]      ---------
  */
 
-
 /// @title Contains helper functions for swaps
 library SwapMath {
     using SafeCast for uint256;
@@ -39,28 +37,14 @@ library SwapMath {
         int256 specifiedAmount,
         bool isExactInput,
         bool isToken0
-    )
-        internal
-        pure
-        returns (int256 usedAmount, int256 returnedAmount, uint256 deltaL, uint160 nextSqrtP)
-    {
+    ) internal pure returns (int256 usedAmount, int256 returnedAmount, uint256 deltaL, uint160 nextSqrtP) {
         // in the event currentSqrtP == targetSqrtP because of tick movements, return
         // eg. swapped up tick where specified price limit is on an initialised tick
         // then swapping down tick will cause next tick to be the same as the current tick
         if (currentSqrtP == targetSqrtP) return (0, 0, 0, currentSqrtP);
-        usedAmount = calcReachAmount(
-            liquidity,
-            currentSqrtP,
-            targetSqrtP,
-            feeInFeeUnits,
-            isExactInput,
-            isToken0
-        );
+        usedAmount = calcReachAmount(liquidity, currentSqrtP, targetSqrtP, feeInFeeUnits, isExactInput, isToken0);
 
-        if (
-            (isExactInput && usedAmount > specifiedAmount) ||
-            (!isExactInput && usedAmount <= specifiedAmount)
-        ) {
+        if ((isExactInput && usedAmount > specifiedAmount) || (!isExactInput && usedAmount <= specifiedAmount)) {
             usedAmount = specifiedAmount;
         } else {
             nextSqrtP = targetSqrtP;
@@ -76,32 +60,11 @@ library SwapMath {
                 isExactInput,
                 isToken0
             );
-            nextSqrtP = calcFinalPrice(
-                absDelta,
-                liquidity,
-                deltaL,
-                currentSqrtP,
-                isExactInput,
-                isToken0
-            ).toUint160();
+            nextSqrtP = calcFinalPrice(absDelta, liquidity, deltaL, currentSqrtP, isExactInput, isToken0).toUint160();
         } else {
-            deltaL = calcIncrementalLiquidity(
-                absDelta,
-                liquidity,
-                currentSqrtP,
-                nextSqrtP,
-                isExactInput,
-                isToken0
-            );
+            deltaL = calcIncrementalLiquidity(absDelta, liquidity, currentSqrtP, nextSqrtP, isExactInput, isToken0);
         }
-        returnedAmount = calcReturnedAmount(
-            liquidity,
-            currentSqrtP,
-            nextSqrtP,
-            deltaL,
-            isExactInput,
-            isToken0
-        );
+        returnedAmount = calcReturnedAmount(liquidity, currentSqrtP, nextSqrtP, deltaL, isExactInput, isToken0);
     }
 
     /// @dev calculates the amount needed to reach targetSqrtP from currentSqrtP
@@ -116,9 +79,7 @@ library SwapMath {
     ) internal pure returns (int256 reachAmount) {
         uint256 absPriceDiff;
         unchecked {
-            absPriceDiff = (currentSqrtP >= targetSqrtP)
-                ? (currentSqrtP - targetSqrtP)
-                : (targetSqrtP - currentSqrtP);
+            absPriceDiff = (currentSqrtP >= targetSqrtP) ? (currentSqrtP - targetSqrtP) : (targetSqrtP - currentSqrtP);
         }
         if (isExactInput) {
             // we round down so that we avoid taking giving away too much for the specified input
@@ -128,27 +89,15 @@ library SwapMath {
                 // denominator = currentSqrtP * (2 * targetSqrtP - currentSqrtP * feeInFeeUnits / FEE_UNITS)
                 // overflow should not happen because the absPriceDiff is capped to ~5%
                 uint256 denominator = C.TWO_FEE_UNITS * targetSqrtP - feeInFeeUnits * currentSqrtP;
-                uint256 numerator = FullMath.mulDivFloor(
-                    liquidity,
-                    C.TWO_FEE_UNITS * absPriceDiff,
-                    denominator
-                );
-                reachAmount = FullMath
-                    .mulDivFloor(numerator, C.TWO_POW_96, currentSqrtP)
-                    .toInt256();
+                uint256 numerator = FullMath.mulDivFloor(liquidity, C.TWO_FEE_UNITS * absPriceDiff, denominator);
+                reachAmount = FullMath.mulDivFloor(numerator, C.TWO_POW_96, currentSqrtP).toInt256();
             } else {
                 // numerator = 2 * liquidity * absPriceDiff * currentSqrtP
                 // denominator = 2 * currentSqrtP - targetSqrtP * feeInFeeUnits / FEE_UNITS
                 // overflow should not happen because the absPriceDiff is capped to ~5%
                 uint256 denominator = C.TWO_FEE_UNITS * currentSqrtP - feeInFeeUnits * targetSqrtP;
-                uint256 numerator = FullMath.mulDivFloor(
-                    liquidity,
-                    C.TWO_FEE_UNITS * absPriceDiff,
-                    denominator
-                );
-                reachAmount = FullMath
-                    .mulDivFloor(numerator, currentSqrtP, C.TWO_POW_96)
-                    .toInt256();
+                uint256 numerator = FullMath.mulDivFloor(liquidity, C.TWO_FEE_UNITS * absPriceDiff, denominator);
+                reachAmount = FullMath.mulDivFloor(numerator, currentSqrtP, C.TWO_POW_96).toInt256();
             }
         } else {
             // we will perform negation as the last step
@@ -160,8 +109,7 @@ library SwapMath {
                 uint256 denominator = C.TWO_FEE_UNITS * currentSqrtP - feeInFeeUnits * targetSqrtP;
                 uint256 numerator = denominator - feeInFeeUnits * currentSqrtP;
                 numerator = FullMath.mulDivFloor(liquidity << C.RES_96, numerator, denominator);
-                reachAmount = (FullMath.mulDivFloor(numerator, absPriceDiff, currentSqrtP) /
-                    targetSqrtP).revToInt256();
+                reachAmount = (FullMath.mulDivFloor(numerator, absPriceDiff, currentSqrtP) / targetSqrtP).revToInt256();
             } else {
                 // numerator: liquidity * absPriceDiff * (TWO_FEE_UNITS * targetSqrtP - feeInFeeUnits * (targetSqrtP + currentSqrtP))
                 // denominator: (TWO_FEE_UNITS * targetSqrtP - feeInFeeUnits * currentSqrtP)
@@ -169,9 +117,7 @@ library SwapMath {
                 uint256 denominator = C.TWO_FEE_UNITS * targetSqrtP - feeInFeeUnits * currentSqrtP;
                 uint256 numerator = denominator - feeInFeeUnits * targetSqrtP;
                 numerator = FullMath.mulDivFloor(liquidity, numerator, denominator);
-                reachAmount = FullMath
-                    .mulDivFloor(numerator, absPriceDiff, C.TWO_POW_96)
-                    .revToInt256();
+                reachAmount = FullMath.mulDivFloor(numerator, absPriceDiff, C.TWO_POW_96).revToInt256();
             }
         }
     }
@@ -190,20 +136,12 @@ library SwapMath {
         if (isExactInput) {
             if (isToken0) {
                 // deltaL = feeInFeeUnits * absDelta * currentSqrtP / 2
-                deltaL = FullMath.mulDivFloor(
-                    currentSqrtP,
-                    absDelta * feeInFeeUnits,
-                    C.TWO_FEE_UNITS << C.RES_96
-                );
+                deltaL = FullMath.mulDivFloor(currentSqrtP, absDelta * feeInFeeUnits, C.TWO_FEE_UNITS << C.RES_96);
             } else {
                 // deltaL = feeInFeeUnits * absDelta * / (currentSqrtP * 2)
                 // Because nextSqrtP = (liquidity + absDelta / currentSqrtP) * currentSqrtP / (liquidity + deltaL)
                 // so we round up deltaL, to round down nextSqrtP
-                deltaL = FullMath.mulDivFloor(
-                    C.TWO_POW_96,
-                    absDelta * feeInFeeUnits,
-                    C.TWO_FEE_UNITS * currentSqrtP
-                );
+                deltaL = FullMath.mulDivFloor(C.TWO_POW_96, absDelta * feeInFeeUnits, C.TWO_FEE_UNITS * currentSqrtP);
             }
         } else {
             // obtain the smaller root of the quadratic equation
@@ -309,17 +247,13 @@ library SwapMath {
                 // returnedAmount = deltaL * nextSqrtP - liquidity * (currentSqrtP - nextSqrtP)
                 returnedAmount =
                     FullMath.mulDivCeiling(deltaL, nextSqrtP, C.TWO_POW_96).toInt256() +
-                    FullMath
-                        .mulDivFloor(liquidity, currentSqrtP - nextSqrtP, C.TWO_POW_96)
-                        .revToInt256();
+                    FullMath.mulDivFloor(liquidity, currentSqrtP - nextSqrtP, C.TWO_POW_96).revToInt256();
             } else {
                 // maximise actual input (>0) so we get desired output amount
                 // returnedAmount = deltaL * nextSqrtP + liquidity * (nextSqrtP - currentSqrtP)
                 returnedAmount =
                     FullMath.mulDivCeiling(deltaL, nextSqrtP, C.TWO_POW_96).toInt256() +
-                    FullMath
-                        .mulDivCeiling(liquidity, nextSqrtP - currentSqrtP, C.TWO_POW_96)
-                        .toInt256();
+                    FullMath.mulDivCeiling(liquidity, nextSqrtP - currentSqrtP, C.TWO_POW_96).toInt256();
             }
         } else {
             // returnedAmount = (liquidity + deltaL)/nextSqrtP - (liquidity)/currentSqrtP