@pendle/core-v2 6.6.0 → 6.7.0

package/contracts/limit/LimitRouterBase.sol

@@ -4,17 +4,17 @@ pragma solidity ^0.8.17;
 
 import "../core/libraries/BoringOwnableUpgradeableV2.sol";
 import "../core/libraries/TokenHelper.sol";
+import "../interfaces/IPAllActionV3.sol";
 import "../interfaces/IPLimitRouter.sol";
 import "../interfaces/IStandardizedYield.sol";
-import "../interfaces/IWETH.sol";
 import {LimitMathCore as LimitMath} from "./LimitMathCore.sol";
+import "./helpers/MintSyHelper.sol";
 import "./helpers/NonceManager.sol";
-import "@openzeppelin/contracts-upgradeable/utils/cryptography/draft-EIP712Upgradeable.sol";
 import "@openzeppelin/contracts/utils/cryptography/SignatureChecker.sol";
 
 abstract contract LimitRouterBase is
-    EIP712Upgradeable,
     IPLimitRouter,
+    MintSyHelper,
     BoringOwnableUpgradeableV2,
     NonceManager,
     TokenHelper
@@ -28,26 +28,28 @@ abstract contract LimitRouterBase is
 
     uint128 internal constant _ORDER_DOES_NOT_EXIST = 0;
     uint128 internal constant _ORDER_FILLED = 1;
-    uint256 internal constant NEW_PRIME = 12_421;
     uint256 internal constant MAX_LN_FEE_RATE_ROOT = 48_790_164_169_432_003; // ln(1.05)
 
-    bytes private constant EMPTY_BYTES = abi.encode();
-
     address public feeRecipient;
 
     // YT => lnFeeRateRoot // not to be accessed directly
     mapping(address => uint256) internal __lnFeeRateRoot;
 
     address public immutable WNATIVE;
+    address public immutable ROUTER;
 
     mapping(bytes32 => OrderStatus) internal _status;
 
     address private __deprecated__ownerHelper;
 
-    uint256[99] private __gap;
+    address public mintSySigner1;
+    address public mintSySigner2;
+
+    uint256[97] private __gap;
 
-    constructor(address _WNATIVE) {
+    constructor(address _WNATIVE, address _ROUTER) {
         WNATIVE = _WNATIVE;
+        ROUTER = _ROUTER;
     }
 
     // solhint-disable-next-line no-empty-blocks
@@ -64,18 +66,20 @@ abstract contract LimitRouterBase is
         FillOrderParams[] memory params,
         address receiver,
         uint256 maxTaking,
-        bytes calldata,
-        /*optData*/
+        bytes memory optData,
         bytes memory callback
     ) external returns (uint256 actualMaking, uint256 actualTaking, uint256 totalFee, bytes memory callbackReturn) {
-        params = _validateSkipSigAndFilterOrders(params);
+        OptionalArgs memory oArgs = _decodeAndVerifySigOpt_prePrune(params, optData);
+
+        _validateSkipSigAndPruneOrders(params);
         if (params.length == 0) return fillNoOrders(callback);
 
         OrderType orderType = params[0].order.orderType;
+        Args memory a = Args(orderType, params, receiver, maxTaking, callback, oArgs);
         if (orderType == OrderType.SY_FOR_PT || orderType == OrderType.SY_FOR_YT) {
-            return fillTokenForPY(Args(orderType, params, receiver, maxTaking, callback));
+            return fillTokenForPY(a);
         } else {
-            return fillPYForToken(Args(orderType, params, receiver, maxTaking, callback));
+            return fillPYForToken(a);
         }
     }
 
@@ -87,6 +91,11 @@ abstract contract LimitRouterBase is
         address receiver;
         uint256 maxTaking;
         bytes callback;
+        OptionalArgs oArgs;
+    }
+
+    struct OptionalArgs {
+        MintSyData mintSyData;
     }
 
     function fillNoOrders(bytes memory callback)
@@ -104,7 +113,7 @@ abstract contract LimitRouterBase is
         (address SY, address PT, address YT, bytes32[] memory orderHashes) = _checkSig_updMakingAndStatus(a.params);
 
         // Token => This
-        uint256[] memory fromMakers = _transferFromMakers_mintSy_updMakings(SY, a.params);
+        uint256[] memory fromMakers = _transferFromMakers_mintSy_updMakings(SY, a.params, a.oArgs.mintSyData);
 
         FillResults memory out = LimitMath.calcBatch(a.params, YT, getLnFeeRateRoot(YT));
         (actualMaking, actualTaking, totalFee) = (out.totalMaking - out.totalFee, out.totalTaking, out.totalFee);
@@ -160,35 +169,43 @@ abstract contract LimitRouterBase is
     }
 
     // ----------------- verify & convert functions -----------------
-    function _validateSkipSigAndFilterOrders(FillOrderParams[] memory params)
+
+    function _decodeAndVerifySigOpt_prePrune(FillOrderParams[] memory params, bytes memory optData)
         internal
         view
-        returns (FillOrderParams[] memory res)
+        returns (OptionalArgs memory oArgs)
     {
+        if (optData.length != 0) {
+            (uint256 version, bytes memory payload) = abi.decode(optData, (uint256, bytes));
+            require(version == 1, "LOP: invalid version");
+
+            oArgs.mintSyData = abi.decode(payload, (MintSyData));
+            _verifyMintSyData(oArgs.mintSyData, hashFillParams(params), mintSySigner1, mintSySigner2);
+        }
+    }
+
+    function _validateSkipSigAndPruneOrders(FillOrderParams[] memory params) internal view {
         uint256 len = params.length;
         require(len != 0, "LOP: empty batch");
 
         (address YT, OrderType orderType) = (params[0].order.YT, params[0].order.orderType);
         require(block.timestamp < IPYieldToken(YT).expiry(), "LOP: PY expired");
 
-        uint256 skipped = 0;
+        uint256 keep = 0;
         for (uint256 i = 0; i < len; i++) {
             Order memory order = params[i].order;
+
+            require(i == 0 || order.token >= params[i - 1].order.token, "LOP: invalid ordering");
             require(order.orderType == orderType && order.YT == YT, "LOP: mismatch types");
 
-            if (!(block.timestamp < order.expiry && order.nonce >= nonce[order.maker])) {
-                skipped++;
-                params[i].signature = EMPTY_BYTES;
-            }
+            if (!(block.timestamp < order.expiry && order.nonce >= nonce[order.maker])) continue;
+
+            params[keep] = params[i];
+            keep++;
         }
 
-        res = new FillOrderParams[](len - skipped);
-        uint256 iter = 0;
-        for (uint256 i = 0; i < len; i++) {
-            if (params[i].signature.length != 0) {
-                res[iter] = params[i];
-                iter++;
-            }
+        assembly ("memory-safe") {
+            mstore(params, keep)
         }
     }
 
@@ -289,12 +306,13 @@ abstract contract LimitRouterBase is
         return (orderHash, remainingMakerAmount, filledMakerAmount);
     }
 
-    // ----------------- simple helper functions functions -----------------
+    // ----------------- simple helper functions -----------------
 
-    function _transferFromMakers_mintSy_updMakings(address SY, FillOrderParams[] memory params)
-        internal
-        returns (uint256[] memory fromMakers)
-    {
+    function _transferFromMakers_mintSy_updMakings(
+        address SY,
+        FillOrderParams[] memory params,
+        MintSyData memory mintSyData
+    ) internal returns (uint256[] memory fromMakers) {
         uint256 len = params.length;
         fromMakers = new uint256[](len);
 
@@ -309,21 +327,54 @@ abstract contract LimitRouterBase is
 
             if (sharedToken == SY || totalMaking == 0) continue;
 
-            uint256 totalSy = __mintSy_Single(SY, sharedToken, totalMaking);
+            uint256 totalSy = __mintSy_Single(SY, sharedToken, totalMaking, mintSyData.inps, mintSyData.minSyOuts);
             for (uint256 i = l; i < r; i++) {
                 uint256 netToken = params[i].makingAmount;
                 uint256 netSy = (netToken * totalSy) / totalMaking;
-
-                if (_isNewOrder(params[i].order)) {
-                    require(netToken.mulDown(params[i].order.failSafeRate) <= netSy, "LOP: fail safe");
-                }
+                require(netToken.mulDown(params[i].order.failSafeRate) <= netSy, "LOP: fail safe");
 
                 params[i].makingAmount = netSy;
             }
         }
     }
 
-    function __mintSy_Single(address SY, address token, uint256 netTokenIn) private returns (uint256 netSyOut) {
+    /// @dev each token group appears at most once because params are sorted by token
+    function __mintSy_Single(
+        address SY,
+        address token,
+        uint256 netTokenIn,
+        TokenInput[] memory inps,
+        uint256[] memory minSyOuts
+    ) private returns (uint256 netSyOut) {
+        for (uint256 i = 0; i < inps.length; i++) {
+            if (inps[i].tokenIn == token) {
+                return __mintSy_Single_viaRouter(SY, token, netTokenIn, inps[i], minSyOuts[i]);
+            }
+        }
+        return __mintSy_Single_direct(SY, token, netTokenIn);
+    }
+
+    function __mintSy_Single_viaRouter(
+        address SY,
+        address token,
+        uint256 netTokenIn,
+        TokenInput memory inp,
+        uint256 minSyOut
+    ) private returns (uint256 netSyOut) {
+        require(inp.swapData.needScale, "LOP: need scale");
+        require(netTokenIn <= inp.netTokenIn, "LOP: only scale down");
+
+        // Scale down input
+        uint256 scaledMinSyOut = (minSyOut * netTokenIn) / inp.netTokenIn;
+        require(scaledMinSyOut > 0, "LOP: zero scaledMinSy");
+        inp.netTokenIn = netTokenIn;
+
+        // Approve and mint via router
+        _safeApproveInf(token, ROUTER);
+        netSyOut = IPAllActionV3(ROUTER).mintSyFromToken(address(this), SY, scaledMinSyOut, inp);
+    }
+
+    function __mintSy_Single_direct(address SY, address token, uint256 netTokenIn) private returns (uint256 netSyOut) {
         if (token == WNATIVE && !IStandardizedYield(SY).isValidTokenIn(WNATIVE)) {
             _wrap_unwrap_ETH(WNATIVE, NATIVE, netTokenIn);
             token = NATIVE;
@@ -374,12 +425,9 @@ abstract contract LimitRouterBase is
             }
 
             for (uint256 i = l; i < r; i++) {
-                if (_isNewOrder(params[i].order)) {
-                    uint256 netSy = netSyOuts[i];
-                    uint256 netToken = toMakers[i];
-
-                    require(netSy.mulDown(params[i].order.failSafeRate) <= netToken, "LOP: fail safe");
-                }
+                uint256 netSy = netSyOuts[i];
+                uint256 netToken = toMakers[i];
+                require(netSy.mulDown(params[i].order.failSafeRate) <= netToken, "LOP: fail safe");
             }
         }
     }
@@ -432,8 +480,8 @@ abstract contract LimitRouterBase is
         }
     }
 
-    function _isNewOrder(Order memory order) internal pure returns (bool) {
-        return order.salt % NEW_PRIME == 0;
+    function hashFillParams(FillOrderParams[] memory params) public pure returns (bytes32) {
+        return keccak256(abi.encode(params));
     }
 
     function hashOrder(Order memory order) public view returns (bytes32) {
@@ -455,6 +503,12 @@ abstract contract LimitRouterBase is
         feeRecipient = _feeRecipient;
     }
 
+    function setMintSySigners(address _signer1, address _signer2) public onlyOwner {
+        mintSySigner1 = _signer1;
+        mintSySigner2 = _signer2;
+        emit MintSySignersSet(_signer1, _signer2);
+    }
+
     /// @dev if zero fees are intended, it must be explicitly allowed again
     function setLnFeeRateRoots(address[] memory YTs, uint256[] memory lnFeeRateRoots, bool allowZeroFees)
         public

package/contracts/limit/PendleLimitRouter.sol

@@ -8,7 +8,7 @@ contract PendleLimitRouter is LimitRouterBase {
     using Address for address;
     using PMath for uint256;
 
-    constructor(address _WNATIVE) LimitRouterBase(_WNATIVE) {
+    constructor(address _WNATIVE, address _ROUTER) LimitRouterBase(_WNATIVE, _ROUTER) {
         _disableInitializers();
     }
 

package/contracts/limit/helpers/MintSyHelper.sol

@@ -0,0 +1,114 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.17;
+
+import "../../interfaces/IPLimitRouter.sol";
+import "../../interfaces/IPAllActionTypeV3.sol";
+import "@openzeppelin/contracts/utils/cryptography/SignatureChecker.sol";
+import "@openzeppelin/contracts-upgradeable/utils/cryptography/draft-EIP712Upgradeable.sol";
+
+abstract contract MintSyHelper is EIP712Upgradeable {
+    // forgefmt: disable-next-item
+    bytes32 internal constant SWAP_DATA_TYPEHASH = keccak256(
+        "SwapData("
+            "uint8 swapType,"
+            "address extRouter,"
+            "bytes extCalldata,"
+            "bool needScale"
+        ")"
+    );
+
+    // forgefmt: disable-next-item
+    bytes32 internal constant TOKEN_INPUT_TYPEHASH = keccak256(
+        "TokenInput("
+            "address tokenIn,"
+            "uint256 netTokenIn,"
+            "address tokenMintSy,"
+            "address pendleSwap,"
+            "SwapData swapData"
+        ")"
+        "SwapData("
+            "uint8 swapType,"
+            "address extRouter,"
+            "bytes extCalldata,"
+            "bool needScale"
+        ")"
+    );
+
+    // forgefmt: disable-next-item
+    bytes32 internal constant MINT_SY_PAYLOAD_TYPEHASH = keccak256(
+        "MintSyPayload("
+            "TokenInput[] inps,"
+            "uint256[] minSyOuts,"
+            "uint256 expiry,"
+            "bytes32 fillParamsHash"
+        ")"
+        "SwapData("
+            "uint8 swapType,"
+            "address extRouter,"
+            "bytes extCalldata,"
+            "bool needScale"
+        ")"
+        "TokenInput("
+            "address tokenIn,"
+            "uint256 netTokenIn,"
+            "address tokenMintSy,"
+            "address pendleSwap,"
+            "SwapData swapData"
+        ")"
+    );
+
+    function _verifyMintSyData(MintSyData memory mintSyData, bytes32 fillParamsHash, address signer1, address signer2)
+        internal
+        view
+    {
+        require(block.timestamp < mintSyData.expiry, "LOP: mintSy expired");
+        require(mintSyData.fillParamsHash == fillParamsHash, "LOP: mintSy params mismatch");
+        require(mintSyData.inps.length == mintSyData.minSyOuts.length, "LOP: length mismatch");
+
+        bytes32 digest =
+            hashMintSyPayload(mintSyData.inps, mintSyData.minSyOuts, mintSyData.expiry, mintSyData.fillParamsHash);
+
+        require(SignatureChecker.isValidSignatureNow(signer1, digest, mintSyData.sig1), "LOP: bad mintSy sig1");
+        require(SignatureChecker.isValidSignatureNow(signer2, digest, mintSyData.sig2), "LOP: bad mintSy sig2");
+    }
+
+    function _hashSwapData(SwapData memory d) internal pure returns (bytes32) {
+        return keccak256(abi.encode(SWAP_DATA_TYPEHASH, d.swapType, d.extRouter, keccak256(d.extCalldata), d.needScale));
+    }
+
+    function _hashTokenInput(TokenInput memory inp) internal pure returns (bytes32) {
+        return keccak256(
+            abi.encode(
+                TOKEN_INPUT_TYPEHASH,
+                inp.tokenIn,
+                inp.netTokenIn,
+                inp.tokenMintSy,
+                inp.pendleSwap,
+                _hashSwapData(inp.swapData)
+            )
+        );
+    }
+
+    function hashMintSyPayload(
+        TokenInput[] memory inps,
+        uint256[] memory minSyOuts,
+        uint256 expiry,
+        bytes32 fillParamsHash
+    ) public view returns (bytes32) {
+        bytes32[] memory inpHashes = new bytes32[](inps.length);
+        for (uint256 i = 0; i < inps.length; i++) {
+            inpHashes[i] = _hashTokenInput(inps[i]);
+        }
+        return _hashTypedDataV4(
+            keccak256(
+                abi.encode(
+                    MINT_SY_PAYLOAD_TYPEHASH,
+                    keccak256(abi.encodePacked(inpHashes)),
+                    keccak256(abi.encodePacked(minSyOuts)),
+                    expiry,
+                    fillParamsHash
+                )
+            )
+        );
+    }
+}

package/contracts/offchain-helpers/PendleFeeSetter.sol

@@ -21,8 +21,10 @@ contract PendleFeeSetter is BoringOwnableUpgradeableV2 {
     event SetterSet(address indexed setter);
 
     uint256 internal constant LIMIT_MAX_LN_FEE_RATE_ROOT = 48_790_164_169_432_003; // ln(1.05)
+    uint256 internal constant POST_FILL_AMM_LN_FEE_RATE_ROOT = 999_999_500_000; // ln(1.000001)
 
     address public immutable router;
+    address public immutable postFillRouter;
     IPLimitRouter public immutable limitRouter;
     IPGovernanceProxy public immutable govProxy;
 
@@ -35,9 +37,10 @@ contract PendleFeeSetter is BoringOwnableUpgradeableV2 {
         _;
     }
 
-    constructor(address _router, address _limitRouter, address _govProxy) {
+    constructor(address _router, address _postFillRouter, address _limitRouter, address _govProxy) {
         _disableInitializers();
         router = _router;
+        postFillRouter = _postFillRouter;
         limitRouter = IPLimitRouter(_limitRouter);
         govProxy = IPGovernanceProxy(_govProxy);
     }
@@ -50,6 +53,21 @@ contract PendleFeeSetter is BoringOwnableUpgradeableV2 {
         _setFeeFactors(_impliedRateToFeeFactor, _routerLnFeeToLimitLnFeeFactor);
     }
 
+    function setPostFillRouterAMMFee(address[] memory markets) external onlyOwnerOrSetter {
+        uint256 n = markets.length;
+
+        IPGovernanceProxy.Call[] memory calls = new IPGovernanceProxy.Call[](n);
+
+        for (uint256 i = 0; i < n; ++i) {
+            calls[i].target = IPMarket(markets[i]).factory();
+            calls[i].callData = abi.encodeCall(
+                IPMarketFactory.setOverriddenFee, (postFillRouter, markets[i], POST_FILL_AMM_LN_FEE_RATE_ROOT.Uint80())
+            );
+        }
+
+        govProxy.aggregateWithScopedAccess(calls);
+    }
+
     function setFees(address[] memory markets) external onlyOwnerOrSetter {
         uint256 n = markets.length;
 

package/contracts/offchain-helpers/PendleProxyAdmin.sol

@@ -0,0 +1,11 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.0;
+
+import {ProxyAdmin} from "@openzeppelin/contracts/proxy/transparent/ProxyAdmin.sol";
+
+/// @dev ProxyAdmin with configurable initial owner, since OZ's ProxyAdmin doesn't support setting owner in constructor.
+contract PendleProxyAdmin is ProxyAdmin {
+    constructor(address initialOwner) {
+        _transferOwnership(initialOwner);
+    }
+}

package/contracts/router/base/ActionBase.sol

@@ -323,10 +323,12 @@ abstract contract ActionBase is TokenHelper, CallbackHelper, IPLimitOrderType {
         IPLimitRouter router = IPLimitRouter(lim.limitRouter);
         netLeft = netInput;
 
+        (bytes memory normalOptData, bytes memory flashOptData) = _decodeLimOptData(lim.optData);
+
         if (lim.normalFills.length != 0) {
             _safeApproveInf(address(tokenIn), lim.limitRouter);
             (uint256 actualMaking, uint256 actualTaking, uint256 totalFee,) =
-                router.fill(lim.normalFills, receiver, netLeft, lim.optData, EMPTY_BYTES);
+                router.fill(lim.normalFills, receiver, netLeft, normalOptData, EMPTY_BYTES);
             netOut += actualMaking;
             netLeft -= actualTaking;
             netSyFee += totalFee;
@@ -337,7 +339,7 @@ abstract contract ActionBase is TokenHelper, CallbackHelper, IPLimitOrderType {
             OrderType orderType = lim.flashFills[0].order.orderType;
 
             (,, uint256 totalFee, bytes memory ret) = router.fill(
-                lim.flashFills, YT, type(uint256).max, lim.optData, abi.encode(orderType, YT, netLeft, receiver)
+                lim.flashFills, YT, type(uint256).max, flashOptData, abi.encode(orderType, YT, netLeft, receiver)
             );
             (uint256 netUse, uint256 netReceived) = abi.decode(ret, (uint256, uint256));
 
@@ -349,6 +351,18 @@ abstract contract ActionBase is TokenHelper, CallbackHelper, IPLimitOrderType {
         doMarketOrder = netLeft > netInput.mulDown(lim.epsSkipMarket);
     }
 
+    function _decodeLimOptData(bytes memory limOptData)
+        internal
+        pure
+        returns (bytes memory normalOptData, bytes memory flashOptData)
+    {
+        if (limOptData.length != 0) {
+            (uint256 version, bytes memory payload) = abi.decode(limOptData, (uint256, bytes));
+            require(version == 1, "invalid version");
+            (normalOptData, flashOptData) = abi.decode(payload, (bytes, bytes));
+        }
+    }
+
     function _isEmptyLimit(LimitOrderData calldata a) internal pure returns (bool) {
         return a.normalFills.length == 0 && a.flashFills.length == 0;
     }

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

@@ -24,7 +24,7 @@ abstract contract OKXScaleHelper {
 
     // https://web3.okx.com/build/dev-docs/dex-api/dex-smart-contract#token-approval
     function __getTokenApproveForChain(uint256 chainid) private pure returns (address) {
-        if (chainid == 1) {
+        if (chainid == 1 || chainid == 43_114) {
             return 0x40aA958dd87FC8305b97f2BA922CDdCa374bcD7f;
         }
         if (chainid == 10) {
@@ -48,6 +48,9 @@ abstract contract OKXScaleHelper {
         if (chainid == 130) {
             return 0x2e28281Cf3D58f475cebE27bec4B8a23dFC7782c;
         }
+        if (chainid == 143) {
+            return 0xf534A8a1CAD0543Cd6438f7534CA3486c01998d4;
+        }
         return address(0);
     }
 

package/deployments/1-core.json

@@ -46,6 +46,7 @@
     "poolDeployHelperV2": "0xF642d8Daa026B8aEd6dFE82FACbA2E077AF199E2",
     "limitRouter": "0x000000000000c9B3E2C3Ec88B1B4c0cD853f4321",
     "proxyAdmin": "0xA28c08f165116587D4F3E708743B4dEe155c5E64",
+    "devProxyAdmin": "0xD37eB2E6DE40a33ba68BaD94427723b66c954EA9",
     "reflector": "0x30544e00Cf296B34A9eE59E5540Ae2f9CCCD55DD",
     "commonDeploy": "0x2Ed473F528E5B320f850d17ADfe0e558f0298aA9",
     "syFactory": "0x466CeD3b33045Ea986B2f306C8D0aA8067961CF8",

package/deployments/1-offchain-helper.json

@@ -8,5 +8,5 @@
     "limitBackendHelperV2": "0xf02CdbD8F6A18c73B73331FEe3C2110e74508977",
     "checkSolvent": "0x1dE943933417D50738557Ac98FF96405CeeeeCD5",
     "externalCapGate": "0x65E04a3b2af7716B7f0765dE62Fa2f1B3290C23F",
-    "feeSetter": "0x0185921C7C6A21F1f5c45A34456C379c9bEC6A81"
+    "feeSetter": "0x95e9FC738e9C94E730536C6f28c88295d3374466"
 }

package/deployments/10-core.json

@@ -44,6 +44,7 @@
     "poolDeployHelper": "0x439B4d66255eFf74e621FBacb00D7162b588Ff4b",
     "limitRouter": "0x000000000000c9B3E2C3Ec88B1B4c0cD853f4321",
     "proxyAdmin": "0xA28c08f165116587D4F3E708743B4dEe155c5E64",
+    "devProxyAdmin": "0xD37eB2E6DE40a33ba68BaD94427723b66c954EA9",
     "reflector": "0x30544e00Cf296B34A9eE59E5540Ae2f9CCCD55DD",
     "vePendleAirdropDistributor": "0x3942F7B55094250644cFfDa7160226Caa349A38E",
     "externalRewardsDistributor": "0x33305665f69B4642D1275f4Ce81c23651674D21C",

package/deployments/10-offchain-helper.json

@@ -7,5 +7,5 @@
     "limitBackendHelperV2": "0xf02CdbD8F6A18c73B73331FEe3C2110e74508977",
     "checkSolvent": "0x1dE943933417D50738557Ac98FF96405CeeeeCD5",
     "externalCapGate": "0x65E04a3b2af7716B7f0765dE62Fa2f1B3290C23F",
-    "feeSetter": "0x0185921C7C6A21F1f5c45A34456C379c9bEC6A81"
+    "feeSetter": "0x95e9FC738e9C94E730536C6f28c88295d3374466"
 }

package/deployments/130-core.json

@@ -21,6 +21,7 @@
     },
     "pendleSwap": "0xd4F480965D2347d421F1bEC7F545682E5Ec2151D",
     "proxyAdmin": "0xA28c08f165116587D4F3E708743B4dEe155c5E64",
+    "devProxyAdmin": "0xD37eB2E6DE40a33ba68BaD94427723b66c954EA9",
     "sparkLinearDiscountOracleFactory": "0x34C91651A070664279866E5f3d6B4d5F65cbbFFb",
     "crossChainSwapHub": "0xd41c99760f4A7e27E736ED25cd6915110948Ea8a",
     "depositBoxFactory": "0x15Ff9D268ef3300a3fcCe5DE4bc4326316c5dD6D"

package/deployments/143-core.json

@@ -2,8 +2,10 @@
     "deployer": "0x1FcCC097db89A86Bfc474A1028F93958295b1Fb7",
     "network": {
         "chainId": 143,
+        "treasury": "0xCbcb48e22622a3778b6F14C2f5d258Ba026b05e6",
         "governance": "0x7877AdFaDEd756f3248a0EBfe8Ac2E2eF87b75Ac",
         "devMultisig": "0xE6F0489ED91dc27f40f9dbe8f81fccbFC16b9cb1",
+        "pendle": "0x5e49e1f85813f2b65858860a3fa231b4186f2e0e",
         "wrappedNative": "0x3bd359C1119dA7Da1D913D1C4D2B7c461115433A",
         "initialRewardFee": "50000000000000000",
         "initialInterestFee": "50000000000000000",
@@ -11,8 +13,43 @@
         "safeWaitTime": 15000,
         "hardwareDeployer": "0xeea6F790F18563E91b18DF00B89d9f79b2E6761F"
     },
+    "PENDLE": "0x5e49e1f85813f2b65858860a3fa231b4186f2e0e",
+    "governanceProxy": "0x2aD631F72fB16d91c4953A7f4260A97C2fE2f31e",
     "proxyAdmin": "0xA28c08f165116587D4F3E708743B4dEe155c5E64",
+    "devProxyAdmin": "0xD37eB2E6DE40a33ba68BaD94427723b66c954EA9",
+    "baseCodeSplitter": "0xed080cfaE31Ed1c4d4FdbE0A76Ed992Ec9171264",
+    "gaugeController": "0x7e500c6efBb00FD3227888256E477171a1304721",
+    "yieldContractFactoryV6": "0x4fe1B23ab695D99394Ab78c16A5bE358f31847F4",
+    "marketFactoryV6": "0xA3cb62a49b66eB2536cf6F3C7AC82293784888A3",
+    "pyYtLpOracle": "0x5542be50420E88dd7D5B4a3D488FA6ED82F6DAc2",
+    "router": "0x888888888889758F76e7103c6CbF23ABbF58F946",
+    "routerFacets": {
+        "ActionAddRemoveLiqV3": "0x2fb6d0753602Bf397fcE38Ec8Ee3a811cA07B3FD",
+        "ActionSwapPTV3": "0xbb0Dd79794e58795b08b599297ec55a6Afb6AB58",
+        "ActionSwapYTV3": "0x171B480B1A2ebc1acE52e46E0Bd73e7E08413ec2",
+        "ActionMiscV3": "0xac1700293346b0bEFC71bCB7E14Bf1c38a5c2a97",
+        "ActionSimple": "0xc66eeDCFf0eC9eACbbF721519E5A03c4d82Fe49b",
+        "ActionCallbackV3": "0x1F593511d7C670FbA0e2601315F6444C10bC9177",
+        "ActionStorageV4": "0x9815cA631062C29f80f5A29783DDd51E08A702db"
+    },
+    "routerStatic": "0x6813d43782395A1F2AAb42f39aeEDE03ac655e09",
+    "pendleSwap": "0xd4F480965D2347d421F1bEC7F545682E5Ec2151D",
+    "reflector": "0x73d5DBF81A4f3bFa7b335e6a2d4638D6017a4fA8",
+    "limitRouter": "0x000000000000c9B3E2C3Ec88B1B4c0cD853f4321",
+    "syFactory": "0x466CeD3b33045Ea986B2f306C8D0aA8067961CF8",
+    "commonDeploy": "0x2Ed473F528E5B320f850d17ADfe0e558f0298aA9",
+    "sparkLinearDiscountOracleFactory": "0x34C91651A070664279866E5f3d6B4d5F65cbbFFb",
+    "PendleChainlinkOracleFactory": "0x6502cda86f9110f3655512237C9FF2B9CE247c69",
+    "experimental": {
+        "PendleSparkLinearDiscountOracleFactoryWrapper": "0x9E80e2525c7289ebd6352B428f2beC53b5A4e579",
+        "MarketSweed": "0x9205aCD8A2fFD56917d4b9139bA423b4f2a70EE5"
+    },
+    "vePendleAirdropDistributor": "0x3942F7B55094250644cFfDa7160226Caa349A38E",
+    "externalRewardsDistributor": "0x33305665f69B4642D1275f4Ce81c23651674D21C",
+    "lpWrapperFactory": "0xA997a99af899951c6A3F218Ef65A0A448A9fF55a",
+    "decimalsFactory": "0x992ec6a490a4b7f256bd59e63746951d98b29be9",
+    "lpLinearDiscountOracleFactory": "0x44fb16D078E9C39B65d6c15E78EDe9736a9f2DF5",
+    "merkleDepositor": "0x3dAe3d1734cA3C7B3089D4DD03C9876e0A0102b4",
     "crossChainSwapHub": "0xd41c99760f4A7e27E736ED25cd6915110948Ea8a",
-    "depositBoxFactory": "0x15Ff9D268ef3300a3fcCe5DE4bc4326316c5dD6D",
-    "sparkLinearDiscountOracleFactory": "0x34C91651A070664279866E5f3d6B4d5F65cbbFFb"
+    "depositBoxFactory": "0x15Ff9D268ef3300a3fcCe5DE4bc4326316c5dD6D"
 }

package/deployments/143-offchain-helper.json

@@ -0,0 +1,11 @@
+{
+    "pendleMulticallV2": "0x1ca3352a55A3D69cA8e5aB06006e08aaF2bD09f1",
+    "implicitSwapfeeContract": "0x82Fae57b2A79D893D88488A7D8BdF2AC6bd2C463",
+    "simulateHelper": "0xc23Dd2807e51dd1D317e1321CBeEb9ace98531EE",
+    "supplyCapReader": "0x251CfB4E84CefecA6c1e6a4D8a0cb9c524e7484f",
+    "balanceReader": "0x2085F50305f656f96b22ECBfe0A4f5e786Ff0438",
+    "limitBackendHelperV2": "0xf02CdbD8F6A18c73B73331FEe3C2110e74508977",
+    "checkSolvent": "0x4686b7E71571845D9598aC49131B48D698C03869",
+    "externalCapGate": "0x65E04a3b2af7716B7f0765dE62Fa2f1B3290C23F",
+    "feeSetter": "0x95e9FC738e9C94E730536C6f28c88295d3374466"
+}

package/deployments/146-core.json

@@ -38,6 +38,7 @@
     "marketFactoryV6": "0x0AB3ae25c42a2f3748a018556989355D568Fa6d6",
     "poolDeployHelperV2": "0x0b692f06CA82e3075dC537224450885Fd138e655",
     "proxyAdmin": "0xA28c08f165116587D4F3E708743B4dEe155c5E64",
+    "devProxyAdmin": "0xD37eB2E6DE40a33ba68BaD94427723b66c954EA9",
     "commonDeploy": "0x2Ed473F528E5B320f850d17ADfe0e558f0298aA9",
     "syFactory": "0x466CeD3b33045Ea986B2f306C8D0aA8067961CF8",
     "receiverEndpoint": "0x3209E9412cca80B18338f2a56ADA59c484c39644",

package/deployments/146-offchain-helper.json

@@ -7,5 +7,5 @@
     "limitBackendHelperV2": "0xf02CdbD8F6A18c73B73331FEe3C2110e74508977",
     "checkSolvent": "0x21332dCAe68b603B9170d25D21fda68f18Da91df",
     "externalCapGate": "0x65E04a3b2af7716B7f0765dE62Fa2f1B3290C23F",
-    "feeSetter": "0x0185921C7C6A21F1f5c45A34456C379c9bEC6A81"
+    "feeSetter": "0x95e9FC738e9C94E730536C6f28c88295d3374466"
 }

package/deployments/42161-core.json

@@ -44,6 +44,7 @@
     "poolDeployHelper": "0xEE2eF4ADaf5Bd61FD107fD169CAe3AB79958B928",
     "limitRouter": "0x000000000000c9B3E2C3Ec88B1B4c0cD853f4321",
     "proxyAdmin": "0xA28c08f165116587D4F3E708743B4dEe155c5E64",
+    "devProxyAdmin": "0xD37eB2E6DE40a33ba68BaD94427723b66c954EA9",
     "reflector": "0x30544e00Cf296B34A9eE59E5540Ae2f9CCCD55DD",
     "vePendleAirdropDistributor": "0x3942F7B55094250644cFfDa7160226Caa349A38E",
     "externalRewardsDistributor": "0x33305665f69B4642D1275f4Ce81c23651674D21C",