@pendle/core-v2 4.5.2 → 4.7.0

package/contracts/core/StandardizedYield/implementations/Karak/PendleKarakVaultSUSDESY.sol

@@ -0,0 +1,73 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.17;
+
+import "../../../../interfaces/IPTokenWithSupplyCap.sol";
+import "./PendleKarakVaultSYBaseUpg.sol";
+
+contract PendleKarakVaultSUSDESY is PendleKarakVaultSYBaseUpg, IPTokenWithSupplyCap {
+    // solhint-disable immutable-vars-naming
+    address public immutable usde;
+    address public immutable susde;
+
+    constructor(address _vault, address _vaultSupervisor) PendleKarakVaultSYBaseUpg(_vault, _vaultSupervisor) {
+        susde = IERC4626(_vault).asset();
+        usde = IERC4626(susde).asset();
+    }
+
+    function getAbsoluteSupplyCap() external view returns (uint256) {
+        uint256 assetLimit = IKarakVault(vault).assetLimit();
+        return IERC4626(vault).convertToShares(assetLimit);
+    }
+
+    function getAbsoluteTotalSupply() external view returns (uint256) {
+        return IERC20(vault).totalSupply();
+    }
+
+    function initialize() external initializer {
+        __SYBaseUpg_init("SY Karak sUSDe", "SY-Karak-sUSDe");
+        __KarakVaultSY_init();
+        _safeApproveInf(usde, susde);
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                               EXCHANGE-RATE
+    //////////////////////////////////////////////////////////////*/
+
+    function _getStakeTokenExchangeRate() internal view virtual override returns (uint256) {
+        return IERC4626(susde).previewRedeem(PMath.ONE);
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                    ADDITIONAL TOKEN IN FUNCTIONS
+    //////////////////////////////////////////////////////////////*/
+
+    function _getAdditionalTokens() internal view virtual override returns (address[] memory) {
+        return ArrayLib.create(usde);
+    }
+
+    function _previewToStakeToken(
+        address tokenIn,
+        uint256 amountTokenToDeposit
+    ) internal view virtual override returns (uint256) {
+        assert(tokenIn == usde);
+
+        return IERC4626(susde).previewDeposit(amountTokenToDeposit);
+    }
+
+    function _wrapToStakeToken(
+        address tokenIn,
+        uint256 amountDeposited
+    ) internal virtual override returns (uint256) {
+        assert(tokenIn == usde);
+
+        return IERC4626(susde).deposit(amountDeposited, address(this));
+    }
+
+    function _canWrapToStakeToken(address tokenIn) internal view virtual override returns (bool) {
+        return tokenIn == usde;
+    }
+
+    function assetInfo() external view override returns (AssetType, address, uint8) {
+        return (AssetType.TOKEN, usde, 18);
+    }
+}

package/contracts/core/StandardizedYield/implementations/Karak/PendleKarakVaultSYBaseUpg.sol

@@ -0,0 +1,141 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.17;
+
+import "../../SYBaseUpg.sol";
+import "../../../../interfaces/IERC4626.sol";
+import "../../../../interfaces/Karak/IKarakVault.sol";
+import "../../../../interfaces/Karak/IKarakVaultSupervisor.sol";
+
+/**
+ * Pendle SY should take either the stake token or the vault token from user to deposit back into Karak.
+ * At any point of time, all holding under SY.totalSupply() should always be deposited inside Karak rather than holding the vault token.
+ */
+abstract contract PendleKarakVaultSYBaseUpg is SYBaseUpg {
+    using ArrayLib for address[];
+
+    error KarakVaultAssetLimitExceeded(uint256 assetLimit, uint256 totalAsset, uint256 amountAssetToDeposit);
+
+    // solhint-disable immutable-vars-naming
+    address public immutable vault; // vault is also share token
+    address public immutable stakeToken;
+    address public immutable vaultSupervisor;
+
+    // address public immutable shareToken;
+
+    constructor(address _vault, address _vaultSupervisor) SYBaseUpg(_vault) {
+        vault = _vault;
+        stakeToken = IERC4626(_vault).asset();
+        vaultSupervisor = _vaultSupervisor;
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                    Karak Vault Specilization
+    //////////////////////////////////////////////////////////////*/
+
+    function __KarakVaultSY_init() internal onlyInitializing {
+        _safeApproveInf(stakeToken, vault);
+        _safeApproveInf(vault, vaultSupervisor);
+    }
+
+    function exchangeRate() public view override returns (uint256) {
+        uint256 stakeTokenRate = _getStakeTokenExchangeRate();
+        // There should be no decimal offset on normal ERC20 tokens
+        // Could not be use for stakeToken without a properly configured ERC20 interface
+        uint256 shareToAssetRate = IERC4626(vault).convertToAssets(PMath.ONE);
+        return (stakeTokenRate * shareToAssetRate) / PMath.ONE;
+    }
+
+    function _getStakeTokenExchangeRate() internal view virtual returns (uint256);
+
+    /*///////////////////////////////////////////////////////////////
+                    DEPOSIT/REDEEM USING BASE TOKENS
+    //////////////////////////////////////////////////////////////*/
+
+    function _deposit(
+        address tokenIn,
+        uint256 amountDeposited
+    ) internal virtual override returns (uint256 /*amountSharesOut*/) {
+        if (tokenIn != stakeToken && tokenIn != vault) {
+            (tokenIn, amountDeposited) = (stakeToken, _wrapToStakeToken(tokenIn, amountDeposited));
+        }
+
+        if (tokenIn == stakeToken) {
+            return IKarakVaultSupervisor(vaultSupervisor).deposit(vault, amountDeposited, 0);
+        } else {
+            IKarakVaultSupervisor(vaultSupervisor).returnShares(vault, amountDeposited);
+            return amountDeposited;
+        }
+    }
+
+    function _redeem(
+        address receiver,
+        address /*tokenOut*/,
+        uint256 amountSharesToRedeem
+    ) internal virtual override returns (uint256 /*amountTokenOut*/) {
+        IKarakVaultSupervisor(vaultSupervisor).gimmieShares(vault, amountSharesToRedeem);
+        _transferOut(vault, receiver, amountSharesToRedeem);
+        return amountSharesToRedeem;
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                MISC FUNCTIONS FOR METADATA
+    //////////////////////////////////////////////////////////////*/
+
+    function _previewDeposit(address tokenIn, uint256 amountTokenToDeposit) internal view override returns (uint256) {
+        if (tokenIn != stakeToken && tokenIn != vault) {
+            (tokenIn, amountTokenToDeposit) = (stakeToken, _previewToStakeToken(tokenIn, amountTokenToDeposit));
+        }
+
+        if (tokenIn == stakeToken) {
+            uint256 totalAsset = IERC4626(vault).totalAssets();
+            uint256 totalSupply = IERC4626(vault).totalSupply();
+            uint256 assetLimit = IKarakVault(vault).assetLimit();
+            if (totalAsset + amountTokenToDeposit > assetLimit) {
+                revert KarakVaultAssetLimitExceeded(assetLimit, totalAsset, amountTokenToDeposit);
+            }
+            return (amountTokenToDeposit * totalSupply) / totalAsset;
+        }
+        return amountTokenToDeposit;
+    }
+
+    function _previewRedeem(
+        address /*tokenOut*/,
+        uint256 amountSharesToRedeem
+    ) internal pure override returns (uint256 /*amountTokenOut*/) {
+        return amountSharesToRedeem;
+    }
+
+    function getTokensIn() public view virtual override returns (address[] memory) {
+        return ArrayLib.create(vault, stakeToken).merge(_getAdditionalTokens());
+    }
+
+    function getTokensOut() public view virtual override returns (address[] memory) {
+        return ArrayLib.create(vault);
+    }
+
+    function isValidTokenIn(address token) public view virtual override returns (bool) {
+        return token == vault || token == stakeToken || _canWrapToStakeToken(token);
+    }
+
+    function isValidTokenOut(address token) public view virtual override returns (bool) {
+        return token == vault;
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                    ADDITIONAL TOKEN IN FUNCTIONS
+    //////////////////////////////////////////////////////////////*/
+
+    function _getAdditionalTokens() internal view virtual returns (address[] memory) {}
+
+    function _previewToStakeToken(address, uint256) internal view virtual returns (uint256) {
+        assert(false);
+    }
+
+    function _wrapToStakeToken(address, uint256) internal virtual returns (uint256) {
+        assert(false);
+    }
+
+    function _canWrapToStakeToken(address) internal view virtual returns (bool) {
+        return false;
+    }
+}

package/contracts/core/StandardizedYield/implementations/Karak/PendleKarakVaultUSDESY.sol

@@ -0,0 +1,18 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.17;
+
+import "../../../../interfaces/IPTokenWithSupplyCap.sol";
+import "./PendleKarakVaultERC20SY.sol";
+
+contract PendleKarakVaultUSDESY is PendleKarakVaultERC20SY, IPTokenWithSupplyCap {
+    constructor(address _vault, address _vaultSupervisor) PendleKarakVaultERC20SY(_vault, _vaultSupervisor) {}
+
+    function getAbsoluteSupplyCap() external view returns (uint256) {
+        uint256 assetLimit = IKarakVault(vault).assetLimit();
+        return IERC4626(vault).convertToShares(assetLimit);
+    }
+
+    function getAbsoluteTotalSupply() external view returns (uint256) {
+        return IERC20(vault).totalSupply();
+    }
+}

package/contracts/core/StandardizedYield/implementations/Karak/PendleKarakVaultWEETHSY.sol

@@ -0,0 +1,71 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.17;
+
+import "./PendleKarakVaultSYBaseUpg.sol";
+import "../../../../interfaces/EtherFi/IEtherFiLiquidityPool.sol";
+import "../../../../interfaces/EtherFi/IEtherFiWEEth.sol";
+
+contract PendleKarakVaultWEETHSY is PendleKarakVaultSYBaseUpg {
+    // solhint-disable immutable-vars-naming
+    address public immutable weETH;
+    address public immutable liquidityPool;
+    address public immutable eETH;
+    address public immutable referee;
+
+    constructor(
+        address _vault,
+        address _vaultSupervisor,
+        address _referee
+    ) PendleKarakVaultSYBaseUpg(_vault, _vaultSupervisor) {
+        weETH = IERC4626(_vault).asset();
+        liquidityPool = IEtherFiWEEth(weETH).liquidityPool();
+        eETH = IEtherFiWEEth(weETH).eETH();
+        referee = _referee;
+
+        _disableInitializers();
+    }
+
+    function initialize() external initializer {
+        __SYBaseUpg_init("SY Karak WEETH", "SY-Karak-WEETH");
+        __KarakVaultSY_init();
+        _safeApproveInf(eETH, weETH);
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                               EXCHANGE-RATE
+    //////////////////////////////////////////////////////////////*/
+
+    function _getStakeTokenExchangeRate() internal view virtual override returns (uint256) {
+        return IEtherFiLiquidityPool(liquidityPool).amountForShare(1 ether);
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                    ADDITIONAL TOKEN IN FUNCTIONS
+    //////////////////////////////////////////////////////////////*/
+
+    function _getAdditionalTokens() internal view virtual override returns (address[] memory) {
+        return ArrayLib.create(eETH, NATIVE);
+    }
+
+    function _previewToStakeToken(
+        address,
+        uint256 amountTokenToDeposit
+    ) internal view virtual override returns (uint256) {
+        return IEtherFiLiquidityPool(liquidityPool).sharesForAmount(amountTokenToDeposit);
+    }
+
+    function _wrapToStakeToken(address tokenIn, uint256 amountDeposited) internal virtual override returns (uint256) {
+        if (tokenIn == NATIVE) {
+            IEtherFiLiquidityPool(liquidityPool).deposit{value: amountDeposited}(referee);
+        }
+        return IEtherFiWEEth(weETH).wrap(_selfBalance(eETH));
+    }
+
+    function _canWrapToStakeToken(address tokenIn) internal view virtual override returns (bool) {
+        return tokenIn == eETH || tokenIn == NATIVE;
+    }
+
+    function assetInfo() external view override returns (AssetType, address, uint8) {
+        return (AssetType.TOKEN, eETH, 18);
+    }
+}

package/contracts/interfaces/IERC4626.sol

@@ -33,6 +33,8 @@ interface IERC4626 is IERC20Metadata {
 
     function convertToAssets(uint256 shares) external view returns (uint256);
 
+    function convertToShares(uint256 assets) external view returns (uint256);
+
     function previewDeposit(uint256 assets) external view returns (uint256);
 
     function previewRedeem(uint256 shares) external view returns (uint256);

package/contracts/interfaces/IPActionMiscV3.sol

@@ -26,6 +26,26 @@ interface IPActionMiscV3 {
         bytes returnData;
     }
 
+    struct ExitPreExpReturnParams {
+        uint256 netPtFromRemove;
+        uint256 netSyFromRemove;
+        uint256 netPyRedeem;
+        uint256 netSyFromRedeem;
+        uint256 netPtSwap;
+        uint256 netYtSwap;
+        uint256 netSyFromSwap;
+        uint256 netSyFee;
+        uint256 totalSyOut;
+    }
+
+    struct ExitPostExpReturnParams {
+        uint256 netPtFromRemove;
+        uint256 netSyFromRemove;
+        uint256 netPtRedeem;
+        uint256 netSyFromRedeem;
+        uint256 totalSyOut;
+    }
+
     event MintSyFromToken(
         address indexed caller,
         address indexed tokenIn,
@@ -80,6 +100,42 @@ interface IPActionMiscV3 {
         uint256 netSyInterm
     );
 
+    event ExitPreExpToToken(
+        address indexed caller,
+        address indexed market,
+        address indexed token,
+        address receiver,
+        uint256 netLpIn,
+        uint256 totalTokenOut,
+        ExitPreExpReturnParams params
+    );
+
+    event ExitPreExpToSy(
+        address indexed caller,
+        address indexed market,
+        address indexed receiver,
+        uint256 netLpIn,
+        ExitPreExpReturnParams params
+    );
+
+    event ExitPostExpToToken(
+        address indexed caller,
+        address indexed market,
+        address indexed token,
+        address receiver,
+        uint256 netLpIn,
+        uint256 totalTokenOut,
+        ExitPostExpReturnParams params
+    );
+
+    event ExitPostExpToSy(
+        address indexed caller,
+        address indexed market,
+        address indexed receiver,
+        uint256 netLpIn,
+        ExitPostExpReturnParams params
+    );
+
     function mintSyFromToken(
         address receiver,
         address SY,
@@ -143,6 +199,49 @@ interface IPActionMiscV3 {
         uint256 minTokenOut
     ) external payable returns (uint256 netTokenOut, uint256 netSyInterm);
 
+    function exitPreExpToToken(
+        address receiver,
+        address market,
+        uint256 netPtIn,
+        uint256 netYtIn,
+        uint256 netLpIn,
+        TokenOutput calldata output,
+        LimitOrderData calldata limit
+    ) external returns (uint256 netTokenOut, ExitPreExpReturnParams memory params);
+
+    function exitPreExpToSy(
+        address receiver,
+        address market,
+        uint256 netPtIn,
+        uint256 netYtIn,
+        uint256 netLpIn,
+        uint256 minSyOut,
+        LimitOrderData calldata limit
+    ) external returns (ExitPreExpReturnParams memory params);
+
+    function exitPostExpToToken(
+        address receiver,
+        address market,
+        uint256 netPtIn,
+        uint256 netLpIn,
+        TokenOutput calldata output
+    ) external returns (uint256 netTokenOut, ExitPostExpReturnParams memory params);
+
+    function exitPostExpToSy(
+        address receiver,
+        address market,
+        uint256 netPtIn,
+        uint256 netLpIn,
+        uint256 minSyOut
+    ) external returns (ExitPostExpReturnParams memory params);
+
+    function callAndReflect(
+        address payable reflector,
+        bytes calldata selfCall1,
+        bytes calldata selfCall2,
+        bytes calldata reflectCall
+    ) external payable returns (bytes memory selfRes1, bytes memory selfRes2, bytes memory reflectRes);
+
     function boostMarkets(address[] memory markets) external;
 
     function multicall(Call3[] calldata calls) external payable returns (Result[] memory res);

package/contracts/interfaces/{IPPtLpOracle.sol → IPPYLpOracle.sol}

@@ -1,15 +1,19 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity ^0.8.0;
 
-interface IPPtLpOracle {
+interface IPPYLpOracle {
     event SetBlockCycleNumerator(uint16 newBlockCycleNumerator);
 
     function getPtToAssetRate(address market, uint32 duration) external view returns (uint256);
 
+    function getYtToAssetRate(address market, uint32 duration) external view returns (uint256);
+
     function getLpToAssetRate(address market, uint32 duration) external view returns (uint256);
 
     function getPtToSyRate(address market, uint32 duration) external view returns (uint256);
 
+    function getYtToSyRate(address market, uint32 duration) external view returns (uint256);
+
     function getLpToSyRate(address market, uint32 duration) external view returns (uint256);
 
     function getOracleState(

package/contracts/interfaces/IPReflector.sol

@@ -0,0 +1,6 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.0;
+
+interface IPReflector {
+    function reflect(bytes calldata inputData) external returns (bytes memory result);
+}

package/contracts/interfaces/IPTokenWithSupplyCap.sol

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

package/contracts/interfaces/Karak/IKarakVault.sol

@@ -0,0 +1,6 @@
+// SPDX-License-Identifier: SEE LICENSE IN LICENSE
+pragma solidity ^0.8.0;
+
+interface IKarakVault {
+    function assetLimit() external view returns (uint256);
+}

package/contracts/interfaces/Karak/IKarakVaultSupervisor.sol

@@ -0,0 +1,8 @@
+// SPDX-License-Identifier: SEE LICENSE IN LICENSE
+pragma solidity ^0.8.0;
+
+interface IKarakVaultSupervisor {
+    function deposit(address vault, uint256 amount, uint256 minSharesOut) external returns (uint256 shares);
+    function gimmieShares(address vault, uint256 shares) external;
+    function returnShares(address vault, uint256 shares) external;
+}

package/contracts/offchain-helpers/PendlePoolDeployHelper.sol

@@ -39,6 +39,11 @@ contract PendlePoolDeployHelper is TokenHelper {
         _seedLiquidity(market, SY, PT, YT, tokenToSeedLiqudity, amountToSeed);
     }
 
+    function seedLiquidity(address market, address tokenToSeedLiqudity, uint256 amountToSeed) external payable {
+        (IStandardizedYield SY, IPPrincipalToken PT, IPYieldToken YT) = IPMarket(market).readTokens();
+        _seedLiquidity(market, address(SY), address(PT), address(YT), tokenToSeedLiqudity, amountToSeed);
+    }
+
     function _deployPYAndMarket(
         address SY,
         PoolDeploymentParams memory params

package/contracts/oracles/PendleLpOracleLib.sol

@@ -1,10 +1,10 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity ^0.8.0;
 
-import "./PendlePtOracleLib.sol";
+import "./PendlePYOracleLib.sol";
 
 library PendleLpOracleLib {
-    using PendlePtOracleLib for IPMarket;
+    using PendlePYOracleLib for IPMarket;
     using PMath for uint256;
     using PMath for int256;
     using MarketMathCore for MarketState;
@@ -16,7 +16,7 @@ library PendleLpOracleLib {
      * @param duration twap duration
      */
     function getLpToAssetRate(IPMarket market, uint32 duration) internal view returns (uint256) {
-        (uint256 syIndex, uint256 pyIndex) = PendlePtOracleLib.getSYandPYIndexCurrent(market);
+        (uint256 syIndex, uint256 pyIndex) = PendlePYOracleLib.getSYandPYIndexCurrent(market);
         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) = PendlePtOracleLib.getSYandPYIndexCurrent(market);
+        (uint256 syIndex, uint256 pyIndex) = PendlePYOracleLib.getSYandPYIndexCurrent(market);
         uint256 lpToAssetRateRaw = _getLpToAssetRateRaw(market, duration, pyIndex);
         if (syIndex >= pyIndex) {
             return lpToAssetRateRaw.divDown(syIndex);

package/contracts/oracles/{PendlePtLpOracle.sol → PendlePYLpOracle.sol}

@@ -1,16 +1,16 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity ^0.8.17;
 
-import "./PendlePtOracleLib.sol";
+import "./PendlePYOracleLib.sol";
 import "./PendleLpOracleLib.sol";
-import "../interfaces/IPPtLpOracle.sol";
+import "../interfaces/IPPYLpOracle.sol";
 import "../core/libraries/BoringOwnableUpgradeable.sol";
 
 // This is a pre-deployed version of PendlePtOracleLib & PendleLpOracleLib with additional utility functions.
 // Use of this contract rather than direct library integration resulting in a smaller bytecode size and simpler structure
 // but slightly higher gas usage (~ 4000 gas, 2 external calls & 1 cold code load)
-contract PendlePtLpOracle is BoringOwnableUpgradeable, IPPtLpOracle {
-    using PendlePtOracleLib for IPMarket;
+contract PendlePYLpOracle is BoringOwnableUpgradeable, IPPYLpOracle {
+    using PendlePYOracleLib for IPMarket;
     using PendleLpOracleLib for IPMarket;
 
     error InvalidBlockRate(uint256 blockCycleNumerator);
@@ -26,38 +26,54 @@ contract PendlePtLpOracle is BoringOwnableUpgradeable, IPPtLpOracle {
     uint16 public blockCycleNumerator;
     uint16 public constant BLOCK_CYCLE_DENOMINATOR = 1000;
 
-    constructor(uint16 _blockCycleNumerator) initializer {
+    constructor() {
+        _disableInitializers();
+    }
+
+    function initialize(uint16 _blockCycleNumerator) external initializer {
         __BoringOwnable_init();
-        setBlockCycleNumerator(_blockCycleNumerator);
+        _setBlockCycleNumerator(_blockCycleNumerator);
     }
 
-    function setBlockCycleNumerator(uint16 newBlockCycleNumerator) public onlyOwner {
-        if (newBlockCycleNumerator < BLOCK_CYCLE_DENOMINATOR) {
-            revert InvalidBlockRate(newBlockCycleNumerator);
-        }
+    // Refer to https://docs.pendle.finance/Home on how to use the oracle
 
-        blockCycleNumerator = newBlockCycleNumerator;
-        emit SetBlockCycleNumerator(newBlockCycleNumerator);
+    /*///////////////////////////////////////////////////////////////
+                    PT, YT, LP to SY
+    //////////////////////////////////////////////////////////////*/
+
+    function getPtToSyRate(address market, uint32 duration) external view returns (uint256) {
+        return IPMarket(market).getPtToSyRate(duration);
     }
 
-    function getPtToAssetRate(address market, uint32 duration) external view returns (uint256) {
-        return IPMarket(market).getPtToAssetRate(duration);
+    function getYtToSyRate(address market, uint32 duration) external view returns (uint256) {
+        return IPMarket(market).getYtToSyRate(duration);
     }
 
+    function getLpToSyRate(address market, uint32 duration) external view returns (uint256) {
+        return IPMarket(market).getLpToSyRate(duration);
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                    PT, YT, LP to Asset
+    //////////////////////////////////////////////////////////////*/
+
     /// @notice make sure you have taken into account the risk of not being able to withdraw from SY to Asset
-    /// More info in StandardizedYield
-    function getLpToAssetRate(address market, uint32 duration) external view returns (uint256) {
-        return IPMarket(market).getLpToAssetRate(duration);
+    function getPtToAssetRate(address market, uint32 duration) external view returns (uint256) {
+        return IPMarket(market).getPtToAssetRate(duration);
     }
 
-    function getPtToSyRate(address market, uint32 duration) external view returns (uint256) {
-        return IPMarket(market).getPtToSyRate(duration);
+    function getYtToAssetRate(address market, uint32 duration) external view returns (uint256) {
+        return IPMarket(market).getYtToAssetRate(duration);
     }
 
-    function getLpToSyRate(address market, uint32 duration) external view returns (uint256) {
-        return IPMarket(market).getLpToSyRate(duration);
+    function getLpToAssetRate(address market, uint32 duration) external view returns (uint256) {
+        return IPMarket(market).getLpToAssetRate(duration);
     }
 
+    /*///////////////////////////////////////////////////////////////
+                        Utility functions
+    //////////////////////////////////////////////////////////////*/
+
     /**
      * A check function for the cardinality status of the market
      * @param market PendleMarket address
@@ -99,4 +115,18 @@ contract PendlePtLpOracle is BoringOwnableUpgradeable, IPPtLpOracle {
         }
         return uint16(cardinalityRequired);
     }
+
+    // --- Owner-Only Functions ---
+    function setBlockCycleNumerator(uint16 newBlockCycleNumerator) external onlyOwner {
+        _setBlockCycleNumerator(newBlockCycleNumerator);
+    }
+
+    function _setBlockCycleNumerator(uint16 newBlockCycleNumerator) internal {
+        if (newBlockCycleNumerator < BLOCK_CYCLE_DENOMINATOR) {
+            revert InvalidBlockRate(newBlockCycleNumerator);
+        }
+
+        blockCycleNumerator = newBlockCycleNumerator;
+        emit SetBlockCycleNumerator(newBlockCycleNumerator);
+    }
 }