@pendle/core-v2 6.3.1 → 6.3.2-pendle-merkle-transfer

package/contracts/core/libraries/math/LogExpMath.sol

@@ -1,15 +1,13 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 // Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
-// documentation files (the “Software”), to deal in the Software without restriction, including without limitation
-// the
+// documentation files (the “Software”), to deal in the Software without restriction, including without limitation the
 // rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to
 // permit persons to whom the Software is furnished to do so, subject to the following conditions:
 
 // The above copyright notice and this permission notice shall be included in all copies or substantial portions of the
 // Software.
 
-// THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO
-// THE
+// THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
 // WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
 // COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
 // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
@@ -58,33 +56,32 @@ library LogExpMath {
     uint256 constant MILD_EXPONENT_BOUND = 2 ** 254 / uint256(ONE_20);
 
     // 18 decimal constants
-    int256 constant x0 = 128_000_000_000_000_000_000; // 2ˆ7
-    int256 constant a0 = 38_877_084_059_945_950_922_200_000_000_000_000_000_000_000_000_000_000_000; // eˆ(x0) (no
-    // decimals)
-    int256 constant x1 = 64_000_000_000_000_000_000; // 2ˆ6
-    int256 constant a1 = 6_235_149_080_811_616_882_910_000_000; // eˆ(x1) (no decimals)
+    int256 constant x0 = 128000000000000000000; // 2ˆ7
+    int256 constant a0 = 38877084059945950922200000000000000000000000000000000000; // eˆ(x0) (no decimals)
+    int256 constant x1 = 64000000000000000000; // 2ˆ6
+    int256 constant a1 = 6235149080811616882910000000; // eˆ(x1) (no decimals)
 
     // 20 decimal constants
-    int256 constant x2 = 3_200_000_000_000_000_000_000; // 2ˆ5
-    int256 constant a2 = 7_896_296_018_268_069_516_100_000_000_000_000; // eˆ(x2)
-    int256 constant x3 = 1_600_000_000_000_000_000_000; // 2ˆ4
-    int256 constant a3 = 888_611_052_050_787_263_676_000_000; // eˆ(x3)
-    int256 constant x4 = 800_000_000_000_000_000_000; // 2ˆ3
-    int256 constant a4 = 298_095_798_704_172_827_474_000; // eˆ(x4)
-    int256 constant x5 = 400_000_000_000_000_000_000; // 2ˆ2
-    int256 constant a5 = 5_459_815_003_314_423_907_810; // eˆ(x5)
-    int256 constant x6 = 200_000_000_000_000_000_000; // 2ˆ1
-    int256 constant a6 = 738_905_609_893_065_022_723; // eˆ(x6)
-    int256 constant x7 = 100_000_000_000_000_000_000; // 2ˆ0
-    int256 constant a7 = 271_828_182_845_904_523_536; // eˆ(x7)
-    int256 constant x8 = 50_000_000_000_000_000_000; // 2ˆ-1
-    int256 constant a8 = 164_872_127_070_012_814_685; // eˆ(x8)
-    int256 constant x9 = 25_000_000_000_000_000_000; // 2ˆ-2
-    int256 constant a9 = 128_402_541_668_774_148_407; // eˆ(x9)
-    int256 constant x10 = 12_500_000_000_000_000_000; // 2ˆ-3
-    int256 constant a10 = 113_314_845_306_682_631_683; // eˆ(x10)
-    int256 constant x11 = 6_250_000_000_000_000_000; // 2ˆ-4
-    int256 constant a11 = 106_449_445_891_785_942_956; // eˆ(x11)
+    int256 constant x2 = 3200000000000000000000; // 2ˆ5
+    int256 constant a2 = 7896296018268069516100000000000000; // eˆ(x2)
+    int256 constant x3 = 1600000000000000000000; // 2ˆ4
+    int256 constant a3 = 888611052050787263676000000; // eˆ(x3)
+    int256 constant x4 = 800000000000000000000; // 2ˆ3
+    int256 constant a4 = 298095798704172827474000; // eˆ(x4)
+    int256 constant x5 = 400000000000000000000; // 2ˆ2
+    int256 constant a5 = 5459815003314423907810; // eˆ(x5)
+    int256 constant x6 = 200000000000000000000; // 2ˆ1
+    int256 constant a6 = 738905609893065022723; // eˆ(x6)
+    int256 constant x7 = 100000000000000000000; // 2ˆ0
+    int256 constant a7 = 271828182845904523536; // eˆ(x7)
+    int256 constant x8 = 50000000000000000000; // 2ˆ-1
+    int256 constant a8 = 164872127070012814685; // eˆ(x8)
+    int256 constant x9 = 25000000000000000000; // 2ˆ-2
+    int256 constant a9 = 128402541668774148407; // eˆ(x9)
+    int256 constant x10 = 12500000000000000000; // 2ˆ-3
+    int256 constant a10 = 113314845306682631683; // eˆ(x10)
+    int256 constant x11 = 6250000000000000000; // 2ˆ-4
+    int256 constant a11 = 106449445891785942956; // eˆ(x11)
 
     /**
      * @dev Natural exponentiation (e^x) with signed 18 decimal fixed point exponent.
@@ -96,29 +93,28 @@ library LogExpMath {
             require(x >= MIN_NATURAL_EXPONENT && x <= MAX_NATURAL_EXPONENT, "Invalid exponent");
 
             if (x < 0) {
-                // We only handle positive exponents: e^(-x) is computed as 1 / e^x. We can safely make x positive since
-                // it fits in the signed 256 bit range (as it is larger than MIN_NATURAL_EXPONENT).
+                // We only handle positive exponents: e^(-x) is computed as 1 / e^x. We can safely make x positive since it
+                // fits in the signed 256 bit range (as it is larger than MIN_NATURAL_EXPONENT).
                 // Fixed point division requires multiplying by ONE_18.
                 return ((ONE_18 * ONE_18) / exp(-x));
             }
 
-            // First, we use the fact that e^(x+y) = e^x * e^y to decompose x into a sum of powers of two, which we call
-            // x_n, where x_n == 2^(7 - n), and e^x_n = a_n has been precomputed. We choose the first x_n, x0, to equal
-            // 2^7
+            // First, we use the fact that e^(x+y) = e^x * e^y to decompose x into a sum of powers of two, which we call x_n,
+            // where x_n == 2^(7 - n), and e^x_n = a_n has been precomputed. We choose the first x_n, x0, to equal 2^7
             // because all larger powers are larger than MAX_NATURAL_EXPONENT, and therefore not present in the
             // decomposition.
-            // At the end of this process we will have the product of all e^x_n = a_n that apply, and the remainder of
-            // this decomposition, which will be lower than the smallest x_n.
+            // At the end of this process we will have the product of all e^x_n = a_n that apply, and the remainder of this
+            // decomposition, which will be lower than the smallest x_n.
             // exp(x) = k_0 * a_0 * k_1 * a_1 * ... + k_n * a_n * exp(remainder), where each k_n equals either 0 or 1.
             // We mutate x by subtracting x_n, making it the remainder of the decomposition.
 
             // The first two a_n (e^(2^7) and e^(2^6)) are too large if stored as 18 decimal numbers, and could cause
             // intermediate overflows. Instead we store them as plain integers, with 0 decimals.
-            // Additionally, x0 + x1 is larger than MAX_NATURAL_EXPONENT, which means they will not both be present in
-            // the decomposition.
+            // Additionally, x0 + x1 is larger than MAX_NATURAL_EXPONENT, which means they will not both be present in the
+            // decomposition.
 
-            // For each x_n, we test if that term is present in the decomposition (if x is larger than it), and if so
-            // deduct it and compute the accumulated product.
+            // For each x_n, we test if that term is present in the decomposition (if x is larger than it), and if so deduct
+            // it and compute the accumulated product.
 
             int256 firstAN;
             if (x >= x0) {
@@ -135,8 +131,8 @@ library LogExpMath {
             // smaller terms.
             x *= 100;
 
-            // `product` is the accumulated product of all a_n (except a0 and a1), which starts at 20 decimal fixed
-            // point one. Recall that fixed point multiplication requires dividing by ONE_20.
+            // `product` is the accumulated product of all a_n (except a0 and a1), which starts at 20 decimal fixed point
+            // one. Recall that fixed point multiplication requires dividing by ONE_20.
             int256 product = ONE_20;
 
             if (x >= x2) {
@@ -174,8 +170,8 @@ library LogExpMath {
 
             // x10 and x11 are unnecessary here since we have high enough precision already.
 
-            // Now we need to compute e^x, where x is small (in particular, it is smaller than x9). We use the Taylor
-            // series expansion for e^x: 1 + x + (x^2 / 2!) + (x^3 / 3!) + ... + (x^n / n!).
+            // Now we need to compute e^x, where x is small (in particular, it is smaller than x9). We use the Taylor series
+            // expansion for e^x: 1 + x + (x^2 / 2!) + (x^3 / 3!) + ... + (x^n / n!).
 
             int256 seriesSum = ONE_20; // The initial one in the sum, with 20 decimal places.
             int256 term; // Each term in the sum, where the nth term is (x^n / n!).
@@ -223,9 +219,8 @@ library LogExpMath {
             // 12 Taylor terms are sufficient for 18 decimal precision.
 
             // We now have the first a_n (with no decimals), and the product of all other a_n present, and the Taylor
-            // approximation of the exponentiation of the remainder (both with 20 decimals). All that remains is to
-            // multiply all three (one 20 decimal fixed point multiplication, dividing by ONE_20, and one integer
-            // multiplication),
+            // approximation of the exponentiation of the remainder (both with 20 decimals). All that remains is to multiply
+            // all three (one 20 decimal fixed point multiplication, dividing by ONE_20, and one integer multiplication),
             // and then drop two digits to return an 18 decimal value.
 
             return (((product * seriesSum) / ONE_20) * firstAN) / 100;
@@ -271,11 +266,10 @@ library LogExpMath {
             require(x < 2 ** 255, "x out of bounds");
             int256 x_int256 = int256(x);
 
-            // We will compute y * ln(x) in a single step. Depending on the value of x, we can either use ln or ln_36.
-            // In both cases, we leave the division by ONE_18 (due to fixed point multiplication) to the end.
+            // We will compute y * ln(x) in a single step. Depending on the value of x, we can either use ln or ln_36. In
+            // both cases, we leave the division by ONE_18 (due to fixed point multiplication) to the end.
 
-            // This prevents y * ln(x) from overflowing, and at the same time guarantees y fits in the signed 256 bit
-            // range.
+            // This prevents y * ln(x) from overflowing, and at the same time guarantees y fits in the signed 256 bit range.
             require(y < MILD_EXPONENT_BOUND, "y out of bounds");
             int256 y_int256 = int256(y);
 
@@ -283,8 +277,8 @@ library LogExpMath {
             if (LN_36_LOWER_BOUND < x_int256 && x_int256 < LN_36_UPPER_BOUND) {
                 int256 ln_36_x = _ln_36(x_int256);
 
-                // ln_36_x has 36 decimal places, so multiplying by y_int256 isn't as straightforward, since we can't
-                // just bring y_int256 to 36 decimal places, as it might overflow. Instead, we perform two 18 decimal
+                // ln_36_x has 36 decimal places, so multiplying by y_int256 isn't as straightforward, since we can't just
+                // bring y_int256 to 36 decimal places, as it might overflow. Instead, we perform two 18 decimal
                 // multiplications and add the results: one with the first 18 decimals of ln_36_x, and one with the
                 // (downscaled) last 18 decimals.
                 logx_times_y = ((ln_36_x / ONE_18) * y_int256 + ((ln_36_x % ONE_18) * y_int256) / ONE_18);
@@ -295,7 +289,8 @@ library LogExpMath {
 
             // Finally, we compute exp(y * ln(x)) to arrive at x^y
             require(
-                MIN_NATURAL_EXPONENT <= logx_times_y && logx_times_y <= MAX_NATURAL_EXPONENT, "product out of bounds"
+                MIN_NATURAL_EXPONENT <= logx_times_y && logx_times_y <= MAX_NATURAL_EXPONENT,
+                "product out of bounds"
             );
 
             return uint256(exp(logx_times_y));
@@ -309,27 +304,25 @@ library LogExpMath {
         unchecked {
             if (a < ONE_18) {
                 // Since ln(a^k) = k * ln(a), we can compute ln(a) as ln(a) = ln((1/a)^(-1)) = - ln((1/a)). If a is less
-                // than one, 1/a will be greater than one, and this if statement will not be entered in the recursive
-                // call. Fixed point division requires multiplying by ONE_18.
+                // than one, 1/a will be greater than one, and this if statement will not be entered in the recursive call.
+                // Fixed point division requires multiplying by ONE_18.
                 return (-_ln((ONE_18 * ONE_18) / a));
             }
 
-            // First, we use the fact that ln^(a * b) = ln(a) + ln(b) to decompose ln(a) into a sum of powers of two,
-            // which we call x_n, where x_n == 2^(7 - n), which are the natural logarithm of precomputed quantities a_n
-            // (that is,
-            // ln(a_n) = x_n). We choose the first x_n, x0, to equal 2^7 because the exponential of all larger powers
-            // cannot be represented as 18 fixed point decimal numbers in 256 bits, and are therefore larger than a.
-            // At the end of this process we will have the sum of all x_n = ln(a_n) that apply, and the remainder of
-            // this decomposition, which will be lower than the smallest a_n.
+            // First, we use the fact that ln^(a * b) = ln(a) + ln(b) to decompose ln(a) into a sum of powers of two, which
+            // we call x_n, where x_n == 2^(7 - n), which are the natural logarithm of precomputed quantities a_n (that is,
+            // ln(a_n) = x_n). We choose the first x_n, x0, to equal 2^7 because the exponential of all larger powers cannot
+            // be represented as 18 fixed point decimal numbers in 256 bits, and are therefore larger than a.
+            // At the end of this process we will have the sum of all x_n = ln(a_n) that apply, and the remainder of this
+            // decomposition, which will be lower than the smallest a_n.
             // ln(a) = k_0 * x_0 + k_1 * x_1 + ... + k_n * x_n + ln(remainder), where each k_n equals either 0 or 1.
             // We mutate a by subtracting a_n, making it the remainder of the decomposition.
 
-            // For reasons related to how `exp` works, the first two a_n (e^(2^7) and e^(2^6)) are not stored as fixed
-            // point numbers with 18 decimals, but instead as plain integers with 0 decimals, so we need to multiply
-            // them by
+            // For reasons related to how `exp` works, the first two a_n (e^(2^7) and e^(2^6)) are not stored as fixed point
+            // numbers with 18 decimals, but instead as plain integers with 0 decimals, so we need to multiply them by
             // ONE_18 to convert them to fixed point.
-            // For each a_n, we test if that term is present in the decomposition (if a is larger than it), and if so
-            // divide by it and compute the accumulated sum.
+            // For each a_n, we test if that term is present in the decomposition (if a is larger than it), and if so divide
+            // by it and compute the accumulated sum.
 
             int256 sum = 0;
             if (a >= a0 * ONE_18) {
@@ -342,8 +335,7 @@ library LogExpMath {
                 sum += x1;
             }
 
-            // All other a_n and x_n are stored as 20 digit fixed point numbers, so we convert the sum and a to this
-            // format.
+            // All other a_n and x_n are stored as 20 digit fixed point numbers, so we convert the sum and a to this format.
             sum *= 100;
             a *= 100;
 
@@ -399,8 +391,8 @@ library LogExpMath {
                 sum += x11;
             }
 
-            // a is now a small number (smaller than a_11, which roughly equals 1.06). This means we can use a Taylor
-            // series that converges rapidly for values of `a` close to one - the same one used in ln_36.
+            // a is now a small number (smaller than a_11, which roughly equals 1.06). This means we can use a Taylor series
+            // that converges rapidly for values of `a` close to one - the same one used in ln_36.
             // Let z = (a - 1) / (a + 1).
             // ln(a) = 2 * (z + z^3 / 3 + z^5 / 5 + z^7 / 7 + ... + z^(2 * n + 1) / (2 * n + 1))
 
@@ -436,9 +428,8 @@ library LogExpMath {
             // Finally, we multiply by 2 (non fixed point) to compute ln(remainder)
             seriesSum *= 2;
 
-            // We now have the sum of all x_n present, and the Taylor approximation of the logarithm of the remainder
-            // (both with 20 decimals). All that remains is to sum these two, and then drop two digits to return a 18
-            // decimal
+            // We now have the sum of all x_n present, and the Taylor approximation of the logarithm of the remainder (both
+            // with 20 decimals). All that remains is to sum these two, and then drop two digits to return a 18 decimal
             // value.
 
             return (sum + seriesSum) / 100;
@@ -446,8 +437,7 @@ library LogExpMath {
     }
 
     /**
-     * @dev Intrnal high precision (36 decimal places) natural logarithm (ln(x)) with signed 18 decimal fixed point
-     * argument,
+     * @dev Intrnal high precision (36 decimal places) natural logarithm (ln(x)) with signed 18 decimal fixed point argument,
      * for x close to one.
      *
      * Should only be used if x is between LN_36_LOWER_BOUND and LN_36_UPPER_BOUND.

package/contracts/cross-chain/FixedPricePTAMM.sol

@@ -1,14 +1,14 @@
 // SPDX-License-Identifier: SEE LICENSE IN LICENSE
 pragma solidity ^0.8.19;
 
-import {IPChainlinkOracleEssential} from "../interfaces/IPChainlinkOracleEssential.sol";
 import {IPFixedPricePTAMM, IPFixedPricePTAMMSwapCallback} from "../interfaces/IPFixedPricePTAMM.sol";
+import {IPChainlinkOracleEssential} from "../interfaces/IPChainlinkOracleEssential.sol";
 
 import {ReentrancyGuardUpgradeable} from "@openzeppelin/contracts-upgradeable/security/ReentrancyGuardUpgradeable.sol";
 
+import {PMath} from "../core/libraries/math/PMath.sol";
 import {BoringOwnableUpgradeableV2} from "../core/libraries/BoringOwnableUpgradeableV2.sol";
 import {TokenHelper} from "../core/libraries/TokenHelper.sol";
-import {PMath} from "../core/libraries/math/PMath.sol";
 import {UUPSUpgradeable} from "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol";
 
 contract FixedPricePTAMM is
@@ -55,36 +55,35 @@ contract FixedPricePTAMM is
         }
     }
 
-    function priceOracle(address PT, address token)
-        public
-        view
-        returns (IPChainlinkOracleEssential oracle, uint256 multiplier)
-    {
+    function priceOracle(
+        address PT,
+        address token
+    ) public view returns (IPChainlinkOracleEssential oracle, uint256 multiplier) {
         oracle = IPChainlinkOracleEssential($().priceOracle[PT][token].oracle);
         multiplier = $().priceOracle[PT][token].multiplier;
 
         if (address(oracle) == address(0)) revert OracleNotSet(PT, token);
     }
 
-    function previewSwapPtForExactToken(address PT, address token, uint256 exactTokenOut)
-        public
-        view
-        returns (uint256 amountPtIn)
-    {
+    function previewSwapPtForExactToken(
+        address PT,
+        address token,
+        uint256 exactTokenOut
+    ) public view returns (uint256 amountPtIn) {
         (IPChainlinkOracleEssential oracle, uint256 multiplier) = priceOracle(PT, token);
-        (, int256 rawPrice,,,) = oracle.latestRoundData();
+        (, int256 rawPrice, , , ) = oracle.latestRoundData();
 
         // ceil(exactTokenOut / (rawPrice * multiplier))
         return (exactTokenOut * PMath.ONE * PMath.ONE).rawDivUp(rawPrice.Uint() * multiplier);
     }
 
-    function previewSwapExactPtForToken(address PT, uint256 exactPtIn, address token)
-        public
-        view
-        returns (uint256 amountTokenOut)
-    {
+    function previewSwapExactPtForToken(
+        address PT,
+        uint256 exactPtIn,
+        address token
+    ) public view returns (uint256 amountTokenOut) {
         (IPChainlinkOracleEssential oracle, uint256 multiplier) = priceOracle(PT, token);
-        (, int256 rawPrice,,,) = oracle.latestRoundData();
+        (, int256 rawPrice, , , ) = oracle.latestRoundData();
 
         // exactPtIn * rawPrice * multiplier
         return (exactPtIn * rawPrice.Uint() * multiplier) / (PMath.ONE * PMath.ONE);
@@ -100,27 +99,31 @@ contract FixedPricePTAMM is
         return _swapPtForExactToken(receiver, PT, token, exactTokenOut, data, false);
     }
 
-    function swapExactPtForToken(address receiver, address PT, uint256 exactPtIn, address token, bytes calldata data)
-        external
-        nonReentrant
-        returns (uint256 netTokenOut)
-    {
+    function swapExactPtForToken(
+        address receiver,
+        address PT,
+        uint256 exactPtIn,
+        address token,
+        bytes calldata data
+    ) external nonReentrant returns (uint256 netTokenOut) {
         return _swapExactPtForToken(receiver, PT, exactPtIn, token, data, false);
     }
 
-    function transferInThenSwapPtForExactToken(address receiver, address PT, address token, uint256 exactTokenOut)
-        external
-        nonReentrant
-        returns (uint256 netPtIn)
-    {
+    function transferInThenSwapPtForExactToken(
+        address receiver,
+        address PT,
+        address token,
+        uint256 exactTokenOut
+    ) external nonReentrant returns (uint256 netPtIn) {
         return _swapPtForExactToken(receiver, PT, token, exactTokenOut, "", true);
     }
 
-    function transferInThenSwapExactPtForToken(address receiver, address PT, uint256 exactPtIn, address token)
-        external
-        nonReentrant
-        returns (uint256 netPtIn)
-    {
+    function transferInThenSwapExactPtForToken(
+        address receiver,
+        address PT,
+        uint256 exactPtIn,
+        address token
+    ) external nonReentrant returns (uint256 netPtIn) {
         return _swapExactPtForToken(receiver, PT, exactPtIn, token, "", true);
     }
 
@@ -158,9 +161,8 @@ contract FixedPricePTAMM is
         uint256 exactTokenOut,
         bytes memory data
     ) internal {
-        if ($().totalToken[token] < exactTokenOut) {
+        if ($().totalToken[token] < exactTokenOut)
             revert InsufficientTokenForTrade(token, $().totalToken[token], exactTokenOut);
-        }
 
         _transferOut(token, receiver, exactTokenOut);
         $().totalToken[token] -= exactTokenOut;
@@ -170,9 +172,8 @@ contract FixedPricePTAMM is
         }
 
         $().totalToken[PT] += exactPtIn;
-        if (_selfBalance(PT) < $().totalToken[PT]) {
+        if (_selfBalance(PT) < $().totalToken[PT])
             revert InsufficientPtReceived(PT, _selfBalance(PT), $().totalToken[PT]);
-        }
 
         emit Swap(msg.sender, receiver, PT, exactPtIn, token, exactTokenOut);
     }

package/contracts/cross-chain/factory/hub/PendlePTOFTAdapterFactory.sol

@@ -1,8 +1,8 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity ^0.8.0;
 
-import {BoringOwnableUpgradeableV2} from "../../../core/libraries/BoringOwnableUpgradeableV2.sol";
 import {IPPTOFTAdapterFactory} from "../../../interfaces/IPPTOFTAdapterFactory.sol";
+import {BoringOwnableUpgradeableV2} from "../../../core/libraries/BoringOwnableUpgradeableV2.sol";
 import {OFTAdapterImpl} from "../../oftImpl/hub/OFTAdapterImpl.sol";
 
 import {UUPSUpgradeable} from "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol";

package/contracts/cross-chain/oftImpl/spoke/PendleBridgedPrincipalToken.sol

@@ -2,7 +2,7 @@
 pragma solidity ^0.8.19;
 
 import {IPBridgedPrincipalToken} from "../../../interfaces/IPBridgedPrincipalToken.sol";
-import {IOFT, OFT, OFTCore} from "@layerzerolabs/oft-evm/contracts/OFT.sol";
+import {OFT, OFTCore, IOFT} from "@layerzerolabs/oft-evm/contracts/OFT.sol";
 import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
 import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
 

package/contracts/deprecated/VeDistributor/PendleFeeDistributor.sol

@@ -1,16 +1,16 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity ^0.8.17;
 
-import "../../LiquidityMining/libraries/VeHistoryLib.sol";
-import "../../LiquidityMining/libraries/WeekMath.sol";
-import "../../core/libraries/ArrayLib.sol";
+import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
+import "@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.sol";
 import "../../core/libraries/BoringOwnableUpgradeableV2.sol";
 import "../../core/libraries/Errors.sol";
 import "../../interfaces/IPFeeDistributor.sol";
-import "../../interfaces/IPVotingController.sol";
 import "../../interfaces/IPVotingEscrowMainchain.sol";
-import "@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.sol";
-import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
+import "../../interfaces/IPVotingController.sol";
+import "../../LiquidityMining/libraries/WeekMath.sol";
+import "../../LiquidityMining/libraries/VeHistoryLib.sol";
+import "../../core/libraries/ArrayLib.sol";
 
 contract PendleFeeDistributor is UUPSUpgradeable, BoringOwnableUpgradeableV2, IPFeeDistributor {
     using SafeERC20 for IERC20;
@@ -73,9 +73,7 @@ contract PendleFeeDistributor is UUPSUpgradeable, BoringOwnableUpgradeableV2, IP
             totalFunded += amounts[i].sum();
         }
 
-        if (totalFunded != totalAmountToFund) {
-            revert Errors.FDTotalAmountFundedNotMatch(totalFunded, totalAmountToFund);
-        }
+        if (totalFunded != totalAmountToFund) revert Errors.FDTotalAmountFundedNotMatch(totalFunded, totalAmountToFund);
 
         IERC20(token).transferFrom(msg.sender, address(this), totalFunded);
     }
@@ -106,7 +104,7 @@ contract PendleFeeDistributor is UUPSUpgradeable, BoringOwnableUpgradeableV2, IP
 
     function claimReward(address user, address[] calldata pools) external returns (uint256[] memory amountRewardOut) {
         amountRewardOut = new uint256[](pools.length);
-        for (uint256 i = 0; i < pools.length;) {
+        for (uint256 i = 0; i < pools.length; ) {
             amountRewardOut[i] = _accumulateUserReward(pools[i], user);
             unchecked {
                 i++;
@@ -119,11 +117,10 @@ contract PendleFeeDistributor is UUPSUpgradeable, BoringOwnableUpgradeableV2, IP
         return allPools;
     }
 
-    function _accumulateUserReward(address pool, address user)
-        internal
-        ensureValidPool(pool)
-        returns (uint256 totalReward)
-    {
+    function _accumulateUserReward(
+        address pool,
+        address user
+    ) internal ensureValidPool(pool) returns (uint256 totalReward) {
         uint256 length = _getUserCheckpointLength(pool, user);
         if (length == 0) return 0;
 

package/contracts/deprecated/VeDistributor/PendleFeeDistributorV2.sol

@@ -1,13 +1,13 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity ^0.8.17;
 
+import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
+import "@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.sol";
+import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
 import "../../core/libraries/BoringOwnableUpgradeableV2.sol";
-import "../../core/libraries/Errors.sol";
 import "../../core/libraries/TokenHelper.sol";
+import "../../core/libraries/Errors.sol";
 import "../../interfaces/IPFeeDistributorV2.sol";
-import "@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.sol";
-import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
-import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
 
 contract PendleFeeDistributorV2 is UUPSUpgradeable, BoringOwnableUpgradeableV2, IPFeeDistributorV2, TokenHelper {
     bytes32 public merkleRoot;
@@ -29,10 +29,11 @@ contract PendleFeeDistributorV2 is UUPSUpgradeable, BoringOwnableUpgradeableV2,
         __BoringOwnableV2_init(_owner);
     }
 
-    function claimRetail(address receiver, uint256 totalAccrued, bytes32[] calldata proof)
-        external
-        returns (uint256 amountOut)
-    {
+    function claimRetail(
+        address receiver,
+        uint256 totalAccrued,
+        bytes32[] calldata proof
+    ) external returns (uint256 amountOut) {
         address user = msg.sender;
         if (!_verifyMerkleData(user, totalAccrued, proof)) revert Errors.InvalidMerkleProof();
 
@@ -46,10 +47,10 @@ contract PendleFeeDistributorV2 is UUPSUpgradeable, BoringOwnableUpgradeableV2,
         emit Claimed(user, amountOut);
     }
 
-    function claimProtocol(address receiver, address[] calldata pools)
-        external
-        returns (uint256 totalAmountOut, uint256[] memory amountsOut)
-    {
+    function claimProtocol(
+        address receiver,
+        address[] calldata pools
+    ) external returns (uint256 totalAmountOut, uint256[] memory amountsOut) {
         unchecked {
             address user = msg.sender;
 
@@ -67,8 +68,7 @@ contract PendleFeeDistributorV2 is UUPSUpgradeable, BoringOwnableUpgradeableV2,
             }
 
             claimed[user] += totalAmountOut;
-            assert(claimed[user] <= protocol[user].totalAccrued); // important invariant, must always hold regardless of
-            // claimable mapping
+            assert(claimed[user] <= protocol[user].totalAccrued); // important invariant, must always hold regardless of claimable mapping
 
             // transfer ETH last
             _transferOut(NATIVE, receiver, totalAmountOut);
@@ -76,11 +76,10 @@ contract PendleFeeDistributorV2 is UUPSUpgradeable, BoringOwnableUpgradeableV2,
         }
     }
 
-    function getProtocolClaimables(address user, address[] calldata pools)
-        external
-        view
-        returns (uint256[] memory claimables)
-    {
+    function getProtocolClaimables(
+        address user,
+        address[] calldata pools
+    ) external view returns (uint256[] memory claimables) {
         unchecked {
             uint256 nPools = pools.length;
             claimables = new uint256[](nPools);
@@ -121,8 +120,12 @@ contract PendleFeeDistributorV2 is UUPSUpgradeable, BoringOwnableUpgradeableV2,
 
     function updateProtocolClaimable(UpdateProtocolStruct calldata ele) public onlyOwner {
         unchecked {
-            (address user, uint256[] calldata topUps, address[] calldata pools, bytes32[] calldata proof) =
-                (ele.user, ele.topUps, ele.pools, ele.proof);
+            (address user, uint256[] calldata topUps, address[] calldata pools, bytes32[] calldata proof) = (
+                ele.user,
+                ele.topUps,
+                ele.pools,
+                ele.proof
+            );
 
             uint256 nPools = pools.length;
             if (nPools != topUps.length) revert Errors.ArrayLengthMismatch();

package/contracts/interfaces/ILayerZeroEndpoint.sol

@@ -7,11 +7,9 @@ interface ILayerZeroEndpoint {
     // @param _dstChainId - the destination chain identifier
     // @param _destination - the address on destination chain (in bytes). address length/format may vary by chains
     // @param _payload - a custom bytes payload to send to the destination contract
-    // @param _refundAddress - if the source transaction is cheaper than the amount of value passed, refund the
-    // additional amount to this address @param _zroPaymentAddress - the address of the ZRO token holder who would pay
-    // for the transaction
-    // @param _adapterParams - parameters for custom functionality. e.g. receive airdropped native gas from the relayer
-    // on destination
+    // @param _refundAddress - if the source transaction is cheaper than the amount of value passed, refund the additional amount to this address
+    // @param _zroPaymentAddress - the address of the ZRO token holder who would pay for the transaction
+    // @param _adapterParams - parameters for custom functionality. e.g. receive airdropped native gas from the relayer on destination
     function send(
         uint16 _dstChainId,
         bytes calldata _destination,

package/contracts/interfaces/IPActionCallbackV3.sol

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity ^0.8.0;
 
-import "./IPLimitRouter.sol";
 import "./IPMarketSwapCallback.sol";
+import "./IPLimitRouter.sol";
 
 interface IPActionCallbackV3 is IPMarketSwapCallback, IPLimitRouterCallback {}

package/contracts/interfaces/IPActionInfoStatic.sol

@@ -29,7 +29,9 @@ interface IPActionInfoStatic {
     function getPY(address py) external view returns (address pt, address yt);
 
     /// can be SY, PY or Market
-    function getTokensInOut(address token) external view returns (address[] memory tokensIn, address[] memory tokensOut);
+    function getTokensInOut(
+        address token
+    ) external view returns (address[] memory tokensIn, address[] memory tokensOut);
 
     function getUserSYInfo(address sy, address user) external returns (UserSYInfo memory res);