@pendle/core-v2 2.29.4 → 2.30.1

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

@@ -1,7 +1,6 @@
 // SPDX-License-Identifier: MIT
 pragma solidity >=0.8.0;
 
-
 /**
  *      ---------      [DIRECT COPIED FROM KYBERSWAP]      ---------
  */
@@ -11,122 +10,114 @@ pragma solidity >=0.8.0;
 /// @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))
-    }
+    /// @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;
-    }
+        // 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');
+        // Make sure the result is less than 2**256.
+        // Also prevents denominator == 0
+        require(denominator > prod1, "denom <= prod1");
 
-    ///////////////////////////////////////////////
-    // 512 by 256 division.
-    ///////////////////////////////////////////////
+        ///////////////////////////////////////////////
+        // 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)
-    }
+        // 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)
-    }
+        // 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;
+        // 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;
+            // 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
+            // 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;
+            // 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;
     }
-    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++;
+    /// @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

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

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

@@ -1,21 +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;
+    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

@@ -1,11 +1,10 @@
 // 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';
-
+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]      ---------
@@ -15,103 +14,90 @@ import {SafeCast} from './SafeCast.sol';
 /// token0 and token1 quantites from differences in prices
 /// or from burning reinvestment tokens
 library QtyDeltaMath {
-  using SafeCast for uint256;
-  using SafeCast for int128;
+    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);
-  }
+    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;
+    /// @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();
     }
-    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 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 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 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))
+    /// @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))
+        }
     }
-  }
 }