@pendle/core-v2 6.1.1 → 6.1.3-swapnseed

package/build/artifacts/contracts/router/ActionStorageV4.sol/ActionStorageV4.dbg.json

@@ -1,4 +1,4 @@
 {
   "_format": "hh-sol-dbg-1",
-  "buildInfo": "../../../build-info/df3be05f70ae2389fe0a72ca1be9de65.json"
+  "buildInfo": "../../../build-info/9c640f446a230e808e7c4c91e1214a6e.json"
 }

package/build/artifacts/contracts/router/PendleRouterV4.sol/PendleRouterV4.dbg.json

@@ -1,4 +1,4 @@
 {
   "_format": "hh-sol-dbg-1",
-  "buildInfo": "../../../build-info/df3be05f70ae2389fe0a72ca1be9de65.json"
+  "buildInfo": "../../../build-info/9c640f446a230e808e7c4c91e1214a6e.json"
 }

package/build/artifacts/contracts/router/Reflector.sol/Reflector.dbg.json

@@ -1,4 +1,4 @@
 {
   "_format": "hh-sol-dbg-1",
-  "buildInfo": "../../../build-info/df3be05f70ae2389fe0a72ca1be9de65.json"
+  "buildInfo": "../../../build-info/9c640f446a230e808e7c4c91e1214a6e.json"
 }

package/build/artifacts/contracts/router/RouterStorage.sol/RouterStorage.dbg.json

@@ -1,4 +1,4 @@
 {
   "_format": "hh-sol-dbg-1",
-  "buildInfo": "../../../build-info/3885fcad17d5d083318ce76e68576b1f.json"
+  "buildInfo": "../../../build-info/180ee41ddd188bb00eb103d1b74d2d9c.json"
 }

package/build/artifacts/contracts/router/base/ActionBase.sol/ActionBase.dbg.json

@@ -1,4 +1,4 @@
 {
   "_format": "hh-sol-dbg-1",
-  "buildInfo": "../../../../build-info/df3be05f70ae2389fe0a72ca1be9de65.json"
+  "buildInfo": "../../../../build-info/9c640f446a230e808e7c4c91e1214a6e.json"
 }

package/build/artifacts/contracts/router/base/ActionDelegateBase.sol/ActionDelegateBase.dbg.json

@@ -1,4 +1,4 @@
 {
   "_format": "hh-sol-dbg-1",
-  "buildInfo": "../../../../build-info/df3be05f70ae2389fe0a72ca1be9de65.json"
+  "buildInfo": "../../../../build-info/9c640f446a230e808e7c4c91e1214a6e.json"
 }

package/build/artifacts/contracts/router/base/CallbackHelper.sol/CallbackHelper.dbg.json

@@ -1,4 +1,4 @@
 {
   "_format": "hh-sol-dbg-1",
-  "buildInfo": "../../../../build-info/3885fcad17d5d083318ce76e68576b1f.json"
+  "buildInfo": "../../../../build-info/9c640f446a230e808e7c4c91e1214a6e.json"
 }

package/build/artifacts/contracts/router/math/ApproxStateLib.sol/ApproxStateLib.dbg.json

@@ -1,4 +1,4 @@
 {
   "_format": "hh-sol-dbg-1",
-  "buildInfo": "../../../../build-info/df3be05f70ae2389fe0a72ca1be9de65.json"
+  "buildInfo": "../../../../build-info/9c640f446a230e808e7c4c91e1214a6e.json"
 }

package/build/artifacts/contracts/router/math/MarketApproxEstimateLib.sol/MarketApproxEstimateLib.dbg.json

@@ -1,4 +1,4 @@
 {
   "_format": "hh-sol-dbg-1",
-  "buildInfo": "../../../../build-info/df3be05f70ae2389fe0a72ca1be9de65.json"
+  "buildInfo": "../../../../build-info/9c640f446a230e808e7c4c91e1214a6e.json"
 }

package/build/artifacts/contracts/router/math/MarketApproxLibOnchain.sol/MarketApproxPtInLibOnchain.dbg.json

@@ -1,4 +1,4 @@
 {
   "_format": "hh-sol-dbg-1",
-  "buildInfo": "../../../../build-info/df3be05f70ae2389fe0a72ca1be9de65.json"
+  "buildInfo": "../../../../build-info/9c640f446a230e808e7c4c91e1214a6e.json"
 }

package/build/artifacts/contracts/router/math/MarketApproxLibOnchain.sol/MarketApproxPtOutLibOnchain.dbg.json

@@ -1,4 +1,4 @@
 {
   "_format": "hh-sol-dbg-1",
-  "buildInfo": "../../../../build-info/df3be05f70ae2389fe0a72ca1be9de65.json"
+  "buildInfo": "../../../../build-info/9c640f446a230e808e7c4c91e1214a6e.json"
 }

package/build/artifacts/contracts/router/math/MarketApproxLibV2.sol/MarketApproxPtInLibV2.dbg.json

@@ -1,4 +1,4 @@
 {
   "_format": "hh-sol-dbg-1",
-  "buildInfo": "../../../../build-info/df3be05f70ae2389fe0a72ca1be9de65.json"
+  "buildInfo": "../../../../build-info/9c640f446a230e808e7c4c91e1214a6e.json"
 }

package/build/artifacts/contracts/router/math/MarketApproxLibV2.sol/MarketApproxPtOutLibV2.dbg.json

@@ -1,4 +1,4 @@
 {
   "_format": "hh-sol-dbg-1",
-  "buildInfo": "../../../../build-info/df3be05f70ae2389fe0a72ca1be9de65.json"
+  "buildInfo": "../../../../build-info/9c640f446a230e808e7c4c91e1214a6e.json"
 }

package/build/artifacts/contracts/router/swap-aggregator/IPSwapAggregator.sol/IPSwapAggregator.dbg.json

@@ -1,4 +1,4 @@
 {
   "_format": "hh-sol-dbg-1",
-  "buildInfo": "../../../../build-info/3885fcad17d5d083318ce76e68576b1f.json"
+  "buildInfo": "../../../../build-info/180ee41ddd188bb00eb103d1b74d2d9c.json"
 }

package/build/artifacts/contracts/router/swap-aggregator/OKXScaleHelper.sol/IOKXDexRouter.dbg.json

@@ -1,4 +1,4 @@
 {
   "_format": "hh-sol-dbg-1",
-  "buildInfo": "../../../../build-info/3885fcad17d5d083318ce76e68576b1f.json"
+  "buildInfo": "../../../../build-info/180ee41ddd188bb00eb103d1b74d2d9c.json"
 }

package/build/artifacts/contracts/router/swap-aggregator/OKXScaleHelper.sol/OKXScaleHelper.dbg.json

@@ -1,4 +1,4 @@
 {
   "_format": "hh-sol-dbg-1",
-  "buildInfo": "../../../../build-info/3885fcad17d5d083318ce76e68576b1f.json"
+  "buildInfo": "../../../../build-info/180ee41ddd188bb00eb103d1b74d2d9c.json"
 }

package/build/artifacts/contracts/router/swap-aggregator/ParaswapScaleHelper.sol/IAugustusV6.dbg.json

@@ -1,4 +1,4 @@
 {
   "_format": "hh-sol-dbg-1",
-  "buildInfo": "../../../../build-info/3885fcad17d5d083318ce76e68576b1f.json"
+  "buildInfo": "../../../../build-info/180ee41ddd188bb00eb103d1b74d2d9c.json"
 }

package/build/artifacts/contracts/router/swap-aggregator/ParaswapScaleHelper.sol/ParaswapScaleHelper.dbg.json

@@ -1,4 +1,4 @@
 {
   "_format": "hh-sol-dbg-1",
-  "buildInfo": "../../../../build-info/3885fcad17d5d083318ce76e68576b1f.json"
+  "buildInfo": "../../../../build-info/180ee41ddd188bb00eb103d1b74d2d9c.json"
 }

package/build/artifacts/contracts/router/swap-aggregator/PendleSwap.sol/IKyberScalingHelper.dbg.json

@@ -1,4 +1,4 @@
 {
   "_format": "hh-sol-dbg-1",
-  "buildInfo": "../../../../build-info/3885fcad17d5d083318ce76e68576b1f.json"
+  "buildInfo": "../../../../build-info/180ee41ddd188bb00eb103d1b74d2d9c.json"
 }

package/build/artifacts/contracts/router/swap-aggregator/PendleSwap.sol/IOdosRouterV2.dbg.json

@@ -1,4 +1,4 @@
 {
   "_format": "hh-sol-dbg-1",
-  "buildInfo": "../../../../build-info/3885fcad17d5d083318ce76e68576b1f.json"
+  "buildInfo": "../../../../build-info/180ee41ddd188bb00eb103d1b74d2d9c.json"
 }

package/build/artifacts/contracts/router/swap-aggregator/PendleSwap.sol/PendleSwap.dbg.json

@@ -1,4 +1,4 @@
 {
   "_format": "hh-sol-dbg-1",
-  "buildInfo": "../../../../build-info/3885fcad17d5d083318ce76e68576b1f.json"
+  "buildInfo": "../../../../build-info/180ee41ddd188bb00eb103d1b74d2d9c.json"
 }

package/contracts/interfaces/IMarketSweed.sol

@@ -0,0 +1,23 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.0;
+
+import "./IPAllActionV3.sol";
+
+interface IMarketSweed {
+    struct ApproxSweedParams {
+        uint256 targetLnImpliedRate;
+        uint256 eps;
+        uint256 maxPtToSwap;
+        int256 guessOffchain;
+        uint256 maxIteration;
+    }
+
+    function seedAtImpliedRate(
+        address receiver,
+        address market,
+        uint256 minLpOut,
+        uint256 minYtOut,
+        TokenInput calldata input,
+        ApproxSweedParams calldata sweedParams
+    ) external payable returns (uint256 netLpOut, uint256 netYtOut, int256 guessedAmountPtToSwap);
+}

package/contracts/interfaces/IPCommonPoolDeployHelperV2.sol

@@ -27,4 +27,13 @@ interface IPCommonPoolDeployHelperV2 is IPPoolDeployHelperV2 {
         uint256 amountToSeed,
         address syOwner
     ) external returns (PoolDeploymentAddrs memory);
+
+    function deployCommonMarketById(
+        bytes32 id,
+        bytes memory constructorParams,
+        PoolConfig memory config,
+        address tokenToSeedLiqudity,
+        uint256 amountToSeed,
+        address syOwner
+    ) external returns (PoolDeploymentAddrs memory);
 }

package/contracts/interfaces/IPGovernanceProxy.sol

@@ -2,6 +2,12 @@
 pragma solidity ^0.8.0;
 
 interface IPGovernanceProxy {
+    event ModifyScopedAccess(address indexed caller, bytes4 indexed selector, address indexed target, bool access);
+
+    event ModifySelectorAdmin(address indexed addr, bytes4 indexed selector, bool isAdmin);
+
+    event SetAllowedSelectors(bytes4[] selectors, bytes32 indexed role); // Deprecated
+
     struct Call {
         address target;
         uint256 value;
@@ -12,13 +18,18 @@ interface IPGovernanceProxy {
 
     function aggregate(Call[] calldata calls) external payable returns (bytes[] memory rtnData);
 
-    event SetAllowedSelectors(bytes4[] selectors, bytes32 indexed role);
+    function aggregateWithScopedAccess(Call[] calldata calls) external payable returns (bytes[] memory rtnData);
 
-    function ALICE() external view returns (bytes32);
+    function isSelectorAdminOf(address addr, bytes4 selector) external view returns (bool);
 
-    function BOB() external view returns (bytes32);
+    function hasScopedAccess(address caller, bytes4 selector, address target) external view returns (bool);
 
-    function CHARLIE() external view returns (bytes32);
+    function modifySelectorAdmin(address addr, bytes4[] memory selectors, bool[] memory isAdmins) external;
 
-    function allowedSelectors(bytes4 selector) external view returns (bytes32);
+    function modifyScopedAccess(
+        address caller,
+        address[] memory targets,
+        bytes4 selector,
+        bool[] memory accesses
+    ) external;
 }

package/contracts/offchain-helpers/MarketSweed.sol

@@ -0,0 +1,230 @@
+// 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/IMarketSweed.sol";
+
+contract MarketSweed is ActionBase, IMarketSweed {
+    using PMath for uint256;
+    using PMath for int256;
+    using PYIndexLib for PYIndex;
+    using MarketMathCore for MarketState;
+    using PYIndexLib for IPYieldToken;
+
+    address public immutable router;
+
+    struct MarketTokens {
+        IStandardizedYield SY;
+        IPPrincipalToken PT;
+        IPYieldToken YT;
+    }
+
+    constructor(address _router, address _dustReceiver) ActionBase(_dustReceiver) {
+        router = _router;
+    }
+
+    function seedAtImpliedRate(
+        address receiver,
+        address market,
+        uint256 minLpOut,
+        uint256 minYtOut,
+        TokenInput calldata input,
+        ApproxSweedParams calldata sweedParams
+    ) external payable returns (uint256 netLpOut, uint256 netYtOut, int256 guessedAmountPtToSwap) {
+        MarketTokens memory tokens;
+        (tokens.SY, tokens.PT, tokens.YT) = IPMarket(market).readTokens();
+
+        _mintSyFromToken(address(this), address(tokens.SY), 1, input);
+
+        uint256 netPtOut;
+        (netPtOut, netYtOut, guessedAmountPtToSwap) = _swap(receiver, market, tokens, sweedParams);
+
+        uint256 netYtFromSeed;
+        (netLpOut, netYtFromSeed, ) = _seed(receiver, market, tokens.SY, tokens.YT, _selfBalance(tokens.SY), netPtOut);
+        netYtOut += netYtFromSeed;
+
+        if (netLpOut < minLpOut) revert("Slippage: INSUFFICIENT_LP_OUT");
+        if (netYtOut < minYtOut) revert("Slippage: INSUFFICIENT_YT_OUT");
+    }
+
+    function _seed(
+        address receiver,
+        address market,
+        IStandardizedYield SY,
+        IPYieldToken YT,
+        uint256 netSyIn,
+        uint256 netPtIn
+    ) internal returns (uint256 netLpOut, uint256 netYtOut, uint256 netSyMintPy) {
+        MarketState memory state = _readMarket(market);
+
+        uint256 netSyDual = 0;
+        if (netPtIn > 0) {
+            /** Add dual SY + PT */
+            uint256 netPtDual;
+            (, , netSyDual, netPtDual) = _readMarket(market).addLiquidity(netSyIn, netPtIn, block.timestamp);
+            if (netPtIn > netPtDual || netSyDual == netSyIn) {
+                revert("MS: Bought too much PT");
+            }
+            netSyIn -= netSyDual;
+            _transferOut(YT.PT(), market, netPtDual);
+        }
+
+        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);
+
+        // PT goes to market, YT goes to receiver
+        netYtOut = YT.mintPY(market, receiver);
+
+        // the rest of SY goes to market
+        _transferOut(address(SY), market, netSyAddLiquidity + netSyDual);
+
+        (netLpOut, , ) = IPMarket(market).mint(receiver, netSyAddLiquidity, netYtOut);
+    }
+
+    function _swap(
+        address receiver,
+        address market,
+        MarketTokens memory tokens,
+        ApproxSweedParams memory sweedParams
+    ) internal returns (uint256 amountPtToAccount, uint256 amountYTToAccount, int256 guessedSwap) {
+        PYIndex index = _getPYIndex(market);
+        MarketState memory state = _readMarket(market);
+        MarketPreCompute memory comp = state.getMarketPreCompute(index, block.timestamp);
+
+        if (state.lastLnImpliedRate > sweedParams.targetLnImpliedRate) {
+            // Normalize maxPtToSwap
+            sweedParams.maxPtToSwap = PMath.min(
+                sweedParams.maxPtToSwap,
+                MarketApproxPtOutLibOnchain.calcMaxPtOut(comp, state.totalPt)
+            );
+
+            int256 amountSyToAccount;
+
+            (guessedSwap, amountSyToAccount) = _calcAmountPtToBuy(state, index, sweedParams);
+            amountPtToAccount = guessedSwap.Uint();
+
+            _transferOut(address(tokens.SY), market, amountSyToAccount.abs());
+            IPMarket(market).swapSyForExactPt(address(this), guessedSwap.abs(), EMPTY_BYTES);
+        } else {
+            // Normalize maxPtToSwap
+            sweedParams.maxPtToSwap = PMath.min(
+                sweedParams.maxPtToSwap,
+                MarketApproxPtInLibOnchain.calcSoftMaxPtIn(state, comp)
+            );
+
+            guessedSwap = _calcAmountPtToSell(state, index, sweedParams);
+
+            uint256 amountPtToSell = guessedSwap.abs();
+            amountYTToAccount = amountPtToSell;
+
+            _transferOut(address(tokens.SY), address(tokens.YT), index.assetToSyUp(amountPtToSell));
+            uint256 amountPYOut = tokens.YT.mintPY(market, receiver);
+
+            assert(amountPYOut >= amountPtToSell);
+
+            // 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,
+        PYIndex index,
+        ApproxSweedParams memory sweedParams
+    ) internal view returns (int256 amountPtToSwapToAccount, int256 amountSyToAccount) {
+        int256 refAmt = sweedParams.maxPtToSwap.Int();
+        int256 accPtToAccount = 0;
+
+        for (uint256 iter = 0; iter < sweedParams.maxIteration; ++iter) {
+            int256 guess;
+            if (iter == 0 && _isValidGuessOffchain(sweedParams, true)) {
+                guess = sweedParams.guessOffchain;
+            } else {
+                refAmt /= 2;
+                guess = accPtToAccount + refAmt;
+            }
+
+            MarketState memory localState = _deepCopy(state);
+
+            // // Will not revert. maxPtToBuy should already be normalized
+            (int256 localAmountSyToAccount, , ) = localState.executeTradeCore(index, guess, block.timestamp);
+
+            if (PMath.isAApproxB(localState.lastLnImpliedRate, sweedParams.targetLnImpliedRate, sweedParams.eps)) {
+                return (guess, localAmountSyToAccount);
+            }
+
+            if (localState.lastLnImpliedRate > sweedParams.targetLnImpliedRate) {
+                accPtToAccount += refAmt;
+            }
+        }
+        revert("_calcAmountPtToBuy: failed");
+    }
+
+    function _calcAmountPtToSell(
+        MarketState memory state,
+        PYIndex index,
+        ApproxSweedParams memory sweedParams
+    ) internal view returns (int256 amountPtToSwapToAccount) {
+        int256 refAmt = sweedParams.maxPtToSwap.Int();
+        int256 accPtToAccount = 0;
+
+        for (uint256 iter = 0; iter < sweedParams.maxIteration; ++iter) {
+            int256 guess;
+            if (iter == 0 && _isValidGuessOffchain(sweedParams, false)) {
+                guess = sweedParams.guessOffchain;
+            } else {
+                refAmt /= 2;
+                guess = accPtToAccount - refAmt;
+            }
+
+            MarketState memory localState = _deepCopy(state);
+
+            // Will not revert. maxPtToSell should already be normalized
+            localState.executeTradeCore(index, guess, block.timestamp);
+
+            if (PMath.isAApproxB(localState.lastLnImpliedRate, sweedParams.targetLnImpliedRate, sweedParams.eps)) {
+                return guess;
+            }
+
+            if (localState.lastLnImpliedRate < sweedParams.targetLnImpliedRate) {
+                accPtToAccount -= refAmt;
+            }
+        }
+        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;
+    }
+
+    function _isValidGuessOffchain(ApproxSweedParams memory sweedParams, bool isBuyingPt) internal pure returns (bool) {
+        if (sweedParams.guessOffchain == 0) return false;
+        if (isBuyingPt != (sweedParams.guessOffchain > 0)) return false;
+        return sweedParams.guessOffchain.abs() <= sweedParams.maxPtToSwap;
+    }
+}

package/contracts/offchain-helpers/PendleGovernanceProxy.sol

@@ -13,30 +13,34 @@ import "@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.sol";
 contract PendleGovernanceProxy is AccessControlUpgradeable, UUPSUpgradeable, IPGovernanceProxy {
     bytes32 public constant GUARDIAN = keccak256("GUARDIAN");
 
-    bytes32 public constant ALICE = keccak256("ALICE");
-    bytes32 public constant BOB = keccak256("BOB");
-    bytes32 public constant CHARLIE = keccak256("CHARLIE");
-
-    mapping(bytes4 => bytes32) public allowedSelectors;
+    mapping(bytes4 => bytes32) public __deprecated_allowedSelectors;
+
+    // Only the [ADMIN] (governance) of PendleGovernanceProxy can modify one address to be
+    // a selector admin of some selectors.
+    //
+    // A [selector admin] of a selector can grant/revoke scoped access of that selector
+    // to/from ANY caller and ANY target.
+    //
+    // For example: [0xdeployer] is a selector admin of `updateSupplyCap(uint256)`, he can
+    // grant/revoke the scoped access of, say [0xalice] to call `updateSupplyCap(uint256)`
+    // on ANY target contract (in this case, SYs).
+    //
+    // Changes on execution:
+    // - aggregate(Call[]): is now callable by [ADMIN] only
+    // - aggregateWithScopedAccess(Call[]): new function to let anyone with scoped access
+    // to execute calls
+
+    mapping(address caller => mapping(bytes4 selector => bool isAdmin)) public isSelectorAdminOf;
+    mapping(address caller => mapping(bytes4 selector => mapping(address target => bool isAllowed)))
+        public hasScopedAccess;
 
     modifier onlyGuardian() {
-        require(hasRole(GUARDIAN, msg.sender) || hasRole(DEFAULT_ADMIN_ROLE, msg.sender), "n/a");
+        require(hasRole(GUARDIAN, msg.sender) || hasRole(DEFAULT_ADMIN_ROLE, msg.sender), "PGP: n/a");
         _;
     }
 
     modifier onlyAdmin() {
-        require(hasRole(DEFAULT_ADMIN_ROLE, msg.sender), "n/a");
-        _;
-    }
-
-    modifier onlyHaveSomeRole() {
-        require(
-            hasRole(ALICE, msg.sender) ||
-                hasRole(BOB, msg.sender) ||
-                hasRole(CHARLIE, msg.sender) ||
-                hasRole(DEFAULT_ADMIN_ROLE, msg.sender),
-            "n/a"
-        );
+        require(hasRole(DEFAULT_ADMIN_ROLE, msg.sender), "PGP: n/a");
         _;
     }
 
@@ -44,14 +48,42 @@ contract PendleGovernanceProxy is AccessControlUpgradeable, UUPSUpgradeable, IPG
         _disableInitializers();
     }
 
-    function aggregate(Call[] calldata calls) external payable onlyHaveSomeRole returns (bytes[] memory) {
-        bool isAdmin = hasRole(DEFAULT_ADMIN_ROLE, msg.sender);
+    function aggregate(Call[] calldata calls) external payable onlyAdmin returns (bytes[] memory) {
+        return _aggregate(calls);
+    }
 
-        if (!isAdmin) {
-            for (uint256 i = 0; i < calls.length; i++) {
-                bytes4 selector = bytes4(calls[i].callData[:4]);
-                require(hasRole(allowedSelectors[selector], msg.sender), "n/a");
-            }
+    /*///////////////////////////////////////////////////////////////
+                            SCOPED ACCESS
+    //////////////////////////////////////////////////////////////*/
+
+    function modifySelectorAdmin(address addr, bytes4[] memory selectors, bool[] memory isAdmins) external onlyAdmin {
+        require(selectors.length == isAdmins.length, "PGP: Array length mismatch");
+
+        for (uint256 i = 0; i < selectors.length; i++) {
+            isSelectorAdminOf[addr][selectors[i]] = isAdmins[i];
+            emit ModifySelectorAdmin(addr, selectors[i], isAdmins[i]);
+        }
+    }
+
+    function modifyScopedAccess(
+        address caller,
+        address[] memory targets,
+        bytes4 selector,
+        bool[] memory accesses
+    ) external {
+        require(targets.length == accesses.length, "PGP: Array length mismatch");
+        require(hasRole(DEFAULT_ADMIN_ROLE, msg.sender) || isSelectorAdminOf[msg.sender][selector], "PGP: n/a");
+
+        for (uint256 i = 0; i < targets.length; i++) {
+            hasScopedAccess[caller][selector][targets[i]] = accesses[i];
+            emit ModifyScopedAccess(caller, selector, targets[i], accesses[i]);
+        }
+    }
+
+    function aggregateWithScopedAccess(Call[] calldata calls) external payable returns (bytes[] memory) {
+        for (uint256 i = 0; i < calls.length; i++) {
+            bytes4 selector = bytes4(calls[i].callData[:4]);
+            require(hasScopedAccess[msg.sender][selector][calls[i].target], "PGP: n/a");
         }
 
         return _aggregate(calls);
@@ -75,13 +107,6 @@ contract PendleGovernanceProxy is AccessControlUpgradeable, UUPSUpgradeable, IPG
                             ADMIN CALL
     //////////////////////////////////////////////////////////////*/
 
-    function setAllowedSelectors(bytes4[] calldata selectors, bytes32 role) external onlyAdmin {
-        for (uint256 i = 0; i < selectors.length; i++) {
-            allowedSelectors[selectors[i]] = role;
-        }
-        emit SetAllowedSelectors(selectors, role);
-    }
-
     function _aggregate(Call[] calldata calls) internal returns (bytes[] memory rtnData) {
         uint256 length = calls.length;
         rtnData = new bytes[](length);

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

@@ -7,13 +7,15 @@ import "../../interfaces/IOwnable.sol";
 import "../../core/libraries/BoringOwnableUpgradeableV2.sol";
 
 contract PendleCommonPoolDeployHelperV2 is PendlePoolDeployHelperV2, BoringOwnableUpgradeableV2 {
-    bytes32 public constant ERC4626_DEPLOY_ID = keccak256("PendleERC4626SYV2");
-    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");
+    
+    bytes32 public constant ERC4626_DEPLOY_ID = keccak256("PendleERC4626SYV2");                                     // 0x1278efc0e6754cd30fef2df25ff5ced072ebb194d348b0b1b9548166d24352ef
+    bytes32 public constant ERC4626_NOT_REDEEMABLE_DEPLOY_ID = keccak256("PendleERC4626NotRedeemableToAssetSYV2");  // 0x6f089cd4afdd945c5c26b3f4542d0c294d19ec0e339c6ce4f8eafa94d700d05d
+    bytes32 public constant ERC20_DEPLOY_ID = keccak256("PendleERC20SY");                                           // 0xfcf22a9a515753d83e4f2a81cf368c7226408c64f52411ae95241ebf5ed53304
+    
+    bytes32 public constant ERC4626_WITH_ADAPTER_ID = keccak256("PendleERC4626WithAdapterSY");                      // 0x73f41560741d6765943d3c955034291fe23d9141e3a4719bc97422d5bf019adc
+    bytes32 public constant ERC4626_NO_REDEEM_WITH_ADAPTER_ID = keccak256("PendleERC4626NoRedeemWithAdapterSY");    // 0x3b8dd2b992f773444e5422ba1db289c4657c57110d740dca7975dc095632ef23
+    bytes32 public constant ERC20_WITH_ADAPTER_ID = keccak256("PendleERC20WithAdapterSY");                          // 0xe5cce2b1999bf8c2cc4cf6d96d0569a24d8b782ba1647c09a8e1aa8bbfb98996
+    bytes32 public constant ERC4626_NO_DEPOSIT_NO_REDEEM = keccak256("PendleERC4626NoRedeemNoDepositUpgSY");        // 0x5c1cddc0128e0b02bb711f84a022bf1c13177d4ab028830b702f3a77280025ea
 
     address public immutable syFactory;
 
@@ -31,6 +33,18 @@ contract PendleCommonPoolDeployHelperV2 is PendlePoolDeployHelperV2, BoringOwnab
         __BoringOwnableV2_init(_owner);
     }
 
+    function deployCommonMarketById(
+        bytes32 id,
+        bytes memory constructorParams,
+        PoolConfig memory config,
+        address tokenToSeedLiqudity,
+        uint256 amountToSeed,
+        address syOwner
+    ) external returns (PoolDeploymentAddrs memory) {
+        address SY = IPCommonSYFactory(syFactory).deploySY(id, constructorParams, syOwner);
+        return deploy5115MarketAndSeedLiquidity(SY, config, tokenToSeedLiqudity, amountToSeed);
+    }
+
     // Those 3 are all not payable as they should not accept tokenIn as native
 
     function deployERC4626Market(

package/deployments/10-core.json

@@ -44,7 +44,7 @@
     "proxyAdmin": "0xA28c08f165116587D4F3E708743B4dEe155c5E64",
     "reflector": "0x73d5DBF81A4f3bFa7b335e6a2d4638D6017a4fA8",
     "vePendleAirdropDistributor": "0x3942F7B55094250644cFfDa7160226Caa349A38E",
-    "externalRewardsDistributor": "0xae898a7d07f8e27f25e13d0f351a7401f9a5bf9d",
+    "externalRewardsDistributor": "0x33305665f69B4642D1275f4Ce81c23651674D21C",
     "commonDeploy": "0x2Ed473F528E5B320f850d17ADfe0e558f0298aA9",
     "syFactory": "0x466CeD3b33045Ea986B2f306C8D0aA8067961CF8",
     "sparkLinearDiscountOracleFactory": "0x34C91651A070664279866E5f3d6B4d5F65cbbFFb",

package/package.json

@@ -2,7 +2,7 @@
   "name": "@pendle/core-v2",
   "description": "Core smart contracts of Pendle Protocol.",
   "license": "BUSL-1.1",
-  "version": "6.1.1",
+  "version": "6.1.3-swapnseed",
   "homepage": "https://pendle.finance",
   "keywords": [
     "pendle",
@@ -56,4 +56,4 @@
   "publishConfig": {
     "access": "public"
   }
-}
+}