@pendle/core-v2 2.22.0 → 2.22.2

package/contracts/oracles/PendleLpOracleLib.sol

@@ -3,34 +3,42 @@ pragma solidity 0.8.17;
 
 import "./PendlePtOracleLib.sol";
 
-// Reference: https://file.notion.so/f/s/15d1406b-0d81-41a4-8ac3-9b56e30fdf50/LP_Oracle_Doc.pdf?id=201fc56f-959b-4836-9511-73852e166816&table=block&spaceId=33abd05a-56a2-4ce6-8673-929c5984a0fd&expirationTimestamp=1683863581610&signature=IY3jlxvXkWRJZhsccYpQdQaKlm1_NUIb1ypDmuaR7hI&downloadName=LP_Oracle_Doc.pdf
-
 library PendleLpOracleLib {
     using PendlePtOracleLib for IPMarket;
-    using PYIndexLib for PYIndex;
     using Math for uint256;
     using Math for int256;
     using MarketMathCore for MarketState;
 
     /**
-     * This function returns the approximated twap rate LP/Asset on market
+      * This function returns the approximated twap rate LP/asset on market, but take into account the current rate of SY
+     This is to account for special cases where underlying asset becomes insolvent and has decreasing exchangeRate
      * @param market market to get rate from
      * @param duration twap duration
-     *
      */
-    function getLpToAssetRate(
+    function getLpToAssetRate(IPMarket market, uint32 duration) internal view returns (uint256) {
+        (uint256 syIndex, uint256 pyIndex) = PendlePtOracleLib.getSYandPYIndexCurrent(market);
+        uint256 lpToAssetRateRaw = _getLpToAssetRateRaw(market, duration, pyIndex);
+        return (lpToAssetRateRaw * syIndex) / pyIndex;
+    }
+
+    function _getLpToAssetRateRaw(
         IPMarket market,
-        uint32 duration
-    ) internal view returns (uint256 lpToAssetRate) {
+        uint32 duration,
+        uint256 pyIndex
+    ) private view returns (uint256 lpToAssetRateRaw) {
         MarketState memory state = market.readState(address(0));
-        MarketPreCompute memory comp = _getMarketPreCompute(market, state);
+
+        MarketPreCompute memory comp = state.getMarketPreCompute(
+            PYIndex.wrap(pyIndex),
+            block.timestamp
+        );
 
         int256 totalHypotheticalAsset;
         if (state.expiry <= block.timestamp) {
             // 1 PT = 1 Asset post-expiry
             totalHypotheticalAsset = state.totalPt + comp.totalAsset;
         } else {
-            (int256 rateOracle, int256 rateHypTrade) = _getPtRates(market, state, duration);
+            (int256 rateOracle, int256 rateHypTrade) = _getPtRatesRaw(market, state, duration);
             int256 cParam = LogExpMath.exp(
                 comp.rateScalar.mulDown((rateOracle - comp.rateAnchor))
             );
@@ -45,46 +53,19 @@ library PendleLpOracleLib {
                 (state.totalPt + tradeSize).divDown(rateOracle);
         }
 
-        lpToAssetRate = _calcLpPrice(totalHypotheticalAsset, state.totalLp).Uint();
+        lpToAssetRateRaw = totalHypotheticalAsset.divDown(state.totalLp).Uint();
     }
 
-    function _getMarketPreCompute(
-        IPMarket market,
-        MarketState memory state
-    ) private view returns (MarketPreCompute memory) {
-        return state.getMarketPreCompute(_getPYIndexCurrent(market), block.timestamp);
-    }
-
-    function _getPYIndexCurrent(IPMarket market) private view returns (PYIndex) {
-        (IStandardizedYield SY, , IPYieldToken YT) = market.readTokens();
-        uint256 ytIndex = YT.pyIndexStored();
-        uint256 pyIndexCurrent;
-        if (YT.doCacheIndexSameBlock() && YT.pyIndexLastUpdatedBlock() == block.number) {
-            pyIndexCurrent = ytIndex;
-        } else {
-            uint256 syIndex = SY.exchangeRate();
-            pyIndexCurrent = Math.max(syIndex, ytIndex);
-        }
-        return PYIndex.wrap(pyIndexCurrent);
-    }
-
-    function _getPtRates(
+    function _getPtRatesRaw(
         IPMarket market,
         MarketState memory state,
         uint32 duration
     ) private view returns (int256 rateOracle, int256 rateHypTrade) {
-        rateOracle = Math.IONE.divDown(market.getPtToAssetRate(duration).Int());
+        rateOracle = Math.IONE.divDown(market.getPtToAssetRateRaw(duration).Int());
         int256 rateLastTrade = MarketMathCore._getExchangeRateFromImpliedRate(
             state.lastLnImpliedRate,
             state.expiry - block.timestamp
         );
         rateHypTrade = (rateLastTrade + rateOracle) / 2;
     }
-
-    function _calcLpPrice(
-        int256 totalHypotheticalAsset,
-        int256 totalLp
-    ) private pure returns (int256) {
-        return totalHypotheticalAsset.divDown(totalLp);
-    }
 }

package/contracts/oracles/PendlePtOracleLib.sol

@@ -6,28 +6,48 @@ import "../core/libraries/math/Math.sol";
 
 library PendlePtOracleLib {
     using Math for uint256;
+    using Math for int256;
 
     /**
-     * This function returns the twap rate PT/Asset on market
+     * This function returns the twap rate PT/Asset on market, but take into account the current rate of SY
+     This is to account for special cases where underlying asset becomes insolvent and has decreasing exchangeRate
      * @param market market to get rate from
      * @param duration twap duration
      */
-    function getPtToAssetRate(IPMarket market, uint32 duration)
-        internal
-        view
-        returns (uint256 ptToAssetRate)
-    {
+    function getPtToAssetRate(IPMarket market, uint32 duration) internal view returns (uint256) {
+        (uint256 syIndex, uint256 pyIndex) = getSYandPYIndexCurrent(market);
+        return (getPtToAssetRateRaw(market,duration) * syIndex) / pyIndex;
+    }
+
+    function getPtToAssetRateRaw(IPMarket market, uint32 duration) internal view returns (uint256) {
         uint256 expiry = market.expiry();
+
         if (expiry <= block.timestamp) {
-            return _getPtToAssetRatePostExpiry(market);
+            return Math.ONE;
+        } else {
+            uint256 lnImpliedRate = _getMarketLnImpliedRate(market, duration);
+            uint256 timeToExpiry = expiry - block.timestamp;
+            uint256 assetToPtRate =
+                MarketMathCore._getExchangeRateFromImpliedRate(lnImpliedRate, timeToExpiry).Uint();
+            return Math.ONE.divDown(assetToPtRate);
         }
-        uint256 lnImpliedRate = _getMarketLnImpliedRate(market, duration);
-        uint256 timeToExpiry = expiry - block.timestamp;
-        uint256 assetToPtRate = uint256(
-            MarketMathCore._getExchangeRateFromImpliedRate(lnImpliedRate, timeToExpiry)
-        );
+    }
+
+    function getSYandPYIndexCurrent(IPMarket market)
+        internal
+        view
+        returns (uint256 syIndex, uint256 pyIndex)
+    {
+        (IStandardizedYield SY, , IPYieldToken YT) = market.readTokens();
 
-        ptToAssetRate = Math.ONE.divDown(assetToPtRate);
+        syIndex = SY.exchangeRate();
+        uint256 pyIndexStored = YT.pyIndexStored();
+
+        if (YT.doCacheIndexSameBlock() && YT.pyIndexLastUpdatedBlock() == block.number) {
+            pyIndex = pyIndexStored;
+        } else {
+            pyIndex = Math.max(syIndex, pyIndexStored);
+        }
     }
 
     function _getMarketLnImpliedRate(IPMarket market, uint32 duration)
@@ -41,19 +61,4 @@ library PendlePtOracleLib {
         uint216[] memory lnImpliedRateCumulative = market.observe(durations);
         return (lnImpliedRateCumulative[1] - lnImpliedRateCumulative[0]) / duration;
     }
-
-    function _getPtToAssetRatePostExpiry(IPMarket market) private view returns (uint256) {
-        (IStandardizedYield SY, , IPYieldToken YT) = market.readTokens();
-
-        uint256 syIndex = SY.exchangeRate();
-        uint256 pyIndexCurrent;
-
-        if (YT.doCacheIndexSameBlock() && YT.pyIndexLastUpdatedBlock() == block.number) {
-            pyIndexCurrent = YT.pyIndexStored();
-        } else {
-            pyIndexCurrent = Math.max(syIndex, YT.pyIndexStored());
-        }
-
-        return syIndex.divDown(pyIndexCurrent);
-    }
 }

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

@@ -23,7 +23,6 @@ interface IExecutorHelper {
         address tokenOut;
         address recipient;
         uint256 collectAmount; // amount that should be transferred to the pool
-        uint256 limitReturnAmount;
         uint32 swapFee;
         uint32 feePrecision;
         uint32 tokenWeightInput;
@@ -36,7 +35,6 @@ interface IExecutorHelper {
         uint8 tokenIndexFrom;
         uint8 tokenIndexTo;
         uint256 dx;
-        uint256 minDy;
         uint256 poolLength;
         address poolLp;
         bool isSaddle; // true: saddle, false: stable
@@ -49,20 +47,18 @@ interface IExecutorHelper {
         int128 tokenIndexFrom;
         int128 tokenIndexTo;
         uint256 dx;
-        uint256 minDy;
         bool usePoolUnderlying;
         bool useTriCrypto;
     }
 
-    struct UniSwapV3ProMM {
+    struct UniswapV3KSElastic {
         address recipient;
         address pool;
         address tokenIn;
         address tokenOut;
         uint256 swapAmount;
-        uint256 limitReturnAmount;
         uint160 sqrtPriceLimitX96;
-        bool isUniV3; // true = UniV3, false = ProMM
+        bool isUniV3; // true = UniV3, false = KSElastic
     }
 
     struct BalancerV2 {
@@ -71,7 +67,6 @@ interface IExecutorHelper {
         address assetIn;
         address assetOut;
         uint256 amount;
-        uint256 limit;
     }
 
     struct DODO {
@@ -80,7 +75,6 @@ interface IExecutorHelper {
         address tokenFrom;
         address tokenTo;
         uint256 amount;
-        uint256 minReceiveQuote;
         address sellHelper;
         bool isSellBase;
         bool isVersion2;
@@ -91,7 +85,6 @@ interface IExecutorHelper {
         address tokenIn;
         address tokenOut;
         uint256 amount;
-        uint256 minOut;
         address receiver;
     }
 
@@ -102,7 +95,6 @@ interface IExecutorHelper {
         bytes32 sourceCurrencyKey;
         uint256 sourceAmount;
         bytes32 destinationCurrencyKey;
-        uint256 minAmount;
         bool useAtomicExchange;
     }
 
@@ -112,7 +104,6 @@ interface IExecutorHelper {
         address tokenOut;
         address recipient;
         uint256 collectAmount; // amount that should be transferred to the pool
-        uint256 limitReturnAmount;
     }
 
     struct PSM {
@@ -129,111 +120,112 @@ interface IExecutorHelper {
         bool isWrapping;
     }
 
-    function executeUniSwap(
-        uint256 index,
-        bytes memory data,
-        uint256 previousAmountOut
-    ) external payable returns (uint256);
-
-    function executeStableSwap(
-        uint256 index,
-        bytes memory data,
-        uint256 previousAmountOut
-    ) external payable returns (uint256);
-
-    function executeCurveSwap(
-        uint256 index,
-        bytes memory data,
-        uint256 previousAmountOut
-    ) external payable returns (uint256);
-
-    function executeKyberDMMSwap(
-        uint256 index,
-        bytes memory data,
-        uint256 previousAmountOut
-    ) external payable returns (uint256);
-
-    function executeUniV3ProMMSwap(
-        uint256 index,
-        bytes memory data,
-        uint256 previousAmountOut
-    ) external payable returns (uint256);
-
-    function executeRfqSwap(
-        uint256 index,
-        bytes memory data,
-        uint256 previousAmountOut
-    ) external payable returns (uint256);
-
-    function executeBalV2Swap(
-        uint256 index,
-        bytes memory data,
-        uint256 previousAmountOut
-    ) external payable returns (uint256);
-
-    function executeDODOSwap(
-        uint256 index,
-        bytes memory data,
-        uint256 previousAmountOut
-    ) external payable returns (uint256);
-
-    function executeVelodromeSwap(
-        uint256 index,
-        bytes memory data,
-        uint256 previousAmountOut
-    ) external payable returns (uint256);
-
-    function executeGMXSwap(
-        uint256 index,
-        bytes memory data,
-        uint256 previousAmountOut
-    ) external payable returns (uint256);
-
-    function executePlatypusSwap(
-        uint256 index,
-        bytes memory data,
-        uint256 previousAmountOut
-    ) external payable returns (uint256);
-
-    function executeWrappedstETHSwap(
-        uint256 index,
-        bytes memory data,
-        uint256 previousAmountOut
-    ) external payable returns (uint256);
-
-    function executeSynthetixSwap(
-        uint256 index,
-        bytes memory data,
-        uint256 previousAmountOut
-    ) external payable returns (uint256);
-
-    function executeHashflowSwap(
-        uint256 index,
-        bytes memory data,
-        uint256 previousAmountOut
-    ) external payable returns (uint256);
-
-    function executePSMSwap(
-        uint256 index,
-        bytes memory data,
-        uint256 previousAmountOut
-    ) external payable returns (uint256);
-
-    function executeFraxSwap(
-        uint256 index,
-        bytes memory data,
-        uint256 previousAmountOut
-    ) external payable returns (uint256);
-
-    function executeCamelotSwap(
-        uint256 index,
-        bytes memory data,
-        uint256 previousAmountOut
-    ) external payable returns (uint256);
-
-    function executeKyberLimitOrder(
-        uint256 index,
-        bytes memory data,
-        uint256 previousAmountOut
-    ) external payable returns (uint256);
+    struct Maverick {
+        address pool;
+        address tokenIn;
+        address tokenOut;
+        address recipient;
+        uint256 swapAmount;
+        uint256 sqrtPriceLimitD18;
+    }
+
+    function executeUniswap(bytes memory data, uint256 flagsAndPrevAmountOut)
+        external
+        payable
+        returns (uint256);
+
+    function executeStableSwap(bytes memory data, uint256 flagsAndPrevAmountOut)
+        external
+        payable
+        returns (uint256);
+
+    function executeCurve(bytes memory data, uint256 flagsAndPrevAmountOut)
+        external
+        payable
+        returns (uint256);
+
+    function executeKSClassic(bytes memory data, uint256 flagsAndPrevAmountOut)
+        external
+        payable
+        returns (uint256);
+
+    function executeUniV3KSElastic(bytes memory data, uint256 flagsAndPrevAmountOut)
+        external
+        payable
+        returns (uint256);
+
+    function executeRfq(bytes memory data, uint256 flagsAndPrevAmountOut)
+        external
+        payable
+        returns (uint256);
+
+    function executeBalV2(bytes memory data, uint256 flagsAndPrevAmountOut)
+        external
+        payable
+        returns (uint256);
+
+    function executeDODO(bytes memory data, uint256 flagsAndPrevAmountOut)
+        external
+        payable
+        returns (uint256);
+
+    function executeVelodrome(bytes memory data, uint256 flagsAndPrevAmountOut)
+        external
+        payable
+        returns (uint256);
+
+    function executeGMX(bytes memory data, uint256 flagsAndPrevAmountOut)
+        external
+        payable
+        returns (uint256);
+
+    function executePlatypus(bytes memory data, uint256 flagsAndPrevAmountOut)
+        external
+        payable
+        returns (uint256);
+
+    function executeWrappedstETH(bytes memory data, uint256 flagsAndPrevAmountOut)
+        external
+        payable
+        returns (uint256);
+
+    function executeStEth(bytes memory data, uint256 flagsAndPrevAmountOut)
+        external
+        payable
+        returns (uint256);
+
+    function executeSynthetix(bytes memory data, uint256 flagsAndPrevAmountOut)
+        external
+        payable
+        returns (uint256);
+
+    function executeHashflow(bytes memory data, uint256 flagsAndPrevAmountOut)
+        external
+        payable
+        returns (uint256);
+
+    function executePSM(bytes memory data, uint256 flagsAndPrevAmountOut)
+        external
+        payable
+        returns (uint256);
+
+    function executeFrax(bytes memory data, uint256 flagsAndPrevAmountOut)
+        external
+        payable
+        returns (uint256);
+
+    function executeCamelot(bytes memory data, uint256 flagsAndPrevAmountOut)
+        external
+        payable
+        returns (uint256);
+
+    function executeKyberLimitOrder(bytes memory data, uint256 flagsAndPrevAmountOut)
+        external
+        payable
+        returns (uint256);
+
+    function executeMaverick(bytes memory data, uint256 flagsAndPrevAmountOut)
+        external
+        payable
+        returns (uint256);
 }

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

@@ -2,7 +2,6 @@
 
 pragma solidity 0.8.17;
 import "./IMetaAggregationRouterV2.sol";
-import "./IHashflow.sol";
 import "./IExecutorHelper.sol";
 import "./ScalingDataLib.sol";
 
@@ -22,7 +21,7 @@ abstract contract KyberInputScalingHelper {
 
     struct Swap {
         bytes data;
-        bytes4 functionSelector;
+        bytes32 selectorAndFlags; // [selector (32 bits) + flags (224 bits)]; selector is 4 most significant bytes; flags are stored in 4 least significant bytes.
     }
 
     struct SimpleSwapData {
@@ -37,7 +36,6 @@ abstract contract KyberInputScalingHelper {
         Swap[][] swapSequences;
         address tokenIn;
         address tokenOut;
-        uint256 minTotalAmountOut;
         address to;
         uint256 deadline;
         bytes positiveSlippageData;
@@ -156,7 +154,6 @@ abstract contract KyberInputScalingHelper {
         uint256 newAmount
     ) internal pure returns (bytes memory) {
         SwapExecutorDescription memory executorDesc = abi.decode(data, (SwapExecutorDescription));
-        executorDesc.minTotalAmountOut = (executorDesc.minTotalAmountOut * newAmount) / oldAmount;
         executorDesc.positiveSlippageData = _scaledPositiveSlippageFeeData(
             executorDesc.positiveSlippageData,
             oldAmount,
@@ -166,44 +163,48 @@ abstract contract KyberInputScalingHelper {
         uint256 nSequences = executorDesc.swapSequences.length;
         for (uint256 i = 0; i < nSequences; ) {
             Swap memory swap = executorDesc.swapSequences[i][0];
-            bytes4 functionSelector = swap.functionSelector;
+            bytes4 functionSelector = bytes4(swap.selectorAndFlags);
 
-            if (functionSelector == IExecutorHelper.executeUniSwap.selector) {
+            if (functionSelector == IExecutorHelper.executeUniswap.selector) {
                 swap.data = ScalingDataLib.newUniSwap(swap.data, oldAmount, newAmount);
             } else if (functionSelector == IExecutorHelper.executeStableSwap.selector) {
                 swap.data = ScalingDataLib.newStableSwap(swap.data, oldAmount, newAmount);
-            } else if (functionSelector == IExecutorHelper.executeCurveSwap.selector) {
+            } else if (functionSelector == IExecutorHelper.executeCurve.selector) {
                 swap.data = ScalingDataLib.newCurveSwap(swap.data, oldAmount, newAmount);
-            } else if (functionSelector == IExecutorHelper.executeKyberDMMSwap.selector) {
+            } else if (functionSelector == IExecutorHelper.executeKSClassic.selector) {
                 swap.data = ScalingDataLib.newKyberDMM(swap.data, oldAmount, newAmount);
-            } else if (functionSelector == IExecutorHelper.executeUniV3ProMMSwap.selector) {
+            } else if (functionSelector == IExecutorHelper.executeUniV3KSElastic.selector) {
                 swap.data = ScalingDataLib.newUniV3ProMM(swap.data, oldAmount, newAmount);
-            } else if (functionSelector == IExecutorHelper.executeRfqSwap.selector) {
+            } else if (functionSelector == IExecutorHelper.executeRfq.selector) {
                 revert("InputScalingHelper: Can not scale RFQ swap");
-            } else if (functionSelector == IExecutorHelper.executeBalV2Swap.selector) {
+            } else if (functionSelector == IExecutorHelper.executeBalV2.selector) {
                 swap.data = ScalingDataLib.newBalancerV2(swap.data, oldAmount, newAmount);
-            } else if (functionSelector == IExecutorHelper.executeWrappedstETHSwap.selector) {
+            } else if (functionSelector == IExecutorHelper.executeWrappedstETH.selector) {
                 swap.data = ScalingDataLib.newWrappedstETHSwap(swap.data, oldAmount, newAmount);
-            } else if (functionSelector == IExecutorHelper.executeDODOSwap.selector) {
+            } else if (functionSelector == IExecutorHelper.executeStEth.selector) {
+                swap.data = ScalingDataLib.newStETHSwap(swap.data, oldAmount, newAmount);
+            } else if (functionSelector == IExecutorHelper.executeDODO.selector) {
                 swap.data = ScalingDataLib.newDODO(swap.data, oldAmount, newAmount);
-            } else if (functionSelector == IExecutorHelper.executeVelodromeSwap.selector) {
+            } else if (functionSelector == IExecutorHelper.executeVelodrome.selector) {
                 swap.data = ScalingDataLib.newVelodrome(swap.data, oldAmount, newAmount);
-            } else if (functionSelector == IExecutorHelper.executeGMXSwap.selector) {
+            } else if (functionSelector == IExecutorHelper.executeGMX.selector) {
                 swap.data = ScalingDataLib.newGMX(swap.data, oldAmount, newAmount);
-            } else if (functionSelector == IExecutorHelper.executeSynthetixSwap.selector) {
+            } else if (functionSelector == IExecutorHelper.executeSynthetix.selector) {
                 swap.data = ScalingDataLib.newSynthetix(swap.data, oldAmount, newAmount);
-            } else if (functionSelector == IExecutorHelper.executeHashflowSwap.selector) {
+            } else if (functionSelector == IExecutorHelper.executeHashflow.selector) {
                 revert("InputScalingHelper: Can not scale RFQ swap");
-            } else if (functionSelector == IExecutorHelper.executeCamelotSwap.selector) {
+            } else if (functionSelector == IExecutorHelper.executeCamelot.selector) {
                 swap.data = ScalingDataLib.newCamelot(swap.data, oldAmount, newAmount);
             } else if (functionSelector == IExecutorHelper.executeKyberLimitOrder.selector) {
                 revert("InputScalingHelper: Can not scale RFQ swap");
-            } else if (functionSelector == IExecutorHelper.executePSMSwap.selector) {
+            } else if (functionSelector == IExecutorHelper.executePSM.selector) {
                 swap.data = ScalingDataLib.newPSM(swap.data, oldAmount, newAmount);
-            } else if (functionSelector == IExecutorHelper.executeFraxSwap.selector) {
+            } else if (functionSelector == IExecutorHelper.executeFrax.selector) {
                 swap.data = ScalingDataLib.newFrax(swap.data, oldAmount, newAmount);
-            } else if (functionSelector == IExecutorHelper.executePlatypusSwap.selector) {
+            } else if (functionSelector == IExecutorHelper.executePlatypus.selector) {
                 swap.data = ScalingDataLib.newPlatypus(swap.data, oldAmount, newAmount);
+            } else if (functionSelector == IExecutorHelper.executeMaverick.selector) {
+                swap.data = ScalingDataLib.newMaverick(swap.data, oldAmount, newAmount);
             } else revert("AggregationExecutor: Dex type not supported");
             unchecked {
                 ++i;

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

@@ -52,9 +52,9 @@ library ScalingDataLib {
         uint256 oldAmount,
         uint256 newAmount
     ) internal pure returns (bytes memory) {
-        IExecutorHelper.UniSwapV3ProMM memory uniSwapV3ProMM = abi.decode(
+        IExecutorHelper.UniswapV3KSElastic memory uniSwapV3ProMM = abi.decode(
             data,
-            (IExecutorHelper.UniSwapV3ProMM)
+            (IExecutorHelper.UniswapV3KSElastic)
         );
         uniSwapV3ProMM.swapAmount = (uniSwapV3ProMM.swapAmount * newAmount) / oldAmount;
 
@@ -163,4 +163,24 @@ library ScalingDataLib {
         frax.collectAmount = (frax.collectAmount * newAmount) / oldAmount;
         return abi.encode(frax);
     }
+
+    function newStETHSwap(
+        bytes memory data,
+        uint256 oldAmount,
+        uint256 newAmount
+    ) internal pure returns (bytes memory) {
+        uint256 amount = abi.decode(data, (uint256));
+        amount = (amount * newAmount) / oldAmount;
+        return abi.encode(amount);
+    }
+
+    function newMaverick(
+        bytes memory data,
+        uint256 oldAmount,
+        uint256 newAmount
+    ) internal pure returns (bytes memory) {
+        IExecutorHelper.Maverick memory maverick = abi.decode(data, (IExecutorHelper.Maverick));
+        maverick.swapAmount = (maverick.swapAmount * newAmount) / oldAmount;
+        return abi.encode(maverick);
+    }
 }

package/deployments/1-core.json

@@ -12,7 +12,8 @@
         "initialFeeRateRoot": "999500333083533",
         "initialReserveFeePercent": "80",
         "initialPendlePerSec": "826719576719576719",
-        "safeWaitTime": 15000
+        "safeWaitTime": 15000,
+        "sySwapper": "0xd965c925Fd933029F8e5b7AD0C13bC875a026b09"
     },
     "baseCodeSplitter": "0x35878C2Cff38cC4032E85283183428170BA618A2",
     "PENDLE": "0x808507121b80c02388fad14726482e061b8da827",
@@ -22,9 +23,9 @@
     "bulkSellerOffchain": "0x9ACc60F915dFcd190D270fc92567aE71776bd320",
     "router": "0x0000000001e4ef00d069e71d6ba041b0a16f7ea0",
     "routerStatic": "0x263833d47eA3fA4a30f269323aba6a107f9eB14C",
-    "pendleSwap": "0x5719AcDB9ABBBC6Ba414C9DBFf5B2967342f465d",
+    "pendleSwap": "0x10115a984d69b0a832239a26d1841f10a59e45d8",
     "routerHelper": "0x462206b11d185ef6F64B41D344325401C37EC335",
-    "ptOracle": "0x414d3C8A26157085f286abE3BC6E1bb010733602",
+    "ptOracle": "0x14030836AEc15B2ad48bB097bd57032559339c92",
     "vePendle": "0x4f30A9D41B80ecC5B94306AB4364951AE3170210",
     "senderEndpoint": "0x07b1014c88f14C9E910092526db57A20052E989F",
     "votingController": "0x44087E105137a5095c008AaB6a6530182821F2F0",

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

@@ -0,0 +1,12 @@
+{
+    "name": "SY swETH",
+    "symbol": "SY-swETH",
+    "expiry": 1735171200,
+    "scalarRoot": "71979373279000000000",
+    "initialRateAnchor": "1058544507000000000",
+    "doCacheIndex": true,
+    "SY": "0xaa68CA9C69a4ff22203cE189Ce4448d7401875E8",
+    "PT": "0x330c4DD05dB16db6323505262C57CFdE5f0A78Ea",
+    "YT": "0x3199c7c3c972a8da5F9faD2A838383f827b735F1",
+    "market": "0x0e1C5509B503358eA1Dac119C1D413e28Cc4b303"
+}