@pendle/core-v2 6.3.0-beta → 6.3.0-sweedtest

package/contracts/offchain-helpers/BaseSplitCodeFactoryContract.sol

@@ -1,8 +1,8 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity ^0.8.17;
 
-import "../core/libraries/BoringOwnableUpgradeableV2.sol";
 import "../core/libraries/BaseSplitCodeFactory.sol";
+import "../core/libraries/BoringOwnableUpgradeableV2.sol";
 
 contract BaseSplitCodeFactoryContract is BoringOwnableUpgradeableV2 {
     event Deployed(
@@ -17,10 +17,7 @@ contract BaseSplitCodeFactoryContract is BoringOwnableUpgradeableV2 {
         __BoringOwnableV2_init(msg.sender);
     }
 
-    function deploy(
-        string memory name,
-        bytes calldata creationCode
-    )
+    function deploy(string memory name, bytes calldata creationCode)
         external
         onlyOwner
         returns (
@@ -30,8 +27,9 @@ contract BaseSplitCodeFactoryContract is BoringOwnableUpgradeableV2 {
             uint256 creationCodeSizeB
         )
     {
-        (creationCodeContractA, creationCodeSizeA, creationCodeContractB, creationCodeSizeB) = BaseSplitCodeFactory
-            .setCreationCode(creationCode);
+        (
+            creationCodeContractA, creationCodeSizeA, creationCodeContractB, creationCodeSizeB
+        ) = BaseSplitCodeFactory.setCreationCode(creationCode);
         emit Deployed(name, creationCodeContractA, creationCodeSizeA, creationCodeContractB, creationCodeSizeB);
     }
 }

package/contracts/offchain-helpers/Broadcaster.sol

@@ -1,14 +1,14 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity ^0.8.17;
 
-import "../interfaces/IPVotingController.sol";
 import "../LiquidityMining/libraries/WeekMath.sol";
 import "../core/libraries/BoringOwnableUpgradeableV2.sol";
 import "../core/libraries/TokenHelper.sol";
+import "../interfaces/IPVotingController.sol";
 
 import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
-import "@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.sol";
 import "@openzeppelin/contracts/proxy/Proxy.sol";
+import "@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.sol";
 
 contract Broadcaster is Initializable, BoringOwnableUpgradeableV2, UUPSUpgradeable, TokenHelper {
     IPVotingController public immutable votingController;
@@ -28,7 +28,7 @@ contract Broadcaster is Initializable, BoringOwnableUpgradeableV2, UUPSUpgradeab
         lastBroadcastedWeek = currentWeek;
 
         votingController.finalizeEpoch();
-        for (uint256 i = 0; i < chainIds.length; ) {
+        for (uint256 i = 0; i < chainIds.length;) {
             uint64 chainId = chainIds[i];
             uint256 fee = votingController.getBroadcastResultFee(chainId);
             votingController.broadcastResults{value: fee}(chainId);

package/contracts/offchain-helpers/BytesLib.sol

@@ -439,8 +439,8 @@ library BytesLib {
                 let cc := add(_postBytes, 0x20)
 
                 for {
-                    // the next line is the loop condition:
-                    // while(uint256(mc < endWord) + cb == 2)
+                // the next line is the loop condition:
+                // while(uint256(mc < endWord) + cb == 2)
                 } eq(add(lt(mc, endMinusWord), cb), 2) {
                     mc := add(mc, 0x20)
                     cc := add(cc, 0x20)
@@ -527,9 +527,7 @@ library BytesLib {
 
                         // the next line is the loop condition:
                         // while(uint256(mc < end) + cb == 2)
-                        for {
-
-                        } eq(add(lt(mc, end), cb), 2) {
+                        for {} eq(add(lt(mc, end), cb), 2) {
                             sc := add(sc, 1)
                             mc := add(mc, 0x20)
                         } {

package/contracts/offchain-helpers/EmptyUUPS.sol

@@ -1,9 +1,9 @@
 // SPDX-License-Identifier: MIT
 
 pragma solidity ^0.8.17;
-import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
-import "@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.sol";
 import "../core/libraries/BoringOwnableUpgradeableV2.sol";
+import "@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.sol";
+import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
 
 contract EmptyUUPS is Initializable, UUPSUpgradeable, BoringOwnableUpgradeableV2 {
     constructor() initializer {}

package/contracts/offchain-helpers/ExpiredLpPtRedeemer.sol

@@ -1,12 +1,12 @@
 // SPDX-License-Identifier: SEE LICENSE IN LICENSE
 pragma solidity ^0.8.0;
 
-import "../router/base/ActionBase.sol";
+import "../core/libraries/BoringOwnableUpgradeableV2.sol";
 import "../interfaces/IPActionMiscV3.sol";
 import "../interfaces/IPReflector.sol";
-import "../core/libraries/BoringOwnableUpgradeableV2.sol";
-import "@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.sol";
+import "../router/base/ActionBase.sol";
 import "@openzeppelin/contracts-upgradeable/security/ReentrancyGuardUpgradeable.sol";
+import "@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.sol";
 
 contract ExpiredLpPtRedeemer is TokenHelper, ReentrancyGuardUpgradeable, BoringOwnableUpgradeableV2, UUPSUpgradeable {
     mapping(address => bool) public whitelistedMarkets;
@@ -46,11 +46,8 @@ contract ExpiredLpPtRedeemer is TokenHelper, ReentrancyGuardUpgradeable, BoringO
 
         if (netLpIn > 0) {
             _transferFrom(IERC20(market), msg.sender, market, netLpIn);
-            (uint256 netSyFromRemove, uint256 netPtFromRemove) = IPMarket(market).burn(
-                address(this),
-                address(this),
-                netLpIn
-            );
+            (uint256 netSyFromRemove, uint256 netPtFromRemove) =
+                IPMarket(market).burn(address(this), address(this), netLpIn);
 
             totalSyRedeem += netSyFromRemove;
             totalPtRedeem += netPtFromRemove;

package/contracts/offchain-helpers/LegacyNFTHelper.sol

@@ -20,11 +20,7 @@ interface StarNFTV1 {
     event ApprovalForAll(address indexed account, address indexed operator, bool approved);
     event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
     event TransferBatch(
-        address indexed operator,
-        address indexed from,
-        address indexed to,
-        uint256[] ids,
-        uint256[] values
+        address indexed operator, address indexed from, address indexed to, uint256[] ids, uint256[] values
     );
     event TransferSingle(address indexed operator, address indexed from, address indexed to, uint256 id, uint256 value);
     event URI(string value, uint256 indexed id);

package/contracts/offchain-helpers/LimitBackendHelperV2.sol

@@ -2,11 +2,11 @@
 
 pragma solidity ^0.8.17;
 
-import "../interfaces/IPLimitRouter.sol";
+import "../core/libraries/Errors.sol";
 import "../core/libraries/TokenHelper.sol";
+import "../interfaces/IPLimitRouter.sol";
 import "../interfaces/IStandardizedYield.sol";
 import "../interfaces/IWETH.sol";
-import "../core/libraries/Errors.sol";
 import "./BytesLib.sol";
 
 contract LimitBackendHelperV2 is TokenHelper {
@@ -19,11 +19,11 @@ contract LimitBackendHelperV2 is TokenHelper {
     }
 
     /// @notice vanilla read
-    function readSingleToken(
-        address token,
-        address[] calldata owners,
-        address spender
-    ) public view returns (uint256[] memory balances, uint256[] memory allowances) {
+    function readSingleToken(address token, address[] calldata owners, address spender)
+        public
+        view
+        returns (uint256[] memory balances, uint256[] memory allowances)
+    {
         balances = new uint256[](owners.length);
         allowances = new uint256[](owners.length);
         for (uint256 i = 0; i < owners.length; i++) {
@@ -33,11 +33,11 @@ contract LimitBackendHelperV2 is TokenHelper {
     }
 
     /// @notice auto return balances and allowances the input tokens of the orders, based on type
-    function readMultiTokens(
-        address[] calldata tokens,
-        address[] calldata owners,
-        address spender
-    ) public view returns (uint256[] memory balances, uint256[] memory allowances) {
+    function readMultiTokens(address[] calldata tokens, address[] calldata owners, address spender)
+        public
+        view
+        returns (uint256[] memory balances, uint256[] memory allowances)
+    {
         require(tokens.length == owners.length, "Length mismatch");
         balances = new uint256[](owners.length);
         allowances = new uint256[](owners.length);

package/contracts/offchain-helpers/MarketSweed.sol

@@ -0,0 +1,246 @@
+// 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;
+
+    struct MarketTokens {
+        IStandardizedYield SY;
+        IPPrincipalToken PT;
+        IPYieldToken YT;
+    }
+
+    // solhint-disable no-empty-blocks
+    constructor() {}
+
+    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, _selfBalance(tokens.SY), netPtOut);
+        netYtOut += netYtFromSeed;
+
+        if (netLpOut < minLpOut) revert("Slippage: INSUFFICIENT_LP_OUT");
+        if (netYtOut < minYtOut) revert("Slippage: INSUFFICIENT_YT_OUT");
+    }
+
+    function mintPYFromToken__noCall(
+        address YT,
+        TokenInput calldata input
+    ) external payable returns (uint256 netPYOut) {
+        address SY = IPYieldToken(YT).SY();
+        _mintSyFromToken(YT, SY, 1, input);
+        netPYOut = IPYieldToken(YT).mintPY(msg.sender, msg.sender);
+    }
+
+    function _seed(
+        address receiver,
+        address market,
+        MarketTokens memory tokens,
+        uint256 netSyIn,
+        uint256 netPtIn
+    ) internal returns (uint256 /*netLpOut*/, uint256 /*netYtOut*/, uint256 /*netSyMintPy*/) {
+        uint256 netSyMintPy = _calcSyToMintPYSeed(market, tokens, netSyIn, netPtIn);
+
+        // transfer SY to mint PY
+        _transferOut(address(tokens.SY), address(tokens.YT), netSyMintPy);
+        uint256 netPYMinted = tokens.YT.mintPY(market, receiver);
+
+        // the rest of SY goes to market
+        uint256 netSyAddLiquidity = netSyIn - netSyMintPy;
+        _transferOut(address(tokens.SY), market, netSyAddLiquidity);
+        _transferOut(address(tokens.PT), market, netPtIn);
+
+        (uint256 netLpOut, , ) = IPMarket(market).mint(receiver, netSyAddLiquidity, netPYMinted + netPtIn);
+        return (netLpOut, netPYMinted, netSyMintPy);
+    }
+
+    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.neg().Uint();
+            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;
+        MarketState memory localState;
+
+        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;
+            }
+
+            _makeACopyTo(state, localState);
+            // 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 = guess;
+            }
+        }
+        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;
+        MarketState memory localState;
+
+        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;
+            }
+
+            _makeACopyTo(state, localState);
+
+            // 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 = guess;
+            }
+        }
+        revert("_calcAmountPtToSell: failed");
+    }
+
+    function _calcSyToMintPYSeed(
+        address market,
+        MarketTokens memory tokens,
+        uint256 netSyIn,
+        uint256 netPtIn
+    ) internal returns (uint256 /* netSyMintPy */) {
+        uint256 netSyMintPy = netSyIn;
+        if (netPtIn > 0) {
+            (, , uint256 netSyDual, uint256 netPtDual) = _readMarket(market).addLiquidity(
+                netSyIn,
+                netPtIn,
+                block.timestamp
+            );
+            if (netPtDual < netPtIn) {
+                revert("MS: Bought too much PT");
+            }
+            netSyMintPy -= netSyDual;
+        }
+
+        MarketState memory state = _readMarket(market);
+        PYIndex pyIndex = tokens.YT.newIndex();
+        netSyMintPy =
+            (netSyMintPy * state.totalPt.Uint()) /
+            (state.totalPt.Uint() + pyIndex.syToAsset(state.totalSy.Uint()));
+
+        return netSyMintPy;
+    }
+
+    function _getPYIndex(address market) internal returns (PYIndex) {
+        (, , IPYieldToken YT) = IPMarket(market).readTokens();
+        return PYIndex.wrap(YT.pyIndexCurrent());
+    }
+
+    function _makeACopyTo(MarketState memory state, MarketState memory copiedState) internal pure {
+        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/Multicall2.sol

@@ -11,6 +11,7 @@ contract Multicall2 {
         address target;
         bytes callData;
     }
+
     struct Result {
         bool success;
         bytes returnData;
@@ -26,9 +27,10 @@ contract Multicall2 {
         }
     }
 
-    function blockAndAggregate(
-        Call[] memory calls
-    ) public returns (uint256 blockNumber, bytes32 blockHash, Result[] memory returnData) {
+    function blockAndAggregate(Call[] memory calls)
+        public
+        returns (uint256 blockNumber, bytes32 blockHash, Result[] memory returnData)
+    {
         (blockNumber, blockHash, returnData) = tryBlockAndAggregate(true, calls);
     }
 
@@ -77,10 +79,10 @@ contract Multicall2 {
         }
     }
 
-    function tryBlockAndAggregate(
-        bool requireSuccess,
-        Call[] memory calls
-    ) public returns (uint256 blockNumber, bytes32 blockHash, Result[] memory returnData) {
+    function tryBlockAndAggregate(bool requireSuccess, Call[] memory calls)
+        public
+        returns (uint256 blockNumber, bytes32 blockHash, Result[] memory returnData)
+    {
         blockNumber = block.number;
         blockHash = blockhash(block.number);
         returnData = tryAggregate(requireSuccess, calls);

package/contracts/offchain-helpers/PendleExchangeRateOracle.sol

@@ -1,10 +1,10 @@
 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8.17;
 
-import "@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol";
 import "../core/libraries/BoringOwnableUpgradeableV2.sol";
 import "../core/libraries/math/PMath.sol";
 import "../interfaces/IPExchangeRateOracle.sol";
+import "@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol";
 
 contract PendleExchangeRateOracle is BoringOwnableUpgradeableV2, IPExchangeRateOracle {
     using PMath for uint256;
@@ -45,10 +45,7 @@ contract PendleExchangeRateOracle is BoringOwnableUpgradeableV2, IPExchangeRateO
 
     function setExchangeRate(uint128 rate, uint64 dataBlock, uint32 dataTimestamp) external onlyOwner {
         ExchangeRateData memory newData = ExchangeRateData({
-            rate: rate,
-            dataBlock: dataBlock,
-            dataTimestamp: dataTimestamp,
-            updatedAt: uint32(block.timestamp)
+            rate: rate, dataBlock: dataBlock, dataTimestamp: dataTimestamp, updatedAt: uint32(block.timestamp)
         });
         _setExchangeRate(newData);
     }
@@ -75,9 +72,8 @@ contract PendleExchangeRateOracle is BoringOwnableUpgradeableV2, IPExchangeRateO
 
     function _validateMetadata(ExchangeRateData memory oldData, ExchangeRateData memory newData) internal pure {
         if (
-            oldData.dataBlock >= newData.dataBlock ||
-            oldData.dataTimestamp >= newData.dataTimestamp ||
-            oldData.updatedAt + MIN_UPDATE_TIME_GAP >= newData.updatedAt
+            oldData.dataBlock >= newData.dataBlock || oldData.dataTimestamp >= newData.dataTimestamp
+                || oldData.updatedAt + MIN_UPDATE_TIME_GAP >= newData.updatedAt
         ) {
             revert InvalidMetadata(newData);
         }

package/contracts/offchain-helpers/PendleFeeSetter.sol

@@ -0,0 +1,149 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.0;
+
+import {IPGovernanceProxy} from "../interfaces/IPGovernanceProxy.sol";
+import {IPLimitRouter} from "../interfaces/IPLimitRouter.sol";
+import {IPMarket, MarketState} from "../interfaces/IPMarket.sol";
+import {IPMarketFactory} from "../interfaces/IPMarketFactory.sol";
+import {IPYieldToken} from "../interfaces/IPYieldToken.sol";
+
+import {BoringOwnableUpgradeableV2} from "../core/libraries/BoringOwnableUpgradeableV2.sol";
+import {Errors} from "../core/libraries/Errors.sol";
+import {LogExpMath} from "../core/libraries/math/LogExpMath.sol";
+import {PMath} from "../core/libraries/math/PMath.sol";
+
+contract PendleFeeSetter is BoringOwnableUpgradeableV2 {
+    using PMath for uint256;
+    using PMath for int256;
+    using LogExpMath for int256;
+
+    event FeeFactorSet(uint128 impliedRateToFeeFactor, uint128 routerLnFeeToLimitLnFeeFactor);
+    event SetterSet(address indexed setter);
+
+    uint256 internal constant LIMIT_MAX_LN_FEE_RATE_ROOT = 48_790_164_169_432_003; // ln(1.05)
+
+    address public immutable router;
+    IPLimitRouter public immutable limitRouter;
+    IPGovernanceProxy public immutable govProxy;
+
+    uint128 public impliedRateToFeeFactor;
+    uint128 public routerLnFeeToLimitLnFeeFactor;
+    address public setter;
+
+    modifier onlyOwnerOrSetter() {
+        require(msg.sender == setter || msg.sender == owner, "not setter or owner");
+        _;
+    }
+
+    constructor(address _router, address _limitRouter, address _govProxy) {
+        _disableInitializers();
+        router = _router;
+        limitRouter = IPLimitRouter(_limitRouter);
+        govProxy = IPGovernanceProxy(_govProxy);
+    }
+
+    function initialize(address _owner, uint128 _impliedRateToFeeFactor, uint128 _routerLnFeeToLimitLnFeeFactor)
+        external
+        initializer
+    {
+        __BoringOwnableV2_init(_owner);
+        _setFeeFactors(_impliedRateToFeeFactor, _routerLnFeeToLimitLnFeeFactor);
+    }
+
+    function setFees(address[] memory markets) external onlyOwnerOrSetter {
+        uint256 n = markets.length;
+
+        IPGovernanceProxy.Call[] memory calls = new IPGovernanceProxy.Call[](n + 1);
+
+        address[] memory YTs = new address[](n);
+        uint256[] memory limitLnFeeRateRoots = new uint256[](n);
+
+        uint256 _impliedRateToFeeFactor = impliedRateToFeeFactor;
+        uint256 _routerLnFeeToLimitLnFeeFactor = routerLnFeeToLimitLnFeeFactor;
+        for (uint256 i = 0; i < n; ++i) {
+            (,, IPYieldToken yt) = IPMarket(markets[i]).readTokens();
+            (uint256 routerLnFeeRateRoot, uint256 limitLnFeeRateRoot) =
+                _calcFee(_impliedRateToFeeFactor, _routerLnFeeToLimitLnFeeFactor, markets[i]);
+
+            YTs[i] = address(yt);
+            limitLnFeeRateRoots[i] = limitLnFeeRateRoot;
+
+            calls[i].target = IPMarket(markets[i]).factory();
+            calls[i].callData =
+                abi.encodeCall(IPMarketFactory.setOverriddenFee, (router, markets[i], routerLnFeeRateRoot.Uint80()));
+        }
+
+        calls[n].target = address(limitRouter);
+        calls[n].callData = abi.encodeCall(
+            IPLimitRouter.setLnFeeRateRoots, (YTs, limitLnFeeRateRoots, /* allowZeroFees */ false)
+        );
+
+        govProxy.aggregateWithScopedAccess(calls);
+    }
+
+    function _calcFee(uint256 _impliedRateToFeeFactor, uint256 _routerLnFeeToLimitLnFeeFactor, address market)
+        internal
+        view
+        returns (uint256 routerLnFeeRateRoot, uint256 limitLnFeeRateRoot)
+    {
+        uint256 marketLnFee = IPMarket(market).getNonOverrideLnFeeRateRoot();
+        MarketState memory state = IPMarket(market).readState(router);
+        uint256 impliedRate = state.lastLnImpliedRate.Int().exp().Uint();
+
+        uint256 newFee = (impliedRate - PMath.ONE).mulDown(_impliedRateToFeeFactor) + PMath.ONE;
+        uint256 newLnFeeRateRoot = newFee.Int().ln().Uint();
+
+        routerLnFeeRateRoot = marketLnFee.min(newLnFeeRateRoot);
+        limitLnFeeRateRoot = LIMIT_MAX_LN_FEE_RATE_ROOT.min(routerLnFeeRateRoot.mulDown(_routerLnFeeToLimitLnFeeFactor));
+
+        // Fix up `routerLnFeeRateRoot` for this case:
+        // https://github.com/pendle-finance/pendle-core-v2/blob/6169376d0a8c12030307e3d64d02e84b07ffe4f9/contracts/core/Market/v3/PendleMarketFactoryV3.sol#L131-L135
+        if (routerLnFeeRateRoot == marketLnFee) routerLnFeeRateRoot = 0;
+    }
+
+    function readFeesAndImpliedRate(address[] memory markets)
+        external
+        view
+        returns (
+            uint256[] memory routerLnFeeRateRoots,
+            uint256[] memory limitLnFeeRateRoots,
+            uint256[] memory lnImpliedRates
+        )
+    {
+        uint256 n = markets.length;
+        routerLnFeeRateRoots = new uint256[](n);
+        limitLnFeeRateRoots = new uint256[](n);
+        lnImpliedRates = new uint256[](n);
+
+        for (uint256 i = 0; i < n; ++i) {
+            MarketState memory state = IPMarket(markets[i]).readState(router);
+            routerLnFeeRateRoots[i] = state.lnFeeRateRoot;
+            lnImpliedRates[i] = state.lastLnImpliedRate;
+
+            (,, IPYieldToken yt) = IPMarket(markets[i]).readTokens();
+            try limitRouter.getLnFeeRateRoot(address(yt)) returns (uint256 _fee) {
+                limitLnFeeRateRoots[i] = _fee;
+            } catch {
+                limitLnFeeRateRoots[i] = 0;
+            }
+        }
+    }
+
+    // ============================== Admin functions ==============================
+
+    function setFeeFactors(uint128 _impliedRateToFeeFactor, uint128 _routerLnFeeToLimitLnFeeFactor) external onlyOwner {
+        _setFeeFactors(_impliedRateToFeeFactor, _routerLnFeeToLimitLnFeeFactor);
+    }
+
+    function _setFeeFactors(uint128 _impliedRateToFeeFactor, uint128 _routerLnFeeToLimitLnFeeFactor) internal {
+        impliedRateToFeeFactor = _impliedRateToFeeFactor;
+        routerLnFeeToLimitLnFeeFactor = _routerLnFeeToLimitLnFeeFactor;
+
+        emit FeeFactorSet(_impliedRateToFeeFactor, _routerLnFeeToLimitLnFeeFactor);
+    }
+
+    function setSetter(address _setter) external onlyOwner {
+        setter = _setter;
+        emit SetterSet(setter);
+    }
+}