@pendle/core-v2 2.26.5 → 2.28.0

package/contracts/offchain-helpers/PendleMulticallV2.sol

@@ -0,0 +1,87 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.17;
+
+contract PendleMulticallV2 {
+    error CallThenRevertError(bool success, bytes res);
+
+    struct Call {
+        address target;
+        bytes callData;
+    }
+
+    struct Result {
+        bool success;
+        bytes returnData;
+    }
+
+    function aggregate(Call[] calldata calls) public payable virtual {
+        uint256 length = calls.length;
+        Call calldata call;
+        for (uint256 i = 0; i < length;) {
+            call = calls[i];
+
+            (bool success, bytes memory resp) = call.target.call(call.callData);
+            if (!success) {
+                assembly {
+                    revert(add(32, resp), mload(resp))
+                }
+            }
+
+            unchecked {
+                ++i;
+            }
+        }
+    }
+
+    function tryAggregate(bool requireSuccess, uint256 gasLimit, Call[] calldata calls)
+        public
+        payable
+        returns (Result[] memory returnData)
+    {
+        uint256 length = calls.length;
+        returnData = new Result[](length);
+        Call calldata call;
+        for (uint256 i = 0; i < length;) {
+            call = calls[i];
+
+            (bool success, bytes memory resp) = call.target.call{gas: gasLimit}(calls[i].callData);
+            if (!success && requireSuccess) {
+                assembly {
+                    revert(add(32, resp), mload(resp))
+                }
+            }
+
+            returnData[i] = Result(success, resp);
+
+            unchecked {
+                ++i;
+            }
+        }
+    }
+
+    function tryAggregateRevert(uint256 gasLimit, Call[] calldata calls)
+        public
+        payable
+        returns (bytes[] memory returnData)
+    {
+        uint256 length = calls.length;
+        returnData = new bytes[](length);
+        Call calldata call;
+        for (uint256 i = 0; i < length;) {
+            call = calls[i];
+
+            (, returnData[i]) = address(this).delegatecall{gas: gasLimit}(
+                abi.encodeWithSignature("callThenRevert(address,bytes)", call.target, call.callData)
+            );
+
+            unchecked {
+                ++i;
+            }
+        }
+    }
+
+    function callThenRevert(address target, bytes memory callData) public {
+        (bool success, bytes memory resp) = target.call(callData);
+        revert CallThenRevertError(success, resp);
+    }
+}

package/contracts/offchain-helpers/PtAndLpToAsset.sol

@@ -1,13 +1,13 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.17;
+pragma solidity ^0.8.0;
 
 import "../interfaces/IPMarket.sol";
-import "../core/libraries/math/Math.sol";
+import "../core/libraries/math/PMath.sol";
 import "../core/Market/MarketMathCore.sol";
 
 contract PtAndLpToAsset {
-    using Math for int256;
-    using Math for uint256;
+    using PMath for int256;
+    using PMath for uint256;
     using MarketMathCore for MarketState;
 
     function getLpToAssetRate(IPMarket market) public view returns (uint256 lpToAssetRate) {
@@ -44,7 +44,7 @@ contract PtAndLpToAsset {
             timeToExpiry
         );
 
-        ptToAssetRate = uint256(Math.IONE.divDown(assetToPtRate));
+        ptToAssetRate = uint256(PMath.IONE.divDown(assetToPtRate));
     }
 
     function _getPYIndexCurrent(IPMarket market) private view returns (uint256) {
@@ -56,7 +56,7 @@ contract PtAndLpToAsset {
         if (YT.doCacheIndexSameBlock() && YT.pyIndexLastUpdatedBlock() == block.number) {
             return pyIndexStored;
         } else {
-            return Math.max(syIndex, pyIndexStored);
+            return PMath.max(syIndex, pyIndexStored);
         }
     }
 }

package/contracts/offchain-helpers/errors/SDKErrorsDirectory.sol

@@ -1,4 +1,4 @@
-pragma solidity 0.8.17;
+pragma solidity ^0.8.0;
 
 library SDKErrorsDirectory {
     error BulkInsufficientSyForTrade(uint256 currentAmount, uint256 requiredAmount);

package/contracts/offchain-helpers/router-static/base/ActionMarketAuxStatic.sol

@@ -7,8 +7,8 @@ import "./StorageLayout.sol";
 
 contract ActionMarketAuxStatic is IPActionMarketAuxStatic {
     using MarketMathCore for MarketState;
-    using Math for int256;
-    using Math for uint256;
+    using PMath for int256;
+    using PMath for uint256;
     using LogExpMath for int256;
     using PYIndexLib for PYIndex;
     using PYIndexLib for IPYieldToken;
@@ -39,7 +39,7 @@ contract ActionMarketAuxStatic is IPActionMarketAuxStatic {
         view
         returns (uint256)
     {
-        if (IPMarket(market).isExpired()) return Math.ONE;
+        if (IPMarket(market).isExpired()) return PMath.ONE;
 
         MarketPreCompute memory comp = state.getMarketPreCompute(
             _pyIndex(market),
@@ -60,7 +60,7 @@ contract ActionMarketAuxStatic is IPActionMarketAuxStatic {
         view
         returns (uint256)
     {
-        if (IPMarket(market).isExpired()) return Math.ONE;
+        if (IPMarket(market).isExpired()) return PMath.ONE;
 
         int256 netPtToAccount = netPtOut;
         MarketState memory state = _readState(market);
@@ -79,7 +79,7 @@ contract ActionMarketAuxStatic is IPActionMarketAuxStatic {
 
         if (netPtToAccount > 0) {
             int256 postFeeExchangeRate = preFeeExchangeRate.divDown(comp.feeRate);
-            if (postFeeExchangeRate < Math.IONE)
+            if (postFeeExchangeRate < PMath.IONE)
                 revert Errors.MarketExchangeRateBelowOne(postFeeExchangeRate);
             return postFeeExchangeRate.Uint();
         } else {
@@ -167,7 +167,7 @@ contract ActionMarketAuxStatic is IPActionMarketAuxStatic {
             timeToExpiry
         );
 
-        ptToAssetRate = uint256(Math.IONE.divDown(assetToPtRate));
+        ptToAssetRate = uint256(PMath.IONE.divDown(assetToPtRate));
     }
 
     function _getPtImpliedYield(address market) internal view returns (int256) {
@@ -187,7 +187,7 @@ contract ActionMarketAuxStatic is IPActionMarketAuxStatic {
         // 1 yt + 1/EX Asset = 1 Asset
         // 1 yt = 1 Asset - 1/EX Asset
         // 1 yt = (EX - 1) / EX Asset
-        return (ptAssetExchangeRate - Math.ONE).divDown(ptAssetExchangeRate);
+        return (ptAssetExchangeRate - PMath.ONE).divDown(ptAssetExchangeRate);
     }
 
     function _readState(address market) internal view returns (MarketState memory) {

package/contracts/offchain-helpers/router-static/base/ActionMarketCoreStatic.sol

@@ -6,8 +6,8 @@ import "../../../interfaces/IPRouterStatic.sol";
 import "./StorageLayout.sol";
 
 contract ActionMarketCoreStatic is StorageLayout, IPActionMarketCoreStatic {
-    using Math for uint256;
-    using Math for int256;
+    using PMath for uint256;
+    using PMath for int256;
 
     using LogExpMath for int256;
     using PYIndexLib for PYIndex;
@@ -305,7 +305,7 @@ contract ActionMarketCoreStatic is StorageLayout, IPActionMarketCoreStatic {
             netSyOut = netSyFromBurn + _pyIndex(market).assetToSy(netPtFromBurn);
             netSyFee = 0;
             priceImpact = 0;
-            exchangeRateAfter = Math.ONE;
+            exchangeRateAfter = PMath.ONE;
         } else {
             (netSyFromSwap, netSyFee, ) = state.swapExactPtForSy(
                 _pyIndex(market),

package/contracts/offchain-helpers/router-static/base/ActionMintRedeemStatic.sol

@@ -7,7 +7,7 @@ import "../../../interfaces/IPBulkSellerFactory.sol";
 import "./StorageLayout.sol";
 
 contract ActionMintRedeemStatic is StorageLayout, IPActionMintRedeemStatic {
-    using Math for uint256;
+    using PMath for uint256;
     using BulkSellerMathCore for BulkSellerState;
 
     function mintPyFromSyStatic(address YT, uint256 netSyToMint)
@@ -148,8 +148,8 @@ contract ActionMintRedeemStatic is StorageLayout, IPActionMintRedeemStatic {
         }
 
         // Liquidity check
-        uint256 postFeeRateTokenToSy = state.rateTokenToSy.mulDown(Math.ONE - state.feeRate);
-        uint256 postFeeRateSyToToken = state.rateSyToToken.mulDown(Math.ONE - state.feeRate);
+        uint256 postFeeRateTokenToSy = state.rateTokenToSy.mulDown(PMath.ONE - state.feeRate);
+        uint256 postFeeRateSyToToken = state.rateSyToToken.mulDown(PMath.ONE - state.feeRate);
         if (
             netTokenIn.mulDown(postFeeRateTokenToSy) > state.totalSy ||
             netSyIn.mulDown(postFeeRateSyToToken) > state.totalToken
@@ -177,7 +177,7 @@ contract ActionMintRedeemStatic is StorageLayout, IPActionMintRedeemStatic {
         if (YT.doCacheIndexSameBlock() && YT.pyIndexLastUpdatedBlock() == block.number) {
             return pyIndexStored;
         } else {
-            return Math.max(syIndex, pyIndexStored);
+            return PMath.max(syIndex, pyIndexStored);
         }
     }
 

package/contracts/oracles/PendleLpOracleLib.sol

@@ -1,12 +1,12 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.17;
+pragma solidity ^0.8.0;
 
 import "./PendlePtOracleLib.sol";
 
 library PendleLpOracleLib {
     using PendlePtOracleLib for IPMarket;
-    using Math for uint256;
-    using Math for int256;
+    using PMath for uint256;
+    using PMath for int256;
     using MarketMathCore for MarketState;
 
     /**
@@ -44,7 +44,7 @@ library PendleLpOracleLib {
             );
 
             int256 tradeSize = (cParam.mulDown(comp.totalAsset) - state.totalPt).divDown(
-                Math.IONE + cParam.divDown(rateHypTrade)
+                PMath.IONE + cParam.divDown(rateHypTrade)
             );
 
             totalHypotheticalAsset =
@@ -61,7 +61,7 @@ library PendleLpOracleLib {
         MarketState memory state,
         uint32 duration
     ) private view returns (int256 rateOracle, int256 rateHypTrade) {
-        rateOracle = Math.IONE.divDown(market.getPtToAssetRateRaw(duration).Int());
+        rateOracle = PMath.IONE.divDown(market.getPtToAssetRateRaw(duration).Int());
         int256 rateLastTrade = MarketMathCore._getExchangeRateFromImpliedRate(
             state.lastLnImpliedRate,
             state.expiry - block.timestamp

package/contracts/oracles/PendlePtOracleLib.sol

@@ -1,12 +1,12 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.17;
+pragma solidity ^0.8.0;
 
 import "../interfaces/IPMarket.sol";
-import "../core/libraries/math/Math.sol";
+import "../core/libraries/math/PMath.sol";
 
 library PendlePtOracleLib {
-    using Math for uint256;
-    using Math for int256;
+    using PMath for uint256;
+    using PMath for int256;
 
     /**
      * This function returns the twap rate PT/Asset on market, but take into account the current rate of SY
@@ -23,13 +23,13 @@ library PendlePtOracleLib {
         uint256 expiry = market.expiry();
 
         if (expiry <= block.timestamp) {
-            return Math.ONE;
+            return PMath.ONE;
         } else {
             uint256 lnImpliedRate = _getMarketLnImpliedRate(market, duration);
             uint256 timeToExpiry = expiry - block.timestamp;
             uint256 assetToPtRate =
                 MarketMathCore._getExchangeRateFromImpliedRate(lnImpliedRate, timeToExpiry).Uint();
-            return Math.ONE.divDown(assetToPtRate);
+            return PMath.ONE.divDown(assetToPtRate);
         }
     }
 
@@ -46,7 +46,7 @@ library PendlePtOracleLib {
         if (YT.doCacheIndexSameBlock() && YT.pyIndexLastUpdatedBlock() == block.number) {
             pyIndex = pyIndexStored;
         } else {
-            pyIndex = Math.max(syIndex, pyIndexStored);
+            pyIndex = PMath.max(syIndex, pyIndexStored);
         }
     }
 

package/contracts/oracles/samples/PendleLpGlpOracle.sol

@@ -4,7 +4,7 @@ pragma solidity 0.8.17;
 import "../PendleLpOracleLib.sol";
 import "../../interfaces/IPPtOracle.sol";
 import "../../interfaces/GMX/IGlpManager.sol";
-import "../../core/libraries/math/Math.sol";
+import "../../core/libraries/math/PMath.sol";
 
 /**
  * @notice The LP/GLP price gotten from the market using the LpOracleLib is multiplied with the USD price of GLP read from

package/contracts/oracles/samples/PendlePtGlpOracle.sol

@@ -4,7 +4,7 @@ pragma solidity 0.8.17;
 import "../PendlePtOracleLib.sol";
 import "../../interfaces/IPPtOracle.sol";
 import "../../interfaces/GMX/IGlpManager.sol";
-import "../../core/libraries/math/Math.sol";
+import "../../core/libraries/math/PMath.sol";
 
 /**
  * @notice The returned price from this contract is multiply with the USD price of GLP read from

package/contracts/oracles/samples/PendlePtUsdChainlinkOracle.sol

@@ -2,7 +2,7 @@
 pragma solidity 0.8.17;
 
 import "../../interfaces/IPPtOracle.sol";
-import "../../core/libraries/math/Math.sol";
+import "../../core/libraries/math/PMath.sol";
 import { AggregatorV2V3Interface as IChainlinkAggregator } from "@chainlink/contracts/src/v0.8/interfaces/AggregatorV2V3Interface.sol";
 
 /**
@@ -44,7 +44,7 @@ contract PendlePtUsdChainlinkOracle {
     function getPtPrice() external view virtual returns (uint256) {
         uint256 ptRate = IPPtOracle(ptOracle).getPtToAssetRate(market, twapDuration);
         uint256 assetPrice = _getUnderlyingAssetPrice();
-        return (assetPrice * ptRate) / Math.ONE;
+        return (assetPrice * ptRate) / PMath.ONE;
     }
 
     function _getUnderlyingAssetPrice() internal view virtual returns (uint256) {

package/contracts/router/ActionAddRemoveLiq.sol

@@ -15,8 +15,8 @@ import "../core/libraries/Errors.sol";
  * This is because swapping and adding liquidity are not allowed on an expired market.
  */
 contract ActionAddRemoveLiq is IPActionAddRemoveLiq, ActionBaseMintRedeem {
-    using Math for uint256;
-    using Math for int256;
+    using PMath for uint256;
+    using PMath for int256;
     using MarketMathCore for MarketState;
     using MarketApproxPtInLib for MarketState;
     using MarketApproxPtOutLib for MarketState;

package/contracts/router/ActionMintRedeem.sol

@@ -8,8 +8,8 @@ import "../core/libraries/Errors.sol";
 
 contract ActionMintRedeem is IPActionMintRedeem, ActionBaseMintRedeem {
     using MarketMathCore for MarketState;
-    using Math for uint256;
-    using Math for int256;
+    using PMath for uint256;
+    using PMath for int256;
 
     /**
      * @notice swaps input token for SY-mintable tokens (if needed), then mints SY from such

package/contracts/router/ActionSwapPT.sol

@@ -11,8 +11,8 @@ contract ActionSwapPT is IPActionSwapPT, ActionBaseMintRedeem {
     using MarketMathCore for MarketState;
     using MarketApproxPtInLib for MarketState;
     using MarketApproxPtOutLib for MarketState;
-    using Math for uint256;
-    using Math for int256;
+    using PMath for uint256;
+    using PMath for int256;
     using PYIndexLib for IPYieldToken;
 
     /**

package/contracts/router/ActionSwapYT.sol

@@ -12,8 +12,8 @@ import "./base/ActionBaseCallback.sol";
 
 /// @dev All swap actions will revert if market is expired
 contract ActionSwapYT is ActionBaseCallback, IPActionSwapYT, ActionBaseMintRedeem {
-    using Math for uint256;
-    using Math for int256;
+    using PMath for uint256;
+    using PMath for int256;
     using MarketMathCore for MarketState;
     using MarketApproxPtInLib for MarketState;
     using MarketApproxPtOutLib for MarketState;

package/contracts/router/base/ActionBaseCallback.sol

@@ -13,8 +13,8 @@ import "./CallbackHelper.sol";
 import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
 
 abstract contract ActionBaseCallback is IPMarketSwapCallback, CallbackHelper, TokenHelper {
-    using Math for int256;
-    using Math for uint256;
+    using PMath for int256;
+    using PMath for uint256;
     using PYIndexLib for PYIndex;
     using PYIndexLib for IPYieldToken;
 

package/contracts/router/base/MarketApproxLib.sol

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.17;
+pragma solidity ^0.8.0;
 
-import "../../core/libraries/math/Math.sol";
+import "../../core/libraries/math/PMath.sol";
 import "../../core/Market/MarketMathCore.sol";
 
 struct ApproxParams {
@@ -31,8 +31,8 @@ struct ApproxParams {
 library MarketApproxPtInLib {
     using MarketMathCore for MarketState;
     using PYIndexLib for PYIndex;
-    using Math for uint256;
-    using Math for int256;
+    using PMath for uint256;
+    using PMath for int256;
     using LogExpMath for int256;
 
     /**
@@ -52,7 +52,7 @@ library MarketApproxPtInLib {
         MarketPreCompute memory comp = market.getMarketPreCompute(index, blockTime);
         if (approx.guessOffchain == 0) {
             // no limit on min
-            approx.guessMax = Math.min(approx.guessMax, calcMaxPtIn(market, comp));
+            approx.guessMax = PMath.min(approx.guessMax, calcMaxPtIn(market, comp));
             validateApprox(approx);
         }
 
@@ -61,7 +61,7 @@ library MarketApproxPtInLib {
             (uint256 netSyOut, uint256 netSyFee, ) = calcSyOut(market, comp, index, guess);
 
             if (netSyOut >= minSyOut) {
-                if (Math.isAGreaterApproxB(netSyOut, minSyOut, approx.eps))
+                if (PMath.isAGreaterApproxB(netSyOut, minSyOut, approx.eps))
                     return (guess, netSyOut, netSyFee);
                 approx.guessMax = guess;
             } else {
@@ -89,8 +89,8 @@ library MarketApproxPtInLib {
     ) internal pure returns (uint256 /*netYtOut*/, uint256 /*netSyFee*/) {
         MarketPreCompute memory comp = market.getMarketPreCompute(index, blockTime);
         if (approx.guessOffchain == 0) {
-            approx.guessMin = Math.max(approx.guessMin, index.syToAsset(exactSyIn));
-            approx.guessMax = Math.min(approx.guessMax, calcMaxPtIn(market, comp));
+            approx.guessMin = PMath.max(approx.guessMin, index.syToAsset(exactSyIn));
+            approx.guessMax = PMath.min(approx.guessMax, calcMaxPtIn(market, comp));
             validateApprox(approx);
         }
 
@@ -107,7 +107,7 @@ library MarketApproxPtInLib {
             uint256 netSyToPull = netSyToTokenizePt - netSyOut;
 
             if (netSyToPull <= exactSyIn) {
-                if (Math.isASmallerApproxB(netSyToPull, exactSyIn, approx.eps))
+                if (PMath.isASmallerApproxB(netSyToPull, exactSyIn, approx.eps))
                     return (guess, netSyFee);
                 approx.guessMin = guess;
             } else {
@@ -139,8 +139,8 @@ library MarketApproxPtInLib {
         MarketPreCompute memory comp = market.getMarketPreCompute(index, blockTime);
         if (approx.guessOffchain == 0) {
             // no limit on min
-            approx.guessMax = Math.min(approx.guessMax, calcMaxPtIn(market, comp));
-            approx.guessMax = Math.min(approx.guessMax, totalPtIn);
+            approx.guessMax = PMath.min(approx.guessMax, calcMaxPtIn(market, comp));
+            approx.guessMax = PMath.min(approx.guessMax, totalPtIn);
             validateApprox(approx);
             require(market.totalLp != 0, "no existing lp");
         }
@@ -156,7 +156,7 @@ library MarketApproxPtInLib {
 
             ) = calcNumerators(market, index, totalPtIn, comp, guess);
 
-            if (Math.isAApproxB(syNumerator, ptNumerator, approx.eps))
+            if (PMath.isAApproxB(syNumerator, ptNumerator, approx.eps))
                 return (guess, netSyOut, netSyFee);
 
             if (syNumerator <= ptNumerator) {
@@ -230,8 +230,8 @@ library MarketApproxPtInLib {
     {
         MarketPreCompute memory comp = market.getMarketPreCompute(index, blockTime);
         if (approx.guessOffchain == 0) {
-            approx.guessMin = Math.max(approx.guessMin, exactPtIn);
-            approx.guessMax = Math.min(approx.guessMax, calcMaxPtIn(market, comp));
+            approx.guessMin = PMath.max(approx.guessMin, exactPtIn);
+            approx.guessMax = PMath.min(approx.guessMax, calcMaxPtIn(market, comp));
             validateApprox(approx);
         }
 
@@ -246,7 +246,7 @@ library MarketApproxPtInLib {
             uint256 netPtToPull = guess - netAssetOut;
 
             if (netPtToPull <= exactPtIn) {
-                if (Math.isASmallerApproxB(netPtToPull, exactPtIn, approx.eps))
+                if (PMath.isASmallerApproxB(netPtToPull, exactPtIn, approx.eps))
                     return (netAssetOut, guess, netSyFee);
                 approx.guessMin = guess;
             } else {
@@ -283,7 +283,7 @@ library MarketApproxPtInLib {
     /// INTENDED TO BE CALLED BY WHEN GUESS.OFFCHAIN == 0 ONLY ///
 
     function validateApprox(ApproxParams memory approx) internal pure {
-        if (approx.guessMin > approx.guessMax || approx.eps > Math.ONE)
+        if (approx.guessMin > approx.guessMax || approx.eps > PMath.ONE)
             revert Errors.ApproxParamsInvalid(approx.guessMin, approx.guessMax, approx.eps);
     }
 
@@ -317,7 +317,7 @@ library MarketApproxPtInLib {
         );
 
         int256 part2 = sumPt.divDown(diffAssetPtToMarket).ln();
-        int256 part3 = Math.IONE.divDown(comp.rateScalar);
+        int256 part3 = PMath.IONE.divDown(comp.rateScalar);
 
         return comp.rateAnchor - (part1 - part2).mulDown(part3);
     }
@@ -326,8 +326,8 @@ library MarketApproxPtInLib {
 library MarketApproxPtOutLib {
     using MarketMathCore for MarketState;
     using PYIndexLib for PYIndex;
-    using Math for uint256;
-    using Math for int256;
+    using PMath for uint256;
+    using PMath for int256;
     using LogExpMath for int256;
 
     /**
@@ -347,7 +347,7 @@ library MarketApproxPtOutLib {
         MarketPreCompute memory comp = market.getMarketPreCompute(index, blockTime);
         if (approx.guessOffchain == 0) {
             // no limit on min
-            approx.guessMax = Math.min(approx.guessMax, calcMaxPtOut(comp, market.totalPt));
+            approx.guessMax = PMath.min(approx.guessMax, calcMaxPtOut(comp, market.totalPt));
             validateApprox(approx);
         }
 
@@ -357,7 +357,7 @@ library MarketApproxPtOutLib {
             (uint256 netSyIn, uint256 netSyFee, ) = calcSyIn(market, comp, index, guess);
 
             if (netSyIn <= exactSyIn) {
-                if (Math.isASmallerApproxB(netSyIn, exactSyIn, approx.eps))
+                if (PMath.isASmallerApproxB(netSyIn, exactSyIn, approx.eps))
                     return (guess, netSyFee);
                 approx.guessMin = guess;
             } else {
@@ -386,7 +386,7 @@ library MarketApproxPtOutLib {
         MarketPreCompute memory comp = market.getMarketPreCompute(index, blockTime);
         if (approx.guessOffchain == 0) {
             // no limit on min
-            approx.guessMax = Math.min(approx.guessMax, calcMaxPtOut(comp, market.totalPt));
+            approx.guessMax = PMath.min(approx.guessMax, calcMaxPtOut(comp, market.totalPt));
             validateApprox(approx);
         }
 
@@ -399,7 +399,7 @@ library MarketApproxPtOutLib {
             uint256 netSyOut = index.assetToSy(guess - netAssetToRepay);
 
             if (netSyOut >= minSyOut) {
-                if (Math.isAGreaterApproxB(netSyOut, minSyOut, approx.eps))
+                if (PMath.isAGreaterApproxB(netSyOut, minSyOut, approx.eps))
                     return (guess, netSyOut, netSyFee);
                 approx.guessMax = guess;
             } else {
@@ -441,7 +441,7 @@ library MarketApproxPtOutLib {
         MarketPreCompute memory comp = a.market.getMarketPreCompute(a.index, a.blockTime);
         if (a.approx.guessOffchain == 0) {
             // no limit on min
-            a.approx.guessMax = Math.min(a.approx.guessMax, calcMaxPtOut(comp, a.market.totalPt));
+            a.approx.guessMax = PMath.min(a.approx.guessMax, calcMaxPtOut(comp, a.market.totalPt));
             validateApprox(a.approx);
             require(a.market.totalLp != 0, "no existing lp");
         }
@@ -477,7 +477,7 @@ library MarketApproxPtOutLib {
                 syNumerator = (a.totalSyIn - netSyIn) * newTotalPt;
             }
 
-            if (Math.isAApproxB(ptNumerator, syNumerator, a.approx.eps))
+            if (PMath.isAApproxB(ptNumerator, syNumerator, a.approx.eps))
                 return (guess, netSyIn, netSyFee);
 
             if (ptNumerator <= syNumerator) {
@@ -513,8 +513,8 @@ library MarketApproxPtOutLib {
     {
         MarketPreCompute memory comp = market.getMarketPreCompute(index, blockTime);
         if (approx.guessOffchain == 0) {
-            approx.guessMin = Math.max(approx.guessMin, exactYtIn);
-            approx.guessMax = Math.min(approx.guessMax, calcMaxPtOut(comp, market.totalPt));
+            approx.guessMin = PMath.max(approx.guessMin, exactYtIn);
+            approx.guessMax = PMath.min(approx.guessMax, calcMaxPtOut(comp, market.totalPt));
             validateApprox(approx);
         }
 
@@ -526,7 +526,7 @@ library MarketApproxPtOutLib {
             uint256 netYtToPull = index.syToAssetUp(netSyOwed);
 
             if (netYtToPull <= exactYtIn) {
-                if (Math.isASmallerApproxB(netYtToPull, exactYtIn, approx.eps))
+                if (PMath.isASmallerApproxB(netYtToPull, exactYtIn, approx.eps))
                     return (guess - netYtToPull, guess, netSyFee);
                 approx.guessMin = guess;
             } else {
@@ -561,7 +561,7 @@ library MarketApproxPtOutLib {
         int256 totalPt
     ) internal pure returns (uint256) {
         int256 logitP = (comp.feeRate - comp.rateAnchor).mulDown(comp.rateScalar).exp();
-        int256 proportion = logitP.divDown(logitP + Math.IONE);
+        int256 proportion = logitP.divDown(logitP + PMath.IONE);
         int256 numerator = proportion.mulDown(totalPt + comp.totalAsset);
         int256 maxPtOut = totalPt - numerator;
         // only get 99.9% of the theoretical max to accommodate some precision issues
@@ -575,7 +575,7 @@ library MarketApproxPtOutLib {
     }
 
     function validateApprox(ApproxParams memory approx) internal pure {
-        if (approx.guessMin > approx.guessMax || approx.eps > Math.ONE)
+        if (approx.guessMin > approx.guessMax || approx.eps > PMath.ONE)
             revert Errors.ApproxParamsInvalid(approx.guessMin, approx.guessMax, approx.eps);
     }
 }

package/contracts/router/swap-aggregator/IPSwapAggregator.sol

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.17;
+pragma solidity ^0.8.0;
 
 struct SwapData {
     SwapType swapType;

package/contracts/router/swap-aggregator/kyberswap/IExecutorHelper.sol

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: MIT
-pragma solidity 0.8.17;
+pragma solidity ^0.8.0;
 
 interface IExecutorHelper {
     struct Swap {

package/contracts/router/swap-aggregator/kyberswap/IMetaAggregationRouterV2.sol

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: MIT
-pragma solidity 0.8.17;
+pragma solidity ^0.8.0;
 
 import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
 import { IAggregationExecutor } from "./IAggregationExecutor.sol";

package/contracts/router/swap-aggregator/kyberswap/KyberInputScalingHelper.sol

@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
 
-pragma solidity 0.8.17;
 import "./IMetaAggregationRouterV2.sol";
 import "./IExecutorHelper.sol";
 import "./ScalingDataLib.sol";

package/contracts/router/swap-aggregator/kyberswap/ScalingDataLib.sol

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: MIT
-pragma solidity 0.8.17;
+pragma solidity ^0.8.0;
 
 import "./IExecutorHelper.sol";