@pendle/core-v2 2.27.0 → 2.28.0

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";
 

package/contracts/router/swap-aggregator/oneinch/I1inchAggregationRouterV5.sol

@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: MIT
 
-pragma solidity 0.8.17;
+pragma solidity ^0.8.0;
 
 import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
 

package/contracts/router/swap-aggregator/oneinch/OneInchAggregationRouterHelper.sol

@@ -1,6 +1,5 @@
 // SPDX-License-Identifier: MIT
-
-pragma solidity 0.8.17;
+pragma solidity ^0.8.0;
 
 import "./I1inchAggregationRouterV5.sol";
 import "../../../core/libraries/Errors.sol";

package/deployments/1-markets/EUSD-DEC2024.json

@@ -0,0 +1,10 @@
+{
+    "name": "SY eUSD",
+    "SY": "0x7e16e4253CE4a1C96422a9567B23b4b5Ebc207F1",
+    "YT": "0x82cC3DA7D315C47557147f44984C3E805C34789c",
+    "PT": "0x6B44fC15953fb65be99b1d32E25cFAA9362c8173",
+    "market": "0x23aEfCeD9255aD3560CDaa4A10CbFe9EC230DC5A",
+    "expiry": 1735171200,
+    "scalarRoot": "78713517750000000000",
+    "initAnchor": "1068515534000000000"
+}

package/deployments/42161-markets/HLP-JUN2024.json

@@ -0,0 +1,10 @@
+{
+    "name": "SY HLP",
+    "SY": "0xF18011766Cf11D905e93ed5626838d44c7FA14B7",
+    "YT": "0x9D090Ef4Aafd0ACB821113a7689d5794e50bD047",
+    "PT": "0xC595c9c28D78bb347C8177dFbB820484e2D99A66",
+    "market": "0x0F249f735647992572eEa231fc24b35F7B6b34e1",
+    "expiry": 1719446400,
+    "scalarRoot": "13080544730000000000",
+    "initAnchor": "1172865531000000000"
+}

package/deployments/core.ts

@@ -0,0 +1,29 @@
+import ethCoreJSON from './1-core.json';
+
+export interface PendleCore {
+    PENDLE: string;
+    yieldContractFactory: string;
+    marketFactory: string;
+    bulkSellerFactory: string;
+    bulkSellerOffchain: string;
+    router: string;
+    routerStatic: string;
+    vePendle: string;
+    gaugeController: string;
+}
+
+export interface PendleCoreMainchain extends PendleCore {
+    senderEndpoint: string;
+    votingController: string;
+    feeDistributor: string;
+}
+
+export interface PendleCoreSidechain extends PendleCore {
+    receiverEndpoint: string;
+}
+
+const ethCore: PendleCoreMainchain = ethCoreJSON;
+
+export const pendleCore = {
+    ethereum: ethCore,
+};

package/deployments/index.ts

@@ -0,0 +1,4 @@
+export * from './core';
+export * from './markets';
+export * from './misc';
+export * from '../typechain-types';

package/deployments/markets/ape-june-29-2023.ts

@@ -0,0 +1,3 @@
+import { MarketDeployment } from './types';
+import marketApeJune292022JSON from '../1-markets/APE-JUNE-29.json';
+export const apeJune292022: MarketDeployment = marketApeJune292022JSON;

package/deployments/markets/balancer-reth-dec-28-2023.ts

@@ -0,0 +1,3 @@
+import { MarketDeployment } from './types';
+import marketBalancerRethDec282023JSON from '../1-markets/BALANCER-LP-AURA-RETH-WETH-28DEC.json';
+export const balancerRethDec282023: MarketDeployment = marketBalancerRethDec282023JSON;

package/deployments/markets/balancer-wsteth-jun-27-2024.ts

@@ -0,0 +1,3 @@
+import { MarketDeployment } from './types';
+import marketBalancerWstEthJun272024JSON from '../1-markets/BALANCER-LP-AURA-WSTETH-WETH-JUN272024.json';
+export const balancerWstEthJun272024: MarketDeployment = marketBalancerWstEthJun272024JSON;

package/deployments/markets/curve-fraxusdc-march-30-2023.ts

@@ -0,0 +1,3 @@
+import { MarketDeployment } from './types';
+import marketCurveFraxUsdcMarch302023JSON from '../1-markets/FRAXUSDC-CURVELP-MARCH30.json';
+export const curveFraxUsdcMarch302023: MarketDeployment = marketCurveFraxUsdcMarch302023JSON;

package/deployments/markets/index.ts

@@ -0,0 +1,17 @@
+import { apeJune292022 } from './ape-june-29-2023';
+import { balancerRethDec282023 } from './balancer-reth-dec-28-2023';
+import { balancerWstEthJun272024 } from './balancer-wsteth-jun-27-2024';
+import { curveFraxUsdcMarch302023 } from './curve-fraxusdc-march-30-2023';
+import { looksMarch302023 } from './looks-march-30-2023';
+import { stEthJune292023 } from './steth-june-29-2023';
+import { stEthMarch302023 } from './steth-march-30-2023';
+
+export const markets = {
+    apeJune292022,
+    balancerRethDec282023,
+    balancerWstEthJun272024,
+    curveFraxUsdcMarch302023,
+    looksMarch302023,
+    stEthJune292023,
+    stEthMarch302023,
+};

package/deployments/markets/looks-march-30-2023.ts

@@ -0,0 +1,3 @@
+import { MarketDeployment } from './types';
+import marketLooksMarch302023JSON from '../1-markets/LOOKS-STAKING-MARCH30.json';
+export const looksMarch302023: MarketDeployment = marketLooksMarch302023JSON;

package/deployments/markets/steth-june-29-2023.ts

@@ -0,0 +1,3 @@
+import { MarketDeployment } from './types';
+import marketStEthJune292023JSON from '../1-markets/STETH-JUNE29.json';
+export const stEthJune292023: MarketDeployment = marketStEthJune292023JSON;

package/deployments/markets/steth-march-30-2023.ts

@@ -0,0 +1,3 @@
+import { MarketDeployment } from './types';
+import marketStEthMarch302023JSON from '../1-markets/STETH-MARCH30.json';
+export const stEthMarch302023: MarketDeployment = marketStEthMarch302023JSON;

package/deployments/markets/types.ts

@@ -0,0 +1,9 @@
+export interface MarketDeployment {
+    name: string;
+    SY: string;
+    YT: string;
+    PT: string;
+    market: string;
+    expiry: number;
+    bulkSeller?: string;
+}

package/deployments/misc.ts

@@ -0,0 +1,23 @@
+import { BigNumber as BN, utils } from 'ethers';
+
+export const MISC_CONSTS = {
+    RONE: BN.from(2).pow(40),
+    ONE_E_12: BN.from(10).pow(12),
+    ONE_E_18: BN.from(10).pow(18),
+    INF: BN.from(2).pow(256).sub(1),
+    ZERO_BYTES: utils.formatBytes32String(''),
+    ZERO_ADDRESS: '0x0000000000000000000000000000000000000000',
+    DUMMY_ADDRESS: '0xDEADbeEfEEeEEEeEEEeEEeeeeeEeEEeeeeEEEEeE',
+    ONE_HOUR: BN.from(3600),
+    ONE_DAY: BN.from(86400),
+    ONE_WEEK: BN.from(86400 * 7),
+    FIFTEEN_DAY: BN.from(86400 * 15),
+    ONE_MONTH: BN.from(2592000),
+    THREE_MONTH: BN.from(2592000 * 3),
+    FIVE_MONTH: BN.from(2592000 * 5),
+    SIX_MONTH: BN.from(2592000 * 6),
+    ONE_QUARTER: BN.from(7884000),
+    ONE_YEAR: BN.from(31536000),
+    END_OF_2023: BN.from(1703721600),
+    JUNE_OF_2022: BN.from(1656547200),
+};