@pendle/core-v2 5.8.2 → 5.8.3-factory

package/contracts/offchain-helpers/SwapNSeed.sol

@@ -0,0 +1,221 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.17;
+
+import "../interfaces/IPMarket.sol";
+import "../router/math/MarketApproxLibOnchain.sol";
+import "../router/base/ActionBase.sol";
+import "../interfaces/IPMarketSwapNSeed.sol";
+
+contract MarketSwapNSeed is ActionBase, IPMarketSwapNSeed {
+    using PMath for uint256;
+    using PMath for int256;
+    using PYIndexLib for PYIndex;
+    using MarketMathCore for MarketState;
+    using PYIndexLib for IPYieldToken;
+
+    address public immutable router;
+
+    uint256 public constant MAX_ITERATIONS = 30;
+
+    struct MarketTokens {
+        IStandardizedYield SY;
+        IPPrincipalToken PT;
+        IPYieldToken YT;
+    }
+
+    constructor(address _router) {
+        router = _router;
+    }
+
+    function swapNSeed(
+        address receiver,
+        address market,
+        uint256 minLpOut,
+        uint256 minYtOut,
+        TokenInput calldata input,
+        SwapNSeedData calldata snsData
+    ) external payable returns (int256 amountPYToAccount, uint256 netLpOut, uint256 netYtOut) {
+        MarketTokens memory tokens;
+        (tokens.SY, tokens.PT, tokens.YT) = IPMarket(market).readTokens();
+
+        _mintSyFromToken(address(this), address(tokens.SY), 1, input);
+        amountPYToAccount = _swapBeforeSeeding(receiver, market, tokens, snsData);
+        (netLpOut, netYtOut, ) = _addLiquiditySingleSyKeepYt(
+            receiver,
+            market,
+            tokens.SY,
+            tokens.YT,
+            _selfBalance(tokens.SY),
+            minLpOut,
+            minYtOut
+        );
+    }
+
+    function _addLiquiditySingleSyKeepYt(
+        address receiver,
+        address market,
+        IStandardizedYield SY,
+        IPYieldToken YT,
+        uint256 netSyIn,
+        uint256 minLpOut,
+        uint256 minYtOut
+    ) internal returns (uint256 netLpOut, uint256 netYtOut, uint256 netSyMintPy) {
+        MarketState memory state = _readMarket(market);
+
+        PYIndex pyIndex = YT.newIndex();
+
+        netSyMintPy =
+            (netSyIn * state.totalPt.Uint()) /
+            (state.totalPt.Uint() + pyIndex.syToAsset(state.totalSy.Uint()));
+
+        uint256 netSyAddLiquidity = netSyIn - netSyMintPy;
+
+        // transfer SY to mint PY
+        _transferOut(address(SY), address(YT), netSyMintPy);
+
+        // the rest of SY goes to market
+        _transferOut(address(SY), market, netSyAddLiquidity);
+
+        // PT goes to market, YT goes to receiver
+        netYtOut = YT.mintPY(market, receiver);
+
+        (netLpOut, , ) = IPMarket(market).mint(receiver, netSyAddLiquidity, netYtOut);
+
+        if (netLpOut < minLpOut) revert("Slippage: INSUFFICIENT_LP_OUT");
+        if (netYtOut < minYtOut) revert("Slippage: INSUFFICIENT_YT_OUT");
+    }
+
+    function _swapBeforeSeeding(
+        address receiver,
+        address market,
+        MarketTokens memory tokens,
+        SwapNSeedData memory snsData
+    ) internal returns (int256 amountPYToAccount) {
+        PYIndex index = _getPYIndex(market);
+        MarketState memory state = _readMarket(market);
+        MarketPreCompute memory comp = state.getMarketPreCompute(index, block.timestamp);
+
+        if (state.lastLnImpliedRate > snsData.targetLnImpliedRate) {
+            // Normalize maxPtToSwap
+            snsData.maxPtToSwap = PMath.min(
+                snsData.maxPtToSwap,
+                MarketApproxPtInLibOnchain.calcSoftMaxPtIn(state, comp)
+            );
+
+            (int256 amountPtToBuy, int256 amountSyToAccount) = _calcAmountPtToBuy(state, comp, index, snsData);
+            amountPYToAccount = amountPtToBuy;
+
+            _transferOut(address(tokens.SY), market, amountSyToAccount.abs());
+            IPMarket(market).swapSyForExactPt(receiver, amountPtToBuy.abs(), EMPTY_BYTES);
+        } else {
+            // Normalize maxPtToSwap
+            snsData.maxPtToSwap = PMath.min(
+                snsData.maxPtToSwap,
+                MarketApproxPtOutLibOnchain.calcMaxPtOut(comp, state.totalPt)
+            );
+
+            amountPYToAccount = _calcAmountPtToSell(state, comp, index, snsData);
+            uint256 amountPtToSell = amountPYToAccount.abs();
+            uint256 netPyOut = _mintPyFromSy(
+                address(this),
+                address(tokens.SY),
+                address(tokens.YT),
+                index.assetToSyUp(amountPtToSell),
+                amountPtToSell,
+                false
+            );
+
+            _transferOut(address(tokens.PT), market, netPyOut);
+            _transferOut(address(tokens.YT), receiver, netPyOut);
+
+            // this amount of SY will be used to add liquidity in later step
+            IPMarket(market).swapExactPtForSy(address(this), amountPtToSell, EMPTY_BYTES);
+        }
+    }
+
+    function _calcAmountPtToBuy(
+        MarketState memory state,
+        MarketPreCompute memory comp,
+        PYIndex index,
+        SwapNSeedData memory snsData
+    ) internal pure returns (int256 amountPtToSwapToAccount, int256 amountSyToAccount) {
+        int256 refAmt = snsData.maxPtToSwap.Int();
+        int256 accPtToAccount = 0;
+
+        int256 lastGoodAmountSyToAccount = 0;
+        uint256 lastGoodRate = state.lastLnImpliedRate;
+
+        for (uint256 iter = 0; iter < MAX_ITERATIONS; ++iter) {
+            refAmt /= 2;
+            MarketState memory localState = _deepCopy(state);
+            int256 curPtToAccount = accPtToAccount + refAmt;
+
+            // Will not revert. maxPtToBuy should already be normalized
+            (int256 localAmountSyToAccount, , ) = localState.calcTrade(comp, index, curPtToAccount);
+
+            if (localState.lastLnImpliedRate > snsData.targetLnImpliedRate) {
+                accPtToAccount += refAmt;
+                lastGoodRate = localState.lastLnImpliedRate;
+                lastGoodAmountSyToAccount = localAmountSyToAccount;
+            }
+        }
+
+        if (PMath.isAApproxB(snsData.targetLnImpliedRate, lastGoodRate, snsData.eps)) {
+            amountPtToSwapToAccount = accPtToAccount;
+            amountSyToAccount = lastGoodAmountSyToAccount;
+        } else {
+            revert("_calcAmountPtToBuy: failed");
+        }
+    }
+
+    function _calcAmountPtToSell(
+        MarketState memory state,
+        MarketPreCompute memory comp,
+        PYIndex index,
+        SwapNSeedData memory snsData
+    ) internal pure returns (int256 amountPtToSwapToAccount) {
+        int256 refAmt = snsData.maxPtToSwap.Int();
+        int256 accPtToAccount = 0;
+        uint256 lastGoodRate = state.lastLnImpliedRate;
+
+        for (uint256 iter = 0; iter < MAX_ITERATIONS; ++iter) {
+            refAmt /= 2;
+            MarketState memory localState = _deepCopy(state);
+            int256 curPtToAccount = accPtToAccount - refAmt;
+
+            // Will not revert. maxPtToSell should already be normalized
+            localState.calcTrade(comp, index, curPtToAccount);
+
+            if (localState.lastLnImpliedRate < snsData.targetLnImpliedRate) {
+                accPtToAccount -= refAmt;
+                lastGoodRate = localState.lastLnImpliedRate;
+            }
+        }
+
+        if (PMath.isAApproxB(snsData.targetLnImpliedRate, lastGoodRate, snsData.eps)) {
+            amountPtToSwapToAccount = accPtToAccount;
+        } else {
+            revert("_calcAmountPtToSell: failed");
+        }
+    }
+
+    function _getPYIndex(address market) internal returns (PYIndex) {
+        (, , IPYieldToken YT) = IPMarket(market).readTokens();
+        return PYIndex.wrap(YT.pyIndexCurrent());
+    }
+
+    function _deepCopy(MarketState memory state) internal pure returns (MarketState memory copiedState) {
+        copiedState.totalPt = state.totalPt;
+        copiedState.totalSy = state.totalSy;
+        copiedState.totalLp = state.totalLp;
+        copiedState.treasury = state.treasury;
+
+        copiedState.scalarRoot = state.scalarRoot;
+        copiedState.expiry = state.expiry;
+
+        copiedState.lnFeeRateRoot = state.lnFeeRateRoot;
+        copiedState.reserveFeePercent = state.reserveFeePercent;
+        copiedState.lastLnImpliedRate = state.lastLnImpliedRate;
+    }
+}

package/contracts/offchain-helpers/deploy/PendleCommonPoolDeployHelperV2.sol

@@ -11,6 +11,10 @@ contract PendleCommonPoolDeployHelperV2 is PendlePoolDeployHelperV2, BoringOwnab
     bytes32 public constant ERC4626_NOT_REDEEMABLE_DEPLOY_ID = keccak256("PendleERC4626NotRedeemableToAssetSYV2");
     bytes32 public constant ERC20_DEPLOY_ID = keccak256("PendleERC20SY");
 
+    bytes32 public constant ERC4626_WITH_ADAPTER_ID = keccak256("PendleERC4626WithAdapterSY");
+    bytes32 public constant ERC4626_NO_REDEEM_WITH_ADAPTER_ID = keccak256("PendleERC4626NoRedeemWithAdapterSY");
+    bytes32 public constant ERC20_WITH_ADAPTER_ID = keccak256("PendleERC20WithAdapterSY");
+
     address public immutable syFactory;
 
     constructor(
@@ -65,4 +69,55 @@ contract PendleCommonPoolDeployHelperV2 is PendlePoolDeployHelperV2, BoringOwnab
         address SY = IPCommonSYFactory(syFactory).deploySY(ERC20_DEPLOY_ID, constructorParams, syOwner);
         return deploy5115MarketAndSeedLiquidity(SY, config, tokenToSeedLiqudity, amountToSeed);
     }
+
+    function deployERC4626WithAdapterMarket(
+        bytes memory constructorParams,
+        bytes memory initData,
+        PoolConfig memory config,
+        address tokenToSeedLiqudity,
+        uint256 amountToSeed,
+        address syOwner
+    ) external returns (PoolDeploymentAddrs memory) {
+        address SY = IPCommonSYFactory(syFactory).deployUpgradableSY(
+            ERC4626_WITH_ADAPTER_ID,
+            constructorParams,
+            initData,
+            syOwner
+        );
+        return deploy5115MarketAndSeedLiquidity(SY, config, tokenToSeedLiqudity, amountToSeed);
+    }
+
+    function deployERC4626NoRedeemWithAdapterMarket(
+        bytes memory constructorParams,
+        bytes memory initData,
+        PoolConfig memory config,
+        address tokenToSeedLiqudity,
+        uint256 amountToSeed,
+        address syOwner
+    ) external returns (PoolDeploymentAddrs memory) {
+        address SY = IPCommonSYFactory(syFactory).deployUpgradableSY(
+            ERC4626_NO_REDEEM_WITH_ADAPTER_ID,
+            constructorParams,
+            initData,
+            syOwner
+        );
+        return deploy5115MarketAndSeedLiquidity(SY, config, tokenToSeedLiqudity, amountToSeed);
+    }
+
+    function deployERC20WithAdapterMarket(
+        bytes memory constructorParams,
+        bytes memory initData,
+        PoolConfig memory config,
+        address tokenToSeedLiqudity,
+        uint256 amountToSeed,
+        address syOwner
+    ) external returns (PoolDeploymentAddrs memory) {
+        address SY = IPCommonSYFactory(syFactory).deployUpgradableSY(
+            ERC20_WITH_ADAPTER_ID,
+            constructorParams,
+            initData,
+            syOwner
+        );
+        return deploy5115MarketAndSeedLiquidity(SY, config, tokenToSeedLiqudity, amountToSeed);
+    }
 }

package/contracts/offchain-helpers/deploy/PendleCommonSYFactory.sol

@@ -4,6 +4,7 @@ pragma solidity ^0.8.17;
 import "../../core/libraries/BoringOwnableUpgradeableV2.sol";
 import "../../core/libraries/BaseSplitCodeFactory.sol";
 import "../../interfaces/IOwnable.sol";
+import "@openzeppelin/contracts/proxy/transparent/TransparentUpgradeableProxy.sol";
 
 contract PendleCommonSYFactory is BoringOwnableUpgradeableV2 {
     error InvalidCreationCode(bytes32 id, CreationCode code);
@@ -21,11 +22,14 @@ contract PendleCommonSYFactory is BoringOwnableUpgradeableV2 {
 
     event DeployedSY(bytes32 id, bytes constructorParams, address SY);
 
+    address public immutable proxyAdmin;
+
     mapping(bytes32 => CreationCode) public creationCodes;
 
     uint256 public nonce;
 
-    constructor() {
+    constructor(address _proxyAdmin) {
+        proxyAdmin = _proxyAdmin;
         _disableInitializers();
     }
 
@@ -66,4 +70,33 @@ contract PendleCommonSYFactory is BoringOwnableUpgradeableV2 {
         emit DeployedSY(id, constructorParams, SY);
         IOwnable(SY).transferOwnership(syOwner, true, false);
     }
+
+    function deployUpgradableSY(
+        bytes32 id,
+        bytes memory constructorParams,
+        bytes memory initData,
+        address syOwner
+    ) external returns (address) {
+        CreationCode memory code = creationCodes[id];
+
+        if (code.creationCodeContractA == address(0)) {
+            revert InvalidSYId(id);
+        }
+
+        address implementation = BaseSplitCodeFactory._create2(
+            0,
+            keccak256(abi.encode(block.chainid, nonce++)),
+            constructorParams,
+            code.creationCodeContractA,
+            code.creationCodeSizeA,
+            code.creationCodeContractB,
+            code.creationCodeSizeB
+        );
+        address proxy = address(new TransparentUpgradeableProxy(implementation, proxyAdmin, initData));
+        
+        emit DeployedSY(id, constructorParams, proxy);
+
+        IOwnable(proxy).transferOwnership(syOwner, true, false);
+        return proxy;
+    }
 }

package/contracts/offchain-helpers/deploy/PendlePoolDeployHelperV2.sol

@@ -95,7 +95,11 @@ contract PendlePoolDeployHelperV2 is TokenHelper {
     function _createPYIfNotExist(address SY, uint32 expiry) internal returns (address PT, address YT) {
         PT = IPYieldContractFactory(yieldContractFactory).getPT(SY, uint256(expiry));
         if (PT == address(0)) {
-            (PT, YT) = IPYieldContractFactory(yieldContractFactory).createYieldContract(SY, expiry, doCacheIndexSameBlock);
+            (PT, YT) = IPYieldContractFactory(yieldContractFactory).createYieldContract(
+                SY,
+                expiry,
+                doCacheIndexSameBlock
+            );
         } else {
             YT = IPYieldContractFactory(yieldContractFactory).getYT(SY, expiry);
         }

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

@@ -23,7 +23,7 @@ enum SwapType {
     ETH_WETH,
     OKX,
     ONE_INCH,
-    PARASWAP,
+    RESERVE_1,
     RESERVE_2,
     RESERVE_3,
     RESERVE_4,

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

@@ -0,0 +1,120 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.17;
+import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+
+interface I1inchCommonType {
+    type Address256 is uint256;
+}
+
+abstract contract OneInchScaleHelper is I1inchCommonType {
+    function _rescaleMinAmount(
+        uint256 minAmount,
+        uint256 oldAmount,
+        uint256 newAmount
+    ) internal pure returns (uint256) {
+        return (minAmount * newAmount) / oldAmount;
+    }
+
+    function _oneInchScaling(bytes calldata rawCallData, uint256 actualAmount) internal pure returns (bytes memory) {
+        bytes4 selector = bytes4(rawCallData[:4]);
+        bytes memory args = rawCallData[4:];
+
+        if (selector == I1inchAggregationRouterV6.unoswapTo.selector) {
+            (Address256 to, Address256 token, uint256 amount, uint256 minReturn, Address256 dex) = abi.decode(
+                args,
+                (Address256, Address256, uint256, uint256, Address256)
+            );
+
+            minReturn = (minReturn * actualAmount) / amount;
+            amount = actualAmount;
+            return abi.encodeWithSelector(selector, to, token, amount, minReturn, dex);
+        }
+
+        if (selector == I1inchAggregationRouterV6.unoswapTo2.selector) {
+            (Address256 to, Address256 token, uint256 amount, uint256 minReturn, Address256 dex, Address256 dex2) = abi
+                .decode(args, (Address256, Address256, uint256, uint256, Address256, Address256));
+
+            minReturn = (minReturn * actualAmount) / amount;
+            amount = actualAmount;
+
+            return abi.encodeWithSelector(selector, to, token, amount, minReturn, dex, dex2);
+        }
+
+        if (selector == I1inchAggregationRouterV6.unoswapTo3.selector) {
+            (
+                Address256 to,
+                Address256 token,
+                uint256 amount,
+                uint256 minReturn,
+                Address256 dex,
+                Address256 dex2,
+                Address256 dex3
+            ) = abi.decode(args, (Address256, Address256, uint256, uint256, Address256, Address256, Address256));
+
+            minReturn = (minReturn * actualAmount) / amount;
+            amount = actualAmount;
+
+            return abi.encodeWithSelector(selector, to, token, amount, minReturn, dex, dex2, dex3);
+        }
+
+        if (selector == I1inchAggregationRouterV6.swap.selector) {
+            (address executor, I1inchAggregationRouterV6.SwapDescription memory desc, bytes memory data) = abi.decode(
+                args,
+                (address, I1inchAggregationRouterV6.SwapDescription, bytes)
+            );
+
+            desc.minReturnAmount = (desc.minReturnAmount * actualAmount) / desc.amount;
+            desc.amount = actualAmount;
+            return abi.encodeWithSelector(selector, executor, desc, data);
+        }
+
+        revert("1inch: unsupported selector");
+    }
+}
+
+interface I1inchAggregationRouterV6 is I1inchCommonType {
+    struct SwapDescription {
+        IERC20 srcToken;
+        IERC20 dstToken;
+        address payable srcReceiver;
+        address payable dstReceiver;
+        uint256 amount;
+        uint256 minReturnAmount;
+        uint256 flags;
+    }
+
+    // we ignore the non-to version since it's guarantee this contract won't receive tokens
+
+    function unoswapTo(
+        Address256 to,
+        Address256 token,
+        uint256 amount,
+        uint256 minReturn,
+        Address256 dex
+    ) external returns (uint256 returnAmount);
+
+    function unoswapTo2(
+        Address256 to,
+        Address256 token,
+        uint256 amount,
+        uint256 minReturn,
+        Address256 dex,
+        Address256 dex2
+    ) external returns (uint256 returnAmount);
+
+    function unoswapTo3(
+        Address256 to,
+        Address256 token,
+        uint256 amount,
+        uint256 minReturn,
+        Address256 dex,
+        Address256 dex2,
+        Address256 dex3
+    ) external returns (uint256 returnAmount);
+
+    function swap(
+        address executor,
+        SwapDescription calldata desc,
+        bytes calldata data
+    ) external payable returns (uint256 returnAmount, uint256 spentAmount);
+}

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

@@ -5,9 +5,9 @@ import "../../core/libraries/TokenHelper.sol";
 import "./IPSwapAggregator.sol";
 import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
 import "./OKXScaleHelper.sol";
-import "./ParaswapScaleHelper.sol";
+import "./OneInchScaleHelper.sol";
 
-contract PendleSwap is IPSwapAggregator, TokenHelper, OKXScaleHelper, ParaswapScaleHelper {
+contract PendleSwap is IPSwapAggregator, TokenHelper, OKXScaleHelper, OneInchScaleHelper {
     using Address for address;
     using SafeERC20 for IERC20;
 
@@ -54,10 +54,10 @@ contract PendleSwap is IPSwapAggregator, TokenHelper, OKXScaleHelper, ParaswapSc
             require(isSuccess, "PendleSwap: Kyber scaling failed");
         } else if (swapType == SwapType.ODOS) {
             scaledCallData = _odosScaling(rawCallData, amountIn);
-        } else if (swapType == SwapType.PARASWAP) {
-            scaledCallData = _paraswapScaling(rawCallData, amountIn);
         } else if (swapType == SwapType.OKX) {
             scaledCallData = _okxScaling(rawCallData, amountIn);
+        } else if (swapType == SwapType.ONE_INCH) {
+            scaledCallData = _oneInchScaling(rawCallData, amountIn);
         } else {
             assert(false);
         }

package/deployments/1-core.json

@@ -32,7 +32,7 @@
         "ActionStorageV4": "0x6a0Ed0A9193FCBe7ae9B0F3D90F88e365Cca64fC"
     },
     "routerStatic": "0x263833d47eA3fA4a30f269323aba6a107f9eB14C",
-    "pendleSwap": "0xd4e9B0d466789d7F6201442eecCBA6a75A552db0",
+    "pendleSwap": "0x313e7Ef7d52f5C10aC04ebaa4d33CDc68634c212",
     "pyYtLpOracle": "0x9a9fa8338dd5e5b2188006f1cd2ef26d921650c2",
     "yieldContractFactoryV3": "0xdF3601014686674e53d1Fa52F7602525483F9122",
     "marketFactoryV3": "0x1A6fCc85557BC4fB7B534ed835a03EF056552D52",
@@ -44,7 +44,7 @@
     "poolDeployHelperV2": "0xF642d8Daa026B8aEd6dFE82FACbA2E077AF199E2",
     "limitRouter": "0x000000000000c9B3E2C3Ec88B1B4c0cD853f4321",
     "proxyAdmin": "0xA28c08f165116587D4F3E708743B4dEe155c5E64",
-    "reflector": "0x73d5DBF81A4f3bFa7b335e6a2d4638D6017a4fA8",
+    "reflector": "0x5039Da22E5126e7c4e9284376116716A91782faF",
     "commonDeploy": "0x2Ed473F528E5B320f850d17ADfe0e558f0298aA9",
     "syFactory": "0x466CeD3b33045Ea986B2f306C8D0aA8067961CF8",
     "sparkLinearDiscountOracleFactory": "0x34C91651A070664279866E5f3d6B4d5F65cbbFFb",

package/deployments/10-core.json

@@ -31,7 +31,7 @@
         "ActionStorageV4": "0x6a0Ed0A9193FCBe7ae9B0F3D90F88e365Cca64fC"
     },
     "routerStatic": "0x704478Dd72FD7F9B83d1F1e0fc18C14B54F034d0",
-    "pendleSwap": "0xd4e9B0d466789d7F6201442eecCBA6a75A552db0",
+    "pendleSwap": "0x313e7Ef7d52f5C10aC04ebaa4d33CDc68634c212",
     "pyYtLpOracle": "0x9a9fa8338dd5e5b2188006f1cd2ef26d921650c2",
     "yieldContractFactoryV3": "0xfa6B22FC4c3Ad88B68c16b3061a16b1714F6Bd57",
     "marketFactoryV3": "0x4A2B38b9cBd83c86F261a4d64c243795D4d44aBC",
@@ -42,7 +42,7 @@
     "poolDeployHelper": "0x439B4d66255eFf74e621FBacb00D7162b588Ff4b",
     "limitRouter": "0x000000000000c9B3E2C3Ec88B1B4c0cD853f4321",
     "proxyAdmin": "0xA28c08f165116587D4F3E708743B4dEe155c5E64",
-    "reflector": "0x73d5DBF81A4f3bFa7b335e6a2d4638D6017a4fA8",
+    "reflector": "0x5039Da22E5126e7c4e9284376116716A91782faF",
     "vePendleAirdropDistributor": "0x3942F7B55094250644cFfDa7160226Caa349A38E",
     "externalRewardsDistributor": "0xae898a7d07f8e27f25e13d0f351a7401f9a5bf9d",
     "commonDeploy": "0x2Ed473F528E5B320f850d17ADfe0e558f0298aA9",

package/deployments/146-core.json

@@ -30,21 +30,22 @@
     "routerStatic": "0x0013ACc071f732fd6BF8210AB46A3794a7D8945e",
     "pendleSwap": "0xd4e9B0d466789d7F6201442eecCBA6a75A552db0",
     "pyYtLpOracle": "0x9a9fa8338dd5e5b2188006f1cd2ef26d921650c2",
-    "reflector": "0x73d5DBF81A4f3bFa7b335e6a2d4638D6017a4fA8",
-    "limitRouter": "0x000000000000c9B3E2C3Ec88B1B4c0cD853f4321",
     "yieldContractFactoryV5": "0x0582D93FD9c9d42f26bE5D86a5f75291F92102C2",
     "marketFactoryV5": "0xFeE31A6eC6eBefa0b5A594Bf5b1139e3c6fAA0fB",
     "poolDeployHelperV2": "0x0b692f06CA82e3075dC537224450885Fd138e655",
+    "limitRouter": "0x000000000000c9B3E2C3Ec88B1B4c0cD853f4321",
     "proxyAdmin": "0xA28c08f165116587D4F3E708743B4dEe155c5E64",
+    "reflector": "0x73d5DBF81A4f3bFa7b335e6a2d4638D6017a4fA8",
+    "vePendleAirdropDistributor": "0x3942F7B55094250644cFfDa7160226Caa349A38E",
+    "externalRewardsDistributor": "0xae898a7d07f8e27f25e13d0f351a7401f9a5bf9d",
     "commonDeploy": "0x2Ed473F528E5B320f850d17ADfe0e558f0298aA9",
     "syFactory": "0x466CeD3b33045Ea986B2f306C8D0aA8067961CF8",
-    "receiverEndpoint": "0x3209E9412cca80B18338f2a56ADA59c484c39644",
-    "vePendle": "0xE017CCC08505Ac8fbb5a364680e459d9fBaEE74d",
-    "gaugeController": "0xeE708FC793a02F1eDd5BB9DBD7fD13010D1F7136",
     "sparkLinearDiscountOracleFactory": "0x34C91651A070664279866E5f3d6B4d5F65cbbFFb",
-    "vePendleAirdropDistributor": "0x3942F7B55094250644cFfDa7160226Caa349A38E",
-    "externalRewardsDistributor": "0xae898a7d07f8e27f25e13d0f351a7401f9a5bf9d",
     "beta": {
         "PendleChainlinkOracleFactory": "0x0000000000000000000000000000000000000000"
-    }
+    },
+    "receiverEndpoint": "0x3209E9412cca80B18338f2a56ADA59c484c39644",
+    "vePendle": "0xE017CCC08505Ac8fbb5a364680e459d9fBaEE74d",
+    "gaugeController": "0xeE708FC793a02F1eDd5BB9DBD7fD13010D1F7136",
+    "commonDeployTest": "0x8cbF9190b6EA4BeD4655888273e2A313a77400fD"
 }

package/deployments/42161-core.json

@@ -31,7 +31,7 @@
         "ActionStorageV4": "0x6a0Ed0A9193FCBe7ae9B0F3D90F88e365Cca64fC"
     },
     "routerStatic": "0xAdB09F65bd90d19e3148D9ccb693F3161C6DB3E8",
-    "pendleSwap": "0xd4e9B0d466789d7F6201442eecCBA6a75A552db0",
+    "pendleSwap": "0x313e7Ef7d52f5C10aC04ebaa4d33CDc68634c212",
     "pyYtLpOracle": "0x9a9fa8338dd5e5b2188006f1cd2ef26d921650c2",
     "yieldContractFactoryV3": "0xEb38531db128EcA928aea1B1CE9E5609B15ba146",
     "marketFactoryV3": "0x2FCb47B58350cD377f94d3821e7373Df60bD9Ced",
@@ -42,7 +42,7 @@
     "poolDeployHelper": "0xEE2eF4ADaf5Bd61FD107fD169CAe3AB79958B928",
     "limitRouter": "0x000000000000c9B3E2C3Ec88B1B4c0cD853f4321",
     "proxyAdmin": "0xA28c08f165116587D4F3E708743B4dEe155c5E64",
-    "reflector": "0x73d5DBF81A4f3bFa7b335e6a2d4638D6017a4fA8",
+    "reflector": "0x5039Da22E5126e7c4e9284376116716A91782faF",
     "vePendleAirdropDistributor": "0x3942F7B55094250644cFfDa7160226Caa349A38E",
     "externalRewardsDistributor": "0xae898a7d07f8e27f25e13d0f351a7401f9a5bf9d",
     "commonDeploy": "0x2Ed473F528E5B320f850d17ADfe0e558f0298aA9",

package/deployments/5000-core.json

@@ -29,7 +29,7 @@
         "ActionStorageV4": "0x6a0Ed0A9193FCBe7ae9B0F3D90F88e365Cca64fC"
     },
     "routerStatic": "0xCAd502Bb55d1A3F79952F969BFF3f011CF30a94a",
-    "pendleSwap": "0xd4e9B0d466789d7F6201442eecCBA6a75A552db0",
+    "pendleSwap": "0x313e7Ef7d52f5C10aC04ebaa4d33CDc68634c212",
     "pyYtLpOracle": "0x9a9fa8338dd5e5b2188006f1cd2ef26d921650c2",
     "yieldContractFactoryV3": "0x964840644B88C583500F473E4B829Ab629aF96A8",
     "marketFactoryV3": "0xD228EC1f7D4313fe321fab511A872475D07F5bA6",
@@ -41,7 +41,7 @@
     "poolDeployHelperV2": "0x6E716B682D0b63E7BF2C7b1cD20F2Fc2F3596fc7",
     "limitRouter": "0x000000000000c9B3E2C3Ec88B1B4c0cD853f4321",
     "proxyAdmin": "0xA28c08f165116587D4F3E708743B4dEe155c5E64",
-    "reflector": "0x73d5DBF81A4f3bFa7b335e6a2d4638D6017a4fA8",
+    "reflector": "0x5039Da22E5126e7c4e9284376116716A91782faF",
     "commonDeploy": "0x2Ed473F528E5B320f850d17ADfe0e558f0298aA9",
     "syFactory": "0x466CeD3b33045Ea986B2f306C8D0aA8067961CF8",
     "receiverEndpoint": "0xf799E4c029d14f41Dc1918C9A4C67242F565710e",

package/deployments/56-core.json

@@ -31,7 +31,7 @@
         "ActionStorageV4": "0x6a0Ed0A9193FCBe7ae9B0F3D90F88e365Cca64fC"
     },
     "routerStatic": "0x2700ADB035F82a11899ce1D3f1BF8451c296eABb",
-    "pendleSwap": "0xd4e9B0d466789d7F6201442eecCBA6a75A552db0",
+    "pendleSwap": "0x313e7Ef7d52f5C10aC04ebaa4d33CDc68634c212",
     "pyYtLpOracle": "0x9a9fa8338dd5e5b2188006f1cd2ef26d921650c2",
     "yieldContractFactoryV3": "0x40Ae6da2d92aa3DCb7f8d7a7209FD12BDfcb7C85",
     "marketFactoryV3": "0xC40fEbF5A33b8C92B187d9be0fD3fe0ac2E4B07c",
@@ -42,7 +42,7 @@
     "poolDeployHelper": "0xF536323e5825dCb1Bc9b4DE74D63111189532b5f",
     "limitRouter": "0x000000000000c9B3E2C3Ec88B1B4c0cD853f4321",
     "proxyAdmin": "0xA28c08f165116587D4F3E708743B4dEe155c5E64",
-    "reflector": "0x73d5DBF81A4f3bFa7b335e6a2d4638D6017a4fA8",
+    "reflector": "0x5039Da22E5126e7c4e9284376116716A91782faF",
     "commonDeploy": "0x2Ed473F528E5B320f850d17ADfe0e558f0298aA9",
     "syFactory": "0x466CeD3b33045Ea986B2f306C8D0aA8067961CF8",
     "sparkLinearDiscountOracleFactory": "0x34C91651A070664279866E5f3d6B4d5F65cbbFFb",

package/deployments/80094-core.json

@@ -28,14 +28,14 @@
         "ActionStorageV4": "0xdED51dca2ECED7a0BAab3D9711A87f214769Da0f"
     },
     "routerStatic": "0x6813d43782395A1F2AAb42f39aeEDE03ac655e09",
-    "pendleSwap": "0xd4e9B0d466789d7F6201442eecCBA6a75A552db0",
+    "pendleSwap": "0x313e7Ef7d52f5C10aC04ebaa4d33CDc68634c212",
     "pyYtLpOracle": "0x9a9fa8338dd5e5b2188006f1cd2ef26d921650c2",
     "yieldContractFactoryV5": "0x2bEa6BfD8fbFF45aA2a893EB3B6d85D10EFcC70E",
     "marketFactoryV5": "0x8A09574b0401A856d89d1b583eE22E8cb0C5530B",
     "poolDeployHelperV2": "0x96F77F24b3d17166FcaF3a9E3B8330fF38B966F9",
     "limitRouter": "0x000000000000c9B3E2C3Ec88B1B4c0cD853f4321",
     "proxyAdmin": "0xA28c08f165116587D4F3E708743B4dEe155c5E64",
-    "reflector": "0x73d5DBF81A4f3bFa7b335e6a2d4638D6017a4fA8",
+    "reflector": "0xFAa7aD6258b1aa40F2cC414E49033dc77183ba76",
     "commonDeploy": "0x2Ed473F528E5B320f850d17ADfe0e558f0298aA9",
     "syFactory": "0x466CeD3b33045Ea986B2f306C8D0aA8067961CF8",
     "sparkLinearDiscountOracleFactory": "0x34C91651A070664279866E5f3d6B4d5F65cbbFFb",