@pendle/core-v2 4.7.0 → 4.7.1

package/contracts/core/StandardizedYield/implementations/Mellow/PendleMellowVaultERC20SYUpg.sol

@@ -0,0 +1,119 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.0;
+
+import "../../SYBaseUpg.sol";
+import "../../StEthHelper.sol";
+import "../../../../interfaces/IPTokenWithSupplyCap.sol";
+import "../../../../interfaces/Mellow/IMellowVault.sol";
+import "../../../../interfaces/Mellow/IMellowVaultConfigurator.sol";
+import "../../../../interfaces/IPPriceFeed.sol";
+
+/// @dev This SY implementation intends to ignore native interest from Mellow Vault's underlying
+contract PendleMellowVaultERC20SYUpg is SYBaseUpg, IPTokenWithSupplyCap {
+    event SetPricingHelper(address newPricingHelper);
+
+    // solhint-disable immutable-vars-naming
+    address public immutable vault;
+    address public immutable configurator;
+    address public pricingHelper;
+
+    constructor(address _vault) SYBaseUpg(_vault) {
+        vault = _vault;
+        configurator = IMellowVault(_vault).configurator();
+        _disableInitializers();
+    }
+
+    function initialize(
+        string memory _name,
+        string memory _symbol,
+        address _pricingHelper
+    ) external virtual initializer {
+        __SYBaseUpg_init(_name, _symbol);
+        _setPricingHelper(_pricingHelper);
+    }
+
+    function _deposit(
+        address /*tokenIn*/,
+        uint256 amountDeposited
+    ) internal virtual override returns (uint256 amountSharesOut) {
+        return amountDeposited;
+    }
+
+    function _redeem(
+        address receiver,
+        address /*tokenOut*/,
+        uint256 amountSharesToRedeem
+    ) internal virtual override returns (uint256) {
+        _transferOut(vault, receiver, amountSharesToRedeem);
+        return amountSharesToRedeem;
+    }
+
+    function exchangeRate() public view virtual override returns (uint256 res) {
+        return PMath.ONE;
+    }
+
+    function _previewDeposit(
+        address /*tokenIn*/,
+        uint256 amountTokenToDeposit
+    ) internal view virtual override returns (uint256 /*amountSharesOut*/) {
+        return amountTokenToDeposit;
+    }
+
+    function _previewRedeem(
+        address /*tokenOut*/,
+        uint256 amountSharesToRedeem
+    ) internal view virtual override returns (uint256 /*amountTokenOut*/) {
+        return amountSharesToRedeem;
+    }
+
+    function getTokensIn() public view virtual override returns (address[] memory res) {
+        return ArrayLib.create(vault);
+    }
+
+    function getTokensOut() public view virtual override returns (address[] memory res) {
+        return ArrayLib.create(vault);
+    }
+
+    function isValidTokenIn(address token) public view virtual override returns (bool) {
+        return token == vault;
+    }
+
+    function isValidTokenOut(address token) public view virtual override returns (bool) {
+        return token == vault;
+    }
+
+    function assetInfo()
+        external
+        view
+        virtual
+        returns (AssetType assetType, address assetAddress, uint8 assetDecimals)
+    {
+        return (AssetType.TOKEN, vault, IERC20Metadata(vault).decimals());
+    }
+
+    function getAbsoluteSupplyCap() external view virtual returns (uint256) {
+        return IMellowVaultConfigurator(configurator).maximalTotalSupply();
+    }
+
+    function getAbsoluteTotalSupply() external view virtual returns (uint256) {
+        return IERC20(vault).totalSupply();
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                        OFF-CHAIN USAGE ONLY
+            (NO SECURITY RELATED && CAN BE LEFT UNAUDITED)
+    //////////////////////////////////////////////////////////////*/
+
+    function setPricingHelper(address _pricingHelper) external onlyOwner {
+        _setPricingHelper(_pricingHelper);
+    }
+
+    function _setPricingHelper(address _pricingHelper) internal {
+        pricingHelper = _pricingHelper;
+        emit SetPricingHelper(_pricingHelper);
+    }
+
+    function getPrice() external view returns (uint256) {
+        return IPPriceFeed(pricingHelper).getPrice();
+    }
+}

package/contracts/core/StandardizedYield/implementations/Mellow/PendleMellowVaultWstETHSY.sol

@@ -0,0 +1,102 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.0;
+
+import "./PendleMellowVaultERC20SYUpg.sol";
+
+/// @dev This SY implementation intends to ignore native interest from Mellow Vault's underlying
+contract PendleMellowVaultWstETHSYUpg is PendleMellowVaultERC20SYUpg, StEthHelper {
+    error MellowVaultHasInvalidAssets();
+    error SupplyCapExceeded(uint256 totalSupply, uint256 supplyCap);
+
+    // solhint-disable immutable-vars-naming
+    uint256 public immutable interfaceVersion;
+
+    constructor(address _vault, uint256 _interfaceVersion) PendleMellowVaultERC20SYUpg(_vault) {
+        if (_interfaceVersion > 1) {
+            revert("invalid interface version");
+        }
+        interfaceVersion = _interfaceVersion;
+    }
+
+    function initialize(
+        string memory _name,
+        string memory _symbol,
+        address _pricingHelper
+    ) external override initializer {
+        __SYBaseUpg_init(_name, _symbol);
+        _safeApproveInf(STETH, WSTETH);
+        _safeApproveInf(WSTETH, vault);
+        _setPricingHelper(_pricingHelper);
+    }
+
+    function _deposit(
+        address tokenIn,
+        uint256 amountDeposited
+    ) internal virtual override returns (uint256 amountSharesOut) {
+        if (tokenIn == vault) {
+            return amountDeposited;
+        }
+        if (tokenIn != WSTETH) {
+            (tokenIn, amountDeposited) = (WSTETH, _depositWstETH(tokenIn, amountDeposited));
+        }
+
+        if (interfaceVersion == 0) {
+            (, amountSharesOut) = IMellowVault(vault).deposit(
+                address(this),
+                ArrayLib.create(amountDeposited),
+                0,
+                type(uint256).max,
+                0
+            );
+        } else if (interfaceVersion == 1) {
+            (, amountSharesOut) = IMellowVault(vault).deposit(
+                address(this),
+                ArrayLib.create(amountDeposited),
+                0,
+                type(uint256).max
+            );
+        }
+    }
+
+    /// @dev Mellow uses math calculations under 2**96 base. Also they are taking into account oracle prices
+    /// even with one asset. So a discrepancy of 1e-6 in the result should be expected.
+    function _previewDeposit(
+        address tokenIn,
+        uint256 amountTokenToDeposit
+    ) internal view virtual override returns (uint256 amountSharesOut) {
+        if (tokenIn == vault) {
+            return amountTokenToDeposit;
+        }
+        if (tokenIn != WSTETH) {
+            (tokenIn, amountTokenToDeposit) = (WSTETH, _previewDepositWstETH(tokenIn, amountTokenToDeposit));
+        }
+        (uint256 tvl, uint256 supply) = _getMellowVaultTvl();
+        amountSharesOut = (amountTokenToDeposit * supply) / tvl;
+
+        uint256 supplyCap = IMellowVaultConfigurator(configurator).maximalTotalSupply();
+        uint256 newSupply = supply + amountSharesOut;
+        if (newSupply > supplyCap) {
+            revert SupplyCapExceeded(newSupply, supplyCap);
+        }
+    }
+
+    function getTokensIn() public view override returns (address[] memory res) {
+        return ArrayLib.create(NATIVE, STETH, WSTETH, vault);
+    }
+
+    function isValidTokenIn(address token) public view override returns (bool) {
+        return token == NATIVE || token == STETH || token == WSTETH || token == vault;
+    }
+
+    /// @dev returns mellow TVL in WSTETH
+    /// @dev reverts if the vault contains more than 1 token
+    function _getMellowVaultTvl() internal view returns (uint256 tvl, uint256 supply) {
+        (address[] memory tokens, uint256[] memory amounts) = IMellowVault(vault).underlyingTvl();
+        if (tokens.length > 1 || tokens[0] != WSTETH) {
+            revert MellowVaultHasInvalidAssets();
+        }
+
+        tvl = amounts[0];
+        supply = IERC20(vault).totalSupply();
+    }
+}

package/contracts/core/StandardizedYield/implementations/Mellow/PendleMellowVaultWstETHSYUpg.sol

@@ -0,0 +1,102 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.0;
+
+import "./PendleMellowVaultERC20SYUpg.sol";
+
+/// @dev This SY implementation intends to ignore native interest from Mellow Vault's underlying
+contract PendleMellowVaultWstETHSYUpg is PendleMellowVaultERC20SYUpg, StEthHelper {
+    error MellowVaultHasInvalidAssets();
+    error SupplyCapExceeded(uint256 totalSupply, uint256 supplyCap);
+
+    // solhint-disable immutable-vars-naming
+    uint256 public immutable interfaceVersion;
+
+    constructor(address _vault, uint256 _interfaceVersion) PendleMellowVaultERC20SYUpg(_vault) {
+        if (_interfaceVersion > 1) {
+            revert("invalid interface version");
+        }
+        interfaceVersion = _interfaceVersion;
+    }
+
+    function initialize(
+        string memory _name,
+        string memory _symbol,
+        address _pricingHelper
+    ) external override initializer {
+        __SYBaseUpg_init(_name, _symbol);
+        _safeApproveInf(STETH, WSTETH);
+        _safeApproveInf(WSTETH, vault);
+        _setPricingHelper(_pricingHelper);
+    }
+
+    function _deposit(
+        address tokenIn,
+        uint256 amountDeposited
+    ) internal virtual override returns (uint256 amountSharesOut) {
+        if (tokenIn == vault) {
+            return amountDeposited;
+        }
+        if (tokenIn != WSTETH) {
+            (tokenIn, amountDeposited) = (WSTETH, _depositWstETH(tokenIn, amountDeposited));
+        }
+
+        if (interfaceVersion == 0) {
+            (, amountSharesOut) = IMellowVault(vault).deposit(
+                address(this),
+                ArrayLib.create(amountDeposited),
+                0,
+                type(uint256).max,
+                0
+            );
+        } else if (interfaceVersion == 1) {
+            (, amountSharesOut) = IMellowVault(vault).deposit(
+                address(this),
+                ArrayLib.create(amountDeposited),
+                0,
+                type(uint256).max
+            );
+        }
+    }
+
+    /// @dev Mellow uses math calculations under 2**96 base. Also they are taking into account oracle prices
+    /// even with one asset. So a discrepancy of 1e-6 in the result should be expected.
+    function _previewDeposit(
+        address tokenIn,
+        uint256 amountTokenToDeposit
+    ) internal view virtual override returns (uint256 amountSharesOut) {
+        if (tokenIn == vault) {
+            return amountTokenToDeposit;
+        }
+        if (tokenIn != WSTETH) {
+            (tokenIn, amountTokenToDeposit) = (WSTETH, _previewDepositWstETH(tokenIn, amountTokenToDeposit));
+        }
+        (uint256 tvl, uint256 supply) = _getMellowVaultTvl();
+        amountSharesOut = (amountTokenToDeposit * supply) / tvl;
+
+        uint256 supplyCap = IMellowVaultConfigurator(configurator).maximalTotalSupply();
+        uint256 newSupply = supply + amountSharesOut;
+        if (newSupply > supplyCap) {
+            revert SupplyCapExceeded(newSupply, supplyCap);
+        }
+    }
+
+    function getTokensIn() public view override returns (address[] memory res) {
+        return ArrayLib.create(NATIVE, STETH, WSTETH, vault);
+    }
+
+    function isValidTokenIn(address token) public view override returns (bool) {
+        return token == NATIVE || token == STETH || token == WSTETH || token == vault;
+    }
+
+    /// @dev returns mellow TVL in WSTETH
+    /// @dev reverts if the vault contains more than 1 token
+    function _getMellowVaultTvl() internal view returns (uint256 tvl, uint256 supply) {
+        (address[] memory tokens, uint256[] memory amounts) = IMellowVault(vault).underlyingTvl();
+        if (tokens.length > 1 || tokens[0] != WSTETH) {
+            revert MellowVaultHasInvalidAssets();
+        }
+
+        tvl = amounts[0];
+        supply = IERC20(vault).totalSupply();
+    }
+}

package/contracts/core/StandardizedYield/implementations/PendleERC20SYUpg.sol

@@ -3,12 +3,19 @@ pragma solidity ^0.8.17;
 
 import "../SYBaseUpg.sol";
 
-abstract contract PendleERC20SYUpg is SYBaseUpg {
+contract PendleERC20SYUpg is SYBaseUpg {
     using PMath for uint256;
 
     uint256[100] private __gap;
 
-    constructor(address _erc20) SYBaseUpg(_erc20) {}
+    constructor(address _erc20) SYBaseUpg(_erc20) {
+        _disableInitializers();
+    }
+
+    function initialize(string memory _name, string memory _symbol) external virtual initializer {
+        __SYBaseUpg_init(_name, _symbol);
+    }
+
 
     function _deposit(
         address /*tokenIn*/,

package/contracts/core/YieldContracts/PendleYieldToken.sol

@@ -418,8 +418,11 @@ contract PendleYieldToken is IPYieldToken, PendleERC20, RewardManagerAbstract, I
         if (isExpired()) {
             // post-expiry, all incoming rewards will go to the treasury
             // hence, we can save users one _redeemExternal here
-            for (uint256 i = 0; i < tokens.length; i++)
-                postExpiry.userRewardOwed[tokens[i]] -= userReward[tokens[i]][user].accrued;
+            for (uint256 i = 0; i < tokens.length; i++) {
+                uint256 owed = postExpiry.userRewardOwed[tokens[i]];
+                uint256 accrued = userReward[tokens[i]][user].accrued;
+                postExpiry.userRewardOwed[tokens[i]] = (owed < accrued) ? 0 : owed - accrued;
+            }
             rewardAmounts = __doTransferOutRewardsLocal(tokens, user, receiver, false);
         } else {
             rewardAmounts = __doTransferOutRewardsLocal(tokens, user, receiver, true);

package/contracts/core/libraries/ArrayLib.sol

@@ -120,6 +120,14 @@ library ArrayLib {
         res[2] = c;
     }
 
+    function create(address a, address b, address c, address d) internal pure returns (address[] memory res) {
+        res = new address[](4);
+        res[0] = a;
+        res[1] = b;
+        res[2] = c;
+        res[3] = d;
+    }
+
     function create(uint256 a) internal pure returns (uint256[] memory res) {
         res = new uint256[](1);
         res[0] = a;

package/contracts/interfaces/AaveV3/IAaveV3AToken.sol

@@ -12,4 +12,6 @@ interface IAaveV3AToken {
     function scaledTotalSupply() external view returns (uint256);
 
     function getPreviousIndex(address user) external view returns (uint256);
+
+    function getIncentivesController() external view returns (address);
 }

package/contracts/interfaces/AaveV3/IAaveV3IncentiveController.sol

@@ -0,0 +1,11 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+pragma solidity ^0.8.0;
+
+interface IAaveV3IncentiveController {
+    function getRewardsList() external view returns (address[] memory);
+
+    function claimAllRewardsToSelf(
+        address[] calldata assets
+    ) external returns (address[] memory rewardsList, uint256[] memory claimedAmounts);
+}

package/contracts/interfaces/Dolomite/IDolomiteDToken.sol

@@ -0,0 +1,14 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+interface IDolomiteDToken {
+    function mint(uint256 _amount) external returns (uint256);
+
+    function redeem(uint256 _dAmount) external returns (uint256);
+
+    function underlyingToken() external returns (address);
+
+    function marketId() external view returns (uint256);
+
+    function DOLOMITE_MARGIN() external view returns (address);
+}

package/contracts/interfaces/Dolomite/IDolomiteMarginContract.sol

@@ -0,0 +1,14 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+interface IDolomiteMarginContract {
+    struct Index {
+        uint96 borrow;
+        uint96 supply;
+        uint32 lastUpdate;
+    }
+
+    function getMarketIdByTokenAddress(address token) external view returns (uint256);
+
+    function getMarketCurrentIndex(uint256 marketId) external view returns (Index memory);
+}

package/contracts/interfaces/Mellow/IMellowVault.sol

@@ -0,0 +1,23 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.0;
+
+interface IMellowVault {
+    function underlyingTvl() external view returns (address[] memory tokens, uint256[] memory amounts);
+
+    function deposit(
+        address to,
+        uint256[] memory amounts,
+        uint256 minLpAmount,
+        uint256 deadline,
+        uint256 referralCode
+    ) external returns (uint256[] memory actualAmounts, uint256 lpAmount);
+
+    function deposit(
+        address to,
+        uint256[] memory amounts,
+        uint256 minLpAmount,
+        uint256 deadline
+    ) external returns (uint256[] memory actualAmounts, uint256 lpAmount);
+
+    function configurator() external view returns (address);
+}

package/contracts/interfaces/Mellow/IMellowVaultConfigurator.sol

@@ -0,0 +1,6 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.0;
+
+interface IMellowVaultConfigurator {
+    function maximalTotalSupply() external view returns (uint256);
+}

package/contracts/limit/LimitRouterBase.sol

@@ -41,7 +41,14 @@ abstract contract LimitRouterBase is
 
     mapping(bytes32 => OrderStatus) internal _status;
 
-    uint256[100] private __gap;
+    address public ownerHelper;
+
+    uint256[99] private __gap;
+
+    modifier onlyHelperAndOwner() {
+        require(msg.sender == ownerHelper || msg.sender == owner, "not allowed");
+        _;
+    }
 
     constructor(address _WNATIVE) {
         WNATIVE = _WNATIVE;
@@ -466,17 +473,32 @@ abstract contract LimitRouterBase is
     }
 
     // ----------------- Owner -----------------
+
     function setFeeRecipient(address _feeRecipient) public onlyOwner {
         feeRecipient = _feeRecipient;
     }
 
-    function setLnFeeRateRoots(address[] memory YTs, uint256[] memory lnFeeRateRoots) public onlyOwner {
+    function setOwnerHelper(address _helper) public onlyOwner {
+        ownerHelper = _helper;
+    }
+
+    function setLnFeeRateRoots(address[] memory YTs, uint256[] memory lnFeeRateRoots) public onlyHelperAndOwner {
         uint256 len = YTs.length;
         require(len == lnFeeRateRoots.length, "LOP: length mismatch");
 
+        if (msg.sender == ownerHelper) {
+            _requireFeeNotSet(YTs);
+        }
+
         for (uint256 i = 0; i < len; i++) {
             require(lnFeeRateRoots[i] > 0, "LOP: zero fee not allowed");
             __lnFeeRateRoot[YTs[i]] = lnFeeRateRoots[i];
         }
     }
+
+    function _requireFeeNotSet(address[] memory YTs) internal view {
+        for (uint256 i = 0; i < YTs.length; i++) {
+            require(__lnFeeRateRoot[YTs[i]] == 0, "LOP: fee already set");
+        }
+    }
 }

package/contracts/offchain-helpers/PendleWstETHPriceFeed.sol

@@ -0,0 +1,25 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.17;
+
+import "../interfaces/IWstETH.sol";
+import "../interfaces/IPPriceFeed.sol";
+import {AggregatorV2V3Interface as IChainlinkAggregator} from "@chainlink/contracts/src/v0.8/interfaces/AggregatorV2V3Interface.sol";
+
+contract PendleWstETHPriceFeed is IPPriceFeed {
+    // solhint-disable immutable-vars-naming
+    address public constant WSTETH = 0x7f39C581F595B53c5cb19bD0b3f8dA6c935E2Ca0;
+    address public constant STETH_TO_ETH = 0x86392dC19c0b719886221c78AB11eb8Cf5c52812;
+    address public constant ETH_TO_USD = 0x5f4eC3Df9cbd43714FE2740f5E3616155c5b8419;
+    uint256 public constant FEED_MULTIPLIER = 10 ** 8;
+
+    function getPrice() external view returns (uint256) {
+        uint256 toStETH = IWstETH(WSTETH).stEthPerToken();
+        uint256 toETH = _applyFeedMultiplier(toStETH, STETH_TO_ETH);
+        return _applyFeedMultiplier(toETH, ETH_TO_USD);
+    }
+
+    function _applyFeedMultiplier(uint256 base, address feed) internal view returns (uint256) {
+        return
+            (base * uint256(IChainlinkAggregator(feed).latestAnswer())) / 10 ** (IChainlinkAggregator(feed).decimals());
+    }
+}

package/contracts/offchain-helpers/errors/SDKErrorsDirectory.sol

@@ -184,4 +184,74 @@ library SDKErrorsDirectory {
     error IXERC20_NotHighEnoughLimits();
     error ReturnAmountIsNotEnough();
     error ErrorNotEnoughAllowance();
+    error OnlyManager();
+    error OnlyTradingPnlHandler();
+    error OnlyPnlFeed();
+    error AddressZero();
+    error PriceZero();
+    error ValueZero();
+    error BytesZero();
+    error NoActiveDiscount();
+    error BelowMin();
+    error AboveMax();
+    error WrongValue();
+    error WrongValues();
+    error GnsPriceCallFailed();
+    error GnsTokenPriceZero();
+    error PendingWithdrawal();
+    error EndOfEpoch();
+    error NotAllowed();
+    error NoDiscount();
+    error NotUnlocked();
+    error NotEnoughAssets();
+    error MaxDailyPnl();
+    error NotUnderCollateralized();
+    error AboveInflationLimit();
+    error OwnableInvalidOwner(address owner);
+    error ERC4626ExceededMaxDeposit();
+    error ERC4626ExceededMaxMint();
+    error ERC4626ExceededMaxWithdraw();
+    error ERC4626ExceededMaxRedeem();
+
+    error AccessControlUnauthorizedAccount(address account, bytes32 neededRole);
+    error AccessControlBadConfirmation();
+    error ERC20InvalidSender(address sender);
+    error ERC20InvalidReceiver(address receiver);
+    error ERC20InvalidApprover(address approver);
+    error ERC20InvalidSpender(address spender);
+    error ERC721InvalidOwner(address owner);
+    error ERC721NonexistentToken(uint256 tokenId);
+    error ERC721IncorrectOwner(address sender, uint256 tokenId, address owner);
+    error ERC721InvalidSender(address sender);
+    error ERC721InvalidReceiver(address receiver);
+    error ERC721InsufficientApproval(address operator, uint256 tokenId);
+    error ERC721InvalidApprover(address approver);
+    error ERC721InvalidOperator(address operator);
+    error ERC1155InsufficientBalance(address sender, uint256 balance, uint256 needed, uint256 tokenId);
+    error ERC1155InvalidSender(address sender);
+    error ERC1155InvalidReceiver(address receiver);
+    error ERC1155MissingApprovalForAll(address operator, address owner);
+    error ERC1155InvalidApprover(address approver);
+    error ERC1155InvalidOperator(address operator);
+    error ERC1155InvalidArrayLength(uint256 idsLength, uint256 valuesLength);
+    error SafeERC20FailedOperation(address token);
+    error SafeERC20FailedDecreaseAllowance(address spender, uint256 currentAllowance, uint256 requestedDecrease);
+    error AddressInsufficientBalance(address account);
+    error AddressEmptyCode(address target);
+    error FailedInnerCall();
+    error ReentrancyGuardReentrantCall();
+    error MathOverflowedMulDiv();
+    error Deadline();
+    error InvalidState();
+    error InvalidLength();
+    error InvalidToken();
+    error NonZeroValue();
+    error InsufficientLpAmount();
+    error InsufficientAmount();
+    error LimitOverflow();
+    error AlreadyAdded();
+    error InvalidDelay();
+    error InvalidTimestamp();
+    error InvalidWithdrawalFee();
+    error InvalidTotalSupply();
 }

package/contracts/oracles/PendleLpOracleLib.sol

@@ -16,7 +16,7 @@ library PendleLpOracleLib {
      * @param duration twap duration
      */
     function getLpToAssetRate(IPMarket market, uint32 duration) internal view returns (uint256) {
-        (uint256 syIndex, uint256 pyIndex) = PendlePYOracleLib.getSYandPYIndexCurrent(market);
+        (uint256 syIndex, uint256 pyIndex) = market.getSYandPYIndexCurrent();
         uint256 lpToAssetRateRaw = _getLpToAssetRateRaw(market, duration, pyIndex);
         if (syIndex >= pyIndex) {
             return lpToAssetRateRaw;
@@ -32,7 +32,7 @@ library PendleLpOracleLib {
      * @param duration twap duration
      */
     function getLpToSyRate(IPMarket market, uint32 duration) internal view returns (uint256) {
-        (uint256 syIndex, uint256 pyIndex) = PendlePYOracleLib.getSYandPYIndexCurrent(market);
+        (uint256 syIndex, uint256 pyIndex) = market.getSYandPYIndexCurrent();
         uint256 lpToAssetRateRaw = _getLpToAssetRateRaw(market, duration, pyIndex);
         if (syIndex >= pyIndex) {
             return lpToAssetRateRaw.divDown(syIndex);
@@ -76,11 +76,11 @@ library PendleLpOracleLib {
         MarketState memory state,
         uint32 duration
     ) private view returns (int256 rateOracle, int256 rateHypTrade) {
-        rateOracle = PMath.IONE.divDown(market.getPtToAssetRateRaw(duration).Int());
-        int256 rateLastTrade = MarketMathCore._getExchangeRateFromImpliedRate(
-            state.lastLnImpliedRate,
-            state.expiry - block.timestamp
-        );
+        uint256 lnImpliedRate = market.getMarketLnImpliedRate(duration);
+        uint256 timeToExpiry = state.expiry - block.timestamp;
+        rateOracle = MarketMathCore._getExchangeRateFromImpliedRate(lnImpliedRate, timeToExpiry);
+
+        int256 rateLastTrade = MarketMathCore._getExchangeRateFromImpliedRate(state.lastLnImpliedRate, timeToExpiry);
         rateHypTrade = (rateLastTrade + rateOracle) / 2;
     }
 }

package/contracts/oracles/PendlePYOracleLib.sol

@@ -67,7 +67,7 @@ library PendlePYOracleLib {
         if (expiry <= block.timestamp) {
             return PMath.ONE;
         } else {
-            uint256 lnImpliedRate = _getMarketLnImpliedRate(market, duration);
+            uint256 lnImpliedRate = getMarketLnImpliedRate(market, duration);
             uint256 timeToExpiry = expiry - block.timestamp;
             uint256 assetToPtRate = MarketMathCore._getExchangeRateFromImpliedRate(lnImpliedRate, timeToExpiry).Uint();
             return PMath.ONE.divDown(assetToPtRate);
@@ -92,7 +92,7 @@ library PendlePYOracleLib {
         }
     }
 
-    function _getMarketLnImpliedRate(IPMarket market, uint32 duration) private view returns (uint256) {
+    function getMarketLnImpliedRate(IPMarket market, uint32 duration) internal view returns (uint256) {
         uint32[] memory durations = new uint32[](2);
         durations[0] = duration;