@pendle/core-v2 0.9.4-beta → 0.10.2-testnet

package/contracts/core/LiquidityMining/VotingController/VotingControllerStorageUpg.sol

@@ -17,6 +17,7 @@ abstract contract VotingControllerStorageUpg {
     using VeBalanceLib for LockedPosition;
     using EnumerableSet for EnumerableSet.AddressSet;
     using Checkpoints for Checkpoints.History;
+    using WeekMath for uint128;
 
     struct PoolData {
         uint64 chainId;
@@ -57,16 +58,16 @@ abstract contract VotingControllerStorageUpg {
     EnumerableSet.AddressSet internal allRemovedPools;
 
     // [chainId] => [pool]
-    mapping(uint64 => EnumerableSet.AddressSet) internal chainPools;
+    mapping(uint64 => EnumerableSet.AddressSet) internal activeChainPools;
 
     // [poolAddress] -> PoolData
-    mapping(address => PoolData) public poolData;
+    mapping(address => PoolData) internal poolData;
 
     // [wTime] => WeekData
-    mapping(uint128 => WeekData) public weekData;
+    mapping(uint128 => WeekData) internal weekData;
 
     // user voting data
-    mapping(address => UserData) public userData;
+    mapping(address => UserData) internal userData;
 
     // [user][pool] => checkpoint
     mapping(address => mapping(address => Checkpoints.History)) internal userPoolHistory;
@@ -82,8 +83,64 @@ abstract contract VotingControllerStorageUpg {
                             VIEW FUNCTIONS
     //////////////////////////////////////////////////////////////*/
 
+    function getPoolData(address pool, uint128[] calldata wTimes)
+        public
+        view
+        returns (
+            uint64 chainId,
+            uint128 lastSlopeChangeAppliedAt,
+            VeBalance memory totalVote,
+            uint128[] memory slopeChanges
+        )
+    {
+        PoolData storage data = poolData[pool];
+        (chainId, lastSlopeChangeAppliedAt, totalVote) = (
+            data.chainId,
+            data.lastSlopeChangeAppliedAt,
+            data.totalVote
+        );
+
+        slopeChanges = new uint128[](wTimes.length);
+        for (uint256 i = 0; i < wTimes.length; ++i) {
+            require(wTimes[i].isValidWTime(), "invalid wTimes");
+            slopeChanges[i] = data.slopeChanges[wTimes[i]];
+        }
+    }
+
+    function getUserData(address user, address[] calldata pools)
+        public
+        view
+        returns (uint64 totalVotedWeight, UserPoolData[] memory voteForPools)
+    {
+        UserData storage data = userData[user];
+
+        totalVotedWeight = data.totalVotedWeight;
+
+        voteForPools = new UserPoolData[](pools.length);
+        for (uint256 i = 0; i < pools.length; ++i) voteForPools[i] = data.voteForPools[pools[i]];
+    }
+
+    function getWeekData(uint128 wTime, address[] calldata pools)
+        public
+        view
+        returns (
+            bool isEpochFinalized,
+            uint128 totalVotes,
+            uint128[] memory poolVotes
+        )
+    {
+        require(wTime.isValidWTime(), "invalid wTimes");
+
+        WeekData storage data = weekData[wTime];
+
+        (isEpochFinalized, totalVotes) = (data.isEpochFinalized, data.totalVotes);
+
+        poolVotes = new uint128[](pools.length);
+        for (uint256 i = 0; i < pools.length; ++i) poolVotes[i] = data.poolVotes[pools[i]];
+    }
+
     /// @dev trivial view function
-    function getAllAcitvePools() external view returns (address[] memory) {
+    function getAllActivePools() external view returns (address[] memory) {
         return allActivePools.values();
     }
 
@@ -93,14 +150,15 @@ abstract contract VotingControllerStorageUpg {
         view
         returns (uint256 lengthOfRemovedPools, address[] memory arr)
     {
-        arr = new address[](end - start + 1);
-        for (uint256 i = start; i <= end; i++) arr[i] = allRemovedPools.at(i);
         lengthOfRemovedPools = allRemovedPools.length();
+        require(end < lengthOfRemovedPools, "end is out of bounds");
+        arr = new address[](end - start + 1);
+        for (uint256 i = start; i <= end; ++i) arr[i - start] = allRemovedPools.at(i);
     }
 
     /// @dev trivial view function
-    function getChainPools(uint64 chainId) external view returns (address[] memory) {
-        return chainPools[chainId].values();
+    function getActiveChainPools(uint64 chainId) external view returns (address[] memory) {
+        return activeChainPools[chainId].values();
     }
 
     /// @dev trivial view function
@@ -130,11 +188,11 @@ abstract contract VotingControllerStorageUpg {
 
     /**
     * @dev expected behavior:
-        - add to allActivePools, chainPools
+        - add to allActivePools, activeChainPools
         - set params in poolData
      */
     function _addPool(uint64 chainId, address pool) internal {
-        require(chainPools[chainId].add(pool), "IE");
+        require(activeChainPools[chainId].add(pool), "IE");
         require(allActivePools.add(pool), "IE");
 
         poolData[pool].chainId = chainId;
@@ -143,13 +201,13 @@ abstract contract VotingControllerStorageUpg {
 
     /**
     * @dev expected behavior:
-        - remove from allActivePool, chainPools
+        - remove from allActivePool, activeChainPools
         - add to allRemovedPools
         - clear all params in poolData
      */
     function _removePool(address pool) internal {
         uint64 chainId = poolData[pool].chainId;
-        require(chainPools[chainId].remove(pool), "IE");
+        require(activeChainPools[chainId].remove(pool), "IE");
         require(allActivePools.remove(pool), "IE");
         require(allRemovedPools.add(pool), "IE");
 

package/contracts/core/LiquidityMining/VotingEscrow/VotingEscrowPendleMainchain.sol

@@ -34,12 +34,14 @@ contract VotingEscrowPendleMainchain is IPVotingEscrow, VotingEscrowTokenBase, C
     // to ask for their vePendle balance at any wTime
     mapping(address => Checkpoints.History) internal userHistory;
 
-    constructor(IERC20 _pendle, address _governanceManager)
-        CelerSenderUpg(_governanceManager) // only sets immutable variables
-    {
+    constructor(IERC20 _pendle) {
         pendle = _pendle;
     }
 
+    function initialize() external initializer {
+        __BoringOwnable_init();
+    }
+
     /// @notice basically a proxy function to call increaseLockPosition & broadcastUserPosition at the same time
     function increaseLockPositionAndBroadcast(
         uint128 additionalAmountToLock,
@@ -71,6 +73,7 @@ contract VotingEscrowPendleMainchain is IPVotingEscrow, VotingEscrowTokenBase, C
         );
 
         require(newExpiry <= block.timestamp + MAX_LOCK_TIME, "max lock time exceeded");
+        require(newExpiry >= block.timestamp + MIN_LOCK_TIME, "insufficient lock time");
         require(positionData[user].expiry <= newExpiry, "new expiry must be after current expiry");
 
         uint128 newTotalAmountLocked = additionalAmountToLock + positionData[user].amount;
@@ -227,7 +230,7 @@ contract VotingEscrowPendleMainchain is IPVotingEscrow, VotingEscrowTokenBase, C
     }
 
     /// @notice broadcast position to all chains in chainIds
-    function _broadcastPosition(address user, uint256[] calldata chainIds) public payable {
+    function _broadcastPosition(address user, uint256[] calldata chainIds) internal {
         require(chainIds.length != 0, "empty chainIds");
 
         (VeBalance memory supply, uint128 wTime) = _applySlopeChange();

package/contracts/core/LiquidityMining/VotingEscrow/VotingEscrowPendleSidechain.sol

@@ -17,7 +17,11 @@ contract VotingEscrowPendleSidechain is VotingEscrowTokenBase, CelerReceiverUpg
 
     event SetNewUserPosition(LockedPosition position);
 
-    constructor(address _governanceManager) CelerReceiverUpg(_governanceManager) {}
+    constructor() {}
+
+    function initialize() external initializer {
+        __BoringOwnable_init();
+    }
 
     function totalSupplyCurrent() public view virtual override returns (uint128) {
         return totalSupplyStored();
@@ -27,7 +31,7 @@ contract VotingEscrowPendleSidechain is VotingEscrowTokenBase, CelerReceiverUpg
      * @dev The mechanism of delegating is for governance to support protocol to build on top
      * This way, it is more gas efficient and does not affect the crosschain messaging cost
      */
-    function setDelegatorFor(address receiver, address delegator) external onlyGovernance {
+    function setDelegatorFor(address receiver, address delegator) external onlyOwner {
         delegatorOf[receiver] = delegator;
         emit SetNewDelegator(delegator, receiver);
     }

package/contracts/core/LiquidityMining/VotingEscrow/VotingEscrowTokenBase.sol

@@ -10,7 +10,7 @@ import "../../../libraries/helpers/MiniHelpers.sol";
  * @dev this contract is an abstract for its mainchain and sidechain variant
  * PRINCIPLE:
  *   - All functions implemented in this contract should be either view or pure
- *     to ensure that no writing logic is inheritted by sidechain version
+ *     to ensure that no writing logic is inherited by sidechain version
  *   - Mainchain version will handle the logic which are:
  *        + Deposit, withdraw, increase lock, increase amount
  *        + Mainchain logic will be ensured to have _totalSupply = linear sum of
@@ -25,6 +25,7 @@ abstract contract VotingEscrowTokenBase is IPVeToken {
 
     uint128 public constant WEEK = 1 weeks;
     uint128 public constant MAX_LOCK_TIME = 104 weeks;
+    uint128 public constant MIN_LOCK_TIME = 1 weeks;
 
     VeBalance internal _totalSupply;
     uint128 public lastSlopeChangeAppliedAt;
@@ -49,7 +50,7 @@ abstract contract VotingEscrowTokenBase is IPVeToken {
         return MiniHelpers.isCurrentlyExpired(positionData[user].expiry);
     }
 
-    function totalSupplyAndBlanaceCurrent(address user) external returns (uint128, uint128) {
-        return (balanceOf(user), totalSupplyCurrent());
+    function totalSupplyAndBalanceCurrent(address user) external returns (uint128, uint128) {
+        return (totalSupplyCurrent(), balanceOf(user));
     }
 }

package/contracts/core/Market/PendleMarket.sol

@@ -8,6 +8,7 @@ import "../../interfaces/IPMarket.sol";
 import "../../interfaces/IPMarketFactory.sol";
 import "../../interfaces/IPMarketSwapCallback.sol";
 
+import "../../libraries/OracleLib.sol";
 import "../../libraries/math/LogExpMath.sol";
 import "../../libraries/math/Math.sol";
 import "../../libraries/helpers/MiniHelpers.sol";
@@ -16,8 +17,8 @@ import "../LiquidityMining/PendleGauge.sol";
 import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
 
 /**
-Invariances to maintain:
-- Internal balances totalPt & totalScy not interferred by people transferring tokens in directly
+Invariance to maintain:
+- Internal balances totalPt & totalScy not interfered by people transferring tokens in directly
 - address(0) & address(this) should never have any rewards & activeBalance accounting done. This is
     guaranteed by address(0) & address(this) check in each updateForTwo function
 */
@@ -27,15 +28,17 @@ contract PendleMarket is PendleERC20, PendleGauge, IPMarket {
     using MarketMathCore for MarketState;
     using SafeERC20 for IERC20;
     using PYIndexLib for IPYieldToken;
+    using OracleLib for OracleLib.Observation[65535];
 
     struct MarketStorage {
         int128 totalPt;
         int128 totalScy;
         // 1 SLOT = 256 bits
         uint96 lastLnImpliedRate;
-        uint96 oracleRate;
-        uint32 lastTradeTime;
-        // 1 SLOT = 224 bits
+        uint16 observationIndex;
+        uint16 observationCardinality;
+        uint16 observationCardinalityNext;
+        // 1 SLOT = 144 bits
     }
 
     string private constant NAME = "Pendle Market";
@@ -52,6 +55,8 @@ contract PendleMarket is PendleERC20, PendleGauge, IPMarket {
 
     MarketStorage public _storage;
 
+    OracleLib.Observation[65535] public observations;
+
     modifier notExpired() {
         require(!isExpired(), "market expired");
         _;
@@ -71,6 +76,9 @@ contract PendleMarket is PendleERC20, PendleGauge, IPMarket {
         SCY = ISuperComposableYield(PT.SCY());
         YT = IPYieldToken(PT.YT());
 
+        (_storage.observationCardinality, _storage.observationCardinalityNext) = observations
+            .initialize(uint32(block.timestamp));
+
         require(_scalarRoot > 0, "scalarRoot must be positive");
         scalarRoot = _scalarRoot;
         initialAnchor = _initialAnchor;
@@ -82,13 +90,8 @@ contract PendleMarket is PendleERC20, PendleGauge, IPMarket {
      * @notice PendleMarket allows users to provide in PT & SCY in exchange for LPs, which
      * will grant LP holders more exchange fee over time
      */
-    function mint(address receiver)
-        external
-        nonReentrant
-        notExpired
-        returns (uint256 lpToAccount)
-    {
-        MarketState memory market = readState(true);
+    function mint(address receiver) external nonReentrant notExpired returns (uint256 netLpOut) {
+        MarketState memory market = readState();
         PYIndex index = YT.newIndex();
 
         uint256 scyDesired = IERC20(SCY).balanceOf(address(this)) - market.totalScy.Uint();
@@ -98,7 +101,7 @@ contract PendleMarket is PendleERC20, PendleGauge, IPMarket {
         uint256 scyUsed;
         uint256 ptUsed;
 
-        (lpToReserve, lpToAccount, scyUsed, ptUsed) = market.addLiquidity(
+        (lpToReserve, netLpOut, scyUsed, ptUsed) = market.addLiquidity(
             index,
             scyDesired,
             ptDesired,
@@ -111,11 +114,11 @@ contract PendleMarket is PendleERC20, PendleGauge, IPMarket {
             _mint(address(1), lpToReserve);
         }
 
-        _mint(receiver, lpToAccount);
+        _mint(receiver, netLpOut);
 
         _writeState(market);
 
-        emit Mint(receiver, lpToAccount, scyUsed, ptUsed);
+        emit Mint(receiver, netLpOut, scyUsed, ptUsed);
     }
 
     /**
@@ -125,21 +128,21 @@ contract PendleMarket is PendleERC20, PendleGauge, IPMarket {
     function burn(address receiverScy, address receiverPt)
         external
         nonReentrant
-        returns (uint256 scyToAccount, uint256 ptToAccount)
+        returns (uint256 netScyOut, uint256 netPtOut)
     {
-        MarketState memory market = readState(true);
+        MarketState memory market = readState();
 
         uint256 lpToRemove = balanceOf(address(this));
         _burn(address(this), lpToRemove);
 
-        (scyToAccount, ptToAccount) = market.removeLiquidity(lpToRemove);
+        (netScyOut, netPtOut) = market.removeLiquidity(lpToRemove);
 
-        IERC20(SCY).safeTransfer(receiverScy, scyToAccount);
-        IERC20(PT).safeTransfer(receiverPt, ptToAccount);
+        if (receiverScy != address(this)) IERC20(SCY).safeTransfer(receiverScy, netScyOut);
+        if (receiverPt != address(this)) IERC20(PT).safeTransfer(receiverPt, netPtOut);
 
         _writeState(market);
 
-        emit Burn(receiverScy, receiverPt, lpToRemove, scyToAccount, ptToAccount);
+        emit Burn(receiverScy, receiverPt, lpToRemove, netScyOut, netPtOut);
     }
 
     /**
@@ -157,7 +160,7 @@ contract PendleMarket is PendleERC20, PendleGauge, IPMarket {
         uint256 exactPtIn,
         bytes calldata data
     ) external nonReentrant notExpired returns (uint256 netScyOut, uint256 netScyToReserve) {
-        MarketState memory market = readState(true);
+        MarketState memory market = readState();
 
         (netScyOut, netScyToReserve) = market.swapExactPtForScy(
             YT.newIndex(),
@@ -165,7 +168,7 @@ contract PendleMarket is PendleERC20, PendleGauge, IPMarket {
             block.timestamp
         );
 
-        IERC20(SCY).safeTransfer(receiver, netScyOut);
+        if (receiver != address(this)) IERC20(SCY).safeTransfer(receiver, netScyOut);
         IERC20(SCY).safeTransfer(market.treasury, netScyToReserve);
 
         _writeState(market);
@@ -194,7 +197,7 @@ contract PendleMarket is PendleERC20, PendleGauge, IPMarket {
         uint256 exactPtOut,
         bytes calldata data
     ) external nonReentrant notExpired returns (uint256 netScyIn, uint256 netScyToReserve) {
-        MarketState memory market = readState(true);
+        MarketState memory market = readState();
 
         (netScyIn, netScyToReserve) = market.swapScyForExactPt(
             YT.newIndex(),
@@ -202,7 +205,7 @@ contract PendleMarket is PendleERC20, PendleGauge, IPMarket {
             block.timestamp
         );
 
-        IERC20(PT).safeTransfer(receiver, exactPtOut);
+        if (receiver != address(this)) IERC20(PT).safeTransfer(receiver, exactPtOut);
         IERC20(SCY).safeTransfer(market.treasury, netScyToReserve);
 
         _writeState(market);
@@ -222,7 +225,7 @@ contract PendleMarket is PendleERC20, PendleGauge, IPMarket {
 
     /// @notice force balances to match reserves
     function skim() external nonReentrant {
-        MarketState memory market = readState(true);
+        MarketState memory market = readState();
         uint256 excessPt = IERC20(PT).balanceOf(address(this)) - market.totalPt.Uint();
         uint256 excessScy = IERC20(SCY).balanceOf(address(this)) - market.totalScy.Uint();
         IERC20(PT).safeTransfer(market.treasury, excessPt);
@@ -237,64 +240,97 @@ contract PendleMarket is PendleERC20, PendleGauge, IPMarket {
         return _getRewardTokens();
     }
 
-    function readTokens()
-        external
+    /*///////////////////////////////////////////////////////////////
+                                ORACLE
+    //////////////////////////////////////////////////////////////*/
+
+    function observe(uint32[] memory secondsAgos)
+        public
         view
-        returns (
-            ISuperComposableYield _SCY,
-            IPPrincipalToken _PT,
-            IPYieldToken _YT
-        )
+        returns (uint216[] memory lnImpliedRateCumulative)
     {
-        _SCY = SCY;
-        _PT = PT;
-        _YT = YT;
+        return
+            observations.observe(
+                uint32(block.timestamp),
+                secondsAgos,
+                _storage.lastLnImpliedRate,
+                _storage.observationIndex,
+                _storage.observationCardinality
+            );
     }
 
-    function isExpired() public view returns (bool) {
-        return MiniHelpers.isCurrentlyExpired(expiry);
+    function increaseObservationsCardinalityNext(uint16 cardinalityNext) external nonReentrant {
+        uint16 cardinalityNextOld = _storage.observationCardinalityNext;
+        uint16 cardinalityNextNew = observations.grow(cardinalityNextOld, cardinalityNext);
+        if (cardinalityNextOld != cardinalityNextNew) {
+            _storage.observationCardinalityNext = cardinalityNextNew;
+            emit IncreaseObservationCardinalityNext(cardinalityNextOld, cardinalityNextNew);
+        }
     }
 
+    /*///////////////////////////////////////////////////////////////
+                                READ/WRITE STATES
+    //////////////////////////////////////////////////////////////*/
+
     /**
      * @notice read the state of the market from storage into memory for gas-efficient manipulation
-     * @param updateRateOracle if set to true, the oracleRate will be updated, which will take ~6k of gas. If router wants
-        to do external calculations, normally this can be set to false
      */
-    function readState(bool updateRateOracle) public view returns (MarketState memory market) {
+    function readState() public view returns (MarketState memory market) {
         market.totalPt = _storage.totalPt;
         market.totalScy = _storage.totalScy;
         market.totalLp = totalSupply().Int();
-        market.oracleRate = _storage.oracleRate;
 
-        (
-            market.treasury,
-            market.lnFeeRateRoot,
-            market.rateOracleTimeWindow,
-            market.reserveFeePercent
-        ) = IPMarketFactory(factory).marketConfig();
+        (market.treasury, market.lnFeeRateRoot, market.reserveFeePercent) = IPMarketFactory(
+            factory
+        ).marketConfig();
 
         market.scalarRoot = scalarRoot;
         market.expiry = expiry;
 
         market.lastLnImpliedRate = _storage.lastLnImpliedRate;
-        market.lastTradeTime = _storage.lastTradeTime;
-
-        if (updateRateOracle) {
-            // must happen after lastLnImpliedRate & lastTradeTime is filled
-            market.oracleRate = market.getNewRateOracle(block.timestamp);
-        }
     }
 
     /// @notice write back the state of the market from memory to storage
     function _writeState(MarketState memory market) internal {
+        uint96 lastLnImpliedRate96 = market.lastLnImpliedRate.Uint96();
+
         _storage.totalPt = market.totalPt.Int128();
         _storage.totalScy = market.totalScy.Int128();
-        _storage.lastLnImpliedRate = market.lastLnImpliedRate.Uint96();
-        _storage.oracleRate = market.oracleRate.Uint96();
-        _storage.lastTradeTime = market.lastTradeTime.Uint32();
+        _storage.lastLnImpliedRate = lastLnImpliedRate96;
+
+        (_storage.observationIndex, _storage.observationCardinality) = observations.write(
+            _storage.observationIndex,
+            uint32(block.timestamp),
+            lastLnImpliedRate96,
+            _storage.observationCardinality,
+            _storage.observationCardinalityNext
+        );
+
         emit UpdateImpliedRate(block.timestamp, market.lastLnImpliedRate);
     }
 
+    /*///////////////////////////////////////////////////////////////
+                            TRIVIAL FUNCTIONS
+    //////////////////////////////////////////////////////////////*/
+
+    function readTokens()
+        external
+        view
+        returns (
+            ISuperComposableYield _SCY,
+            IPPrincipalToken _PT,
+            IPYieldToken _YT
+        )
+    {
+        _SCY = SCY;
+        _PT = PT;
+        _YT = YT;
+    }
+
+    function isExpired() public view returns (bool) {
+        return MiniHelpers.isCurrentlyExpired(expiry);
+    }
+
     /*///////////////////////////////////////////////////////////////
                     PENDLE GAUGE - RELATED
     //////////////////////////////////////////////////////////////*/

package/contracts/core/Market/PendleMarketFactory.sol

@@ -1,28 +1,26 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity 0.8.15;
 import "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
-import "@openzeppelin/contracts/proxy/utils/Initializable.sol";
 
 import "../../interfaces/IPMarket.sol";
 import "../../interfaces/IPYieldContractFactory.sol";
 import "../../interfaces/IPMarketFactory.sol";
 
 import "../../libraries/helpers/SSTORE2Deployer.sol";
-import "../../periphery/PermissionsV2Upg.sol";
+import "../../periphery/BoringOwnableUpgradeable.sol";
 
 import "./PendleMarket.sol";
 import "../LiquidityMining/PendleGauge.sol";
 
-contract PendleMarketFactory is PermissionsV2Upg, Initializable, IPMarketFactory {
+contract PendleMarketFactory is BoringOwnableUpgradeable, IPMarketFactory {
     using EnumerableSet for EnumerableSet.AddressSet;
 
     struct MarketConfig {
         address treasury;
         uint96 lnFeeRateRoot;
         // 1 SLOT = 256 bits
-        uint32 rateOracleTimeWindow;
         uint8 reserveFeePercent;
-        // 1 SLOT = 40 bits
+        // 1 SLOT = 8 bits
     }
 
     uint256 private constant MIN_RATE_ORACLE_TIME_WINDOW = 300 seconds;
@@ -41,28 +39,26 @@ contract PendleMarketFactory is PermissionsV2Upg, Initializable, IPMarketFactory
     MarketConfig public marketConfig;
 
     constructor(
-        address _governanceManager,
-        address _yieldContractFactory,
-        address _treasury,
-        uint96 _lnFeeRateRoot,
-        uint32 _rateOracleTimeWindow,
-        uint8 _reserveFeePercent
-    ) PermissionsV2Upg(_governanceManager) {
+        address _yieldContractFactory
+    ) {
         require(_yieldContractFactory != address(0), "zero address");
         yieldContractFactory = _yieldContractFactory;
         maxLnFeeRateRoot = uint256(LogExpMath.ln(int256((105 * Math.IONE) / 100))); // ln(1.05)
-
-        setTreasury(_treasury);
-        setlnFeeRateRoot(_lnFeeRateRoot);
-        setRateOracleTimeWindow(_rateOracleTimeWindow);
-        setReserveFeePercent(_reserveFeePercent);
     }
 
     function initialize(
+        address _treasury,
+        uint96 _lnFeeRateRoot,
+        uint8 _reserveFeePercent,
         address newVePendle,
         address newGaugeController,
         bytes memory _marketCreationCode
-    ) external onlyGovernance initializer {
+    ) external initializer {
+        __BoringOwnable_init();
+        setTreasury(_treasury);
+        setlnFeeRateRoot(_lnFeeRateRoot);
+        setReserveFeePercent(_reserveFeePercent);
+
         require(newVePendle != address(0) && newGaugeController != address(0), "zero address");
         vePendle = newVePendle;
         gaugeController = newGaugeController;
@@ -104,25 +100,19 @@ contract PendleMarketFactory is PermissionsV2Upg, Initializable, IPMarketFactory
         return marketConfig.treasury;
     }
 
-    function setTreasury(address newTreasury) public onlyGovernance {
+    function setTreasury(address newTreasury) public onlyOwner {
         require(newTreasury != address(0), "zero address");
         marketConfig.treasury = newTreasury;
         _emitNewMarketConfigEvent();
     }
 
-    function setlnFeeRateRoot(uint96 newlnFeeRateRoot) public onlyGovernance {
+    function setlnFeeRateRoot(uint96 newlnFeeRateRoot) public onlyOwner {
         require(newlnFeeRateRoot <= maxLnFeeRateRoot, "invalid fee rate root");
         marketConfig.lnFeeRateRoot = newlnFeeRateRoot;
         _emitNewMarketConfigEvent();
     }
 
-    function setRateOracleTimeWindow(uint32 newRateOracleTimeWindow) public onlyGovernance {
-        require(newRateOracleTimeWindow >= MIN_RATE_ORACLE_TIME_WINDOW, "invalid time window");
-        marketConfig.rateOracleTimeWindow = newRateOracleTimeWindow;
-        _emitNewMarketConfigEvent();
-    }
-
-    function setReserveFeePercent(uint8 newReserveFeePercent) public onlyGovernance {
+    function setReserveFeePercent(uint8 newReserveFeePercent) public onlyOwner {
         require(newReserveFeePercent <= 100, "invalid reserve fee percent");
         marketConfig.reserveFeePercent = newReserveFeePercent;
         _emitNewMarketConfigEvent();
@@ -130,11 +120,6 @@ contract PendleMarketFactory is PermissionsV2Upg, Initializable, IPMarketFactory
 
     function _emitNewMarketConfigEvent() internal {
         MarketConfig memory local = marketConfig;
-        emit NewMarketConfig(
-            local.treasury,
-            local.lnFeeRateRoot,
-            local.rateOracleTimeWindow,
-            local.reserveFeePercent
-        );
+        emit NewMarketConfig(local.treasury, local.lnFeeRateRoot, local.reserveFeePercent);
     }
 }