@pendle/core-v2 5.1.1-beta-2 → 5.1.2-beta-2

package/contracts/core/StandardizedYield/implementations/Mantle/PendleCMETHSY.sol

@@ -0,0 +1,82 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.17;
+
+import "../../SYBase.sol";
+import "../../../../interfaces/IPExchangeRateOracle.sol";
+
+contract PendleCMETHSY is SYBase {
+    using PMath for int256;
+
+    address public exchangeRateOracle = 0x1E2Ad9764cfAc60876486A7c714bc71f5b55f5C2;
+    address public constant CMETH = 0xE6829d9a7eE3040e1276Fa75293Bde931859e8fA;
+    address public constant WETH = 0xdEAddEaDdeadDEadDEADDEAddEADDEAddead1111;
+
+    constructor() SYBase("SY cmETH", "SY-cmETH", CMETH) {}
+
+    function setExchangeRateOracle(address newOracle) external onlyOwner {
+        exchangeRateOracle = newOracle;
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                    DEPOSIT/REDEEM USING BASE TOKENS
+    //////////////////////////////////////////////////////////////*/
+
+    function _deposit(address, uint256 amountDeposited) internal pure override returns (uint256 /*amountSharesOut*/) {
+        return amountDeposited;
+    }
+
+    function _redeem(
+        address receiver,
+        address tokenOut,
+        uint256 amountSharesToRedeem
+    ) internal override returns (uint256 /*amountTokenOut*/) {
+        _transferOut(tokenOut, receiver, amountSharesToRedeem);
+        return amountSharesToRedeem;
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                               EXCHANGE-RATE
+    //////////////////////////////////////////////////////////////*/
+
+    function exchangeRate() public view override returns (uint256) {
+        return IPExchangeRateOracle(exchangeRateOracle).getExchangeRate();
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                MISC FUNCTIONS FOR METADATA
+    //////////////////////////////////////////////////////////////*/
+
+    function _previewDeposit(
+        address,
+        uint256 amountTokenToDeposit
+    ) internal pure override returns (uint256 /*amountSharesOut*/) {
+        return amountTokenToDeposit;
+    }
+
+    function _previewRedeem(
+        address,
+        uint256 amountSharesToRedeem
+    ) internal pure override returns (uint256 /*amountTokenOut*/) {
+        return amountSharesToRedeem;
+    }
+
+    function getTokensIn() public view override returns (address[] memory res) {
+        return ArrayLib.create(yieldToken);
+    }
+
+    function getTokensOut() public view override returns (address[] memory res) {
+        return ArrayLib.create(yieldToken);
+    }
+
+    function isValidTokenIn(address token) public view override returns (bool) {
+        return token == yieldToken;
+    }
+
+    function isValidTokenOut(address token) public view override returns (bool) {
+        return token == yieldToken;
+    }
+
+    function assetInfo() external view returns (AssetType assetType, address assetAddress, uint8 assetDecimals) {
+        return (AssetType.TOKEN, WETH, 18);
+    }
+}

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

@@ -64,7 +64,12 @@ contract PendleERC20SYUpg is SYBaseUpg {
         return token == yieldToken;
     }
 
-    function assetInfo() external virtual view returns (AssetType assetType, address assetAddress, uint8 assetDecimals) {
+    function assetInfo()
+        external
+        view
+        virtual
+        returns (AssetType assetType, address assetAddress, uint8 assetDecimals)
+    {
         return (AssetType.TOKEN, yieldToken, IERC20Metadata(yieldToken).decimals());
     }
 }

package/contracts/core/StandardizedYield/implementations/Silo/PendleSiloWithIncentiveNonBorrowableSY.sol

@@ -0,0 +1,154 @@
+// SPDX-License-Identifier: BUSL-1.1
+pragma solidity ^0.8.17;
+
+import "../../SYBaseWithRewards.sol";
+import "../../../../interfaces/Silo/ISiloIncentiveController.sol";
+import "../../../../interfaces/Silo/ISilo.sol";
+import "../../../../interfaces/Silo/ISiloLens.sol";
+import "../../../libraries/ArrayLib.sol";
+import "../../../libraries/math/PMath.sol";
+
+contract PendleSiloWithIncentiveNonBorrowableSY is SYBaseWithRewards {
+    using PMath for uint256;
+    using ArrayLib for address[];
+
+    event SetNewIncentiveController(address indexed newController);
+
+    address public immutable asset;
+    address public immutable collateralToken;
+    address public immutable silo;
+    address public immutable siloLens;
+
+    address public incentiveController;
+    address[] public additionalRewardTokens;
+    address public immutable defaultRewardToken;
+
+    constructor(
+        string memory _name,
+        string memory _symbol,
+        address _asset,
+        address _collateralToken,
+        address _silo,
+        address _siloLens,
+        address _incentiveController
+    ) SYBaseWithRewards(_name, _symbol, _collateralToken) {
+        asset = _asset;
+        collateralToken = _collateralToken;
+        silo = _silo;
+        siloLens = _siloLens;
+
+        incentiveController = _incentiveController;
+        defaultRewardToken = ISiloIncentiveController(incentiveController).REWARD_TOKEN();
+
+        _safeApproveInf(asset, silo);
+    }
+
+    function _deposit(
+        address tokenIn,
+        uint256 amountDeposited
+    ) internal virtual override returns (uint256 amountSharesOut) {
+        if (tokenIn == collateralToken) {
+            return amountDeposited;
+        } else {
+            (, amountSharesOut) = ISilo(silo).deposit(asset, amountDeposited, true);
+        }
+    }
+
+    function _redeem(
+        address receiver,
+        address tokenOut,
+        uint256 amountSharesToRedeem
+    ) internal virtual override returns (uint256 amountTokenOut) {
+        if (tokenOut == collateralToken) {
+            _transferOut(collateralToken, receiver, amountSharesToRedeem);
+            return amountSharesToRedeem;
+        } else {
+            // Silo withdrawing interface only accepts amount of asset as input
+            // Therefore we need to ensure that assetInput.toShareRoundUp() <= amountSharesToRedeem
+
+            amountTokenOut = amountSharesToRedeem;
+
+            // amountAssetToWithdraw should = withdrawnAmount as withdrawing does not
+            // bear any fees
+            ISilo(silo).withdraw(asset, amountTokenOut, true);
+            _transferOut(tokenOut, receiver, amountTokenOut);
+        }
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                               EXCHANGE-RATE
+    //////////////////////////////////////////////////////////////*/
+
+    function exchangeRate() public view virtual override returns (uint256) {
+        return PMath.ONE;
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                               REWARDS-RELATED
+    //////////////////////////////////////////////////////////////*/
+
+    function setIncentiveController(address newController) external onlyOwner {
+        // Claim all pending rewards from old contract
+        _redeemExternalReward();
+
+        address newRewardToken = ISiloIncentiveController(newController).REWARD_TOKEN();
+        if (newRewardToken != defaultRewardToken && !additionalRewardTokens.contains(newRewardToken)) {
+            additionalRewardTokens.push(newRewardToken);
+        }
+        incentiveController = newController;
+
+        emit SetNewIncentiveController(newController);
+    }
+
+    /**
+     * @dev See {IStandardizedYield-getRewardTokens}
+     */
+    function _getRewardTokens() internal view override returns (address[] memory) {
+        return additionalRewardTokens.appendHead(defaultRewardToken);
+    }
+
+    function _redeemExternalReward() internal override {
+        ISiloIncentiveController(incentiveController).claimRewardsToSelf(
+            ArrayLib.create(collateralToken),
+            type(uint256).max
+        );
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                MISC FUNCTIONS FOR METADATA
+    //////////////////////////////////////////////////////////////*/
+
+    function _previewDeposit(
+        address tokenIn,
+        uint256 amountTokenToDeposit
+    ) internal view override returns (uint256 amountSharesOut) {
+        return amountTokenToDeposit;
+    }
+
+    function _previewRedeem(
+        address tokenOut,
+        uint256 amountSharesToRedeem
+    ) internal view override returns (uint256 amountTokenOut) {
+        return amountSharesToRedeem;
+    }
+
+    function getTokensIn() public view virtual override returns (address[] memory) {
+        return ArrayLib.create(asset, collateralToken);
+    }
+
+    function getTokensOut() public view virtual override returns (address[] memory) {
+        return ArrayLib.create(asset, collateralToken);
+    }
+
+    function isValidTokenIn(address token) public view virtual override returns (bool) {
+        return token == asset || token == collateralToken;
+    }
+
+    function isValidTokenOut(address token) public view virtual override returns (bool) {
+        return token == asset || token == collateralToken;
+    }
+
+    function assetInfo() external view returns (AssetType assetType, address assetAddress, uint8 assetDecimals) {
+        return (AssetType.TOKEN, asset, IERC20Metadata(asset).decimals());
+    }
+}

package/contracts/interfaces/AaveV3/IAaveStkGHO.sol

@@ -0,0 +1,17 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+pragma solidity ^0.8.0;
+
+interface IAaveStkGHO {
+    function stake(address to, uint256 amount) external;
+
+    function redeem(address to, uint256 amount) external;
+
+    function claimRewards(address to, uint256 amount) external;
+
+    function getExchangeRate() external view returns (uint216);
+
+    function previewStake(uint256 assets) external view returns (uint256);
+
+    function previewRedeem(uint256 shares) external view returns (uint256);
+}

package/contracts/interfaces/Angle/IAngleDistributor.sol

@@ -0,0 +1,12 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+pragma solidity ^0.8.0;
+
+interface IAngleDistributor {
+    function claim(
+        address[] calldata users,
+        address[] calldata tokens,
+        uint256[] calldata amounts,
+        bytes32[][] calldata proofs
+    ) external;
+}

package/contracts/interfaces/IPActionAddRemoveLiqV3.sol

@@ -29,7 +29,7 @@ interface IPActionAddRemoveLiqV3 is IPAllEventsV3 {
         uint256 netPtIn,
         uint256 minLpOut,
         ApproxParams calldata guessPtSwapToSy,
-        LimitOrderData calldata limit
+        LimitOrderData memory limit
     ) external returns (uint256 netLpOut, uint256 netSyFee);
 
     function addLiquiditySingleToken(
@@ -38,7 +38,7 @@ interface IPActionAddRemoveLiqV3 is IPAllEventsV3 {
         uint256 minLpOut,
         ApproxParams calldata guessPtReceivedFromSy,
         TokenInput calldata input,
-        LimitOrderData calldata limit
+        LimitOrderData memory limit
     ) external payable returns (uint256 netLpOut, uint256 netSyFee, uint256 netSyInterm);
 
     function addLiquiditySingleSy(
@@ -47,7 +47,7 @@ interface IPActionAddRemoveLiqV3 is IPAllEventsV3 {
         uint256 netSyIn,
         uint256 minLpOut,
         ApproxParams calldata guessPtReceivedFromSy,
-        LimitOrderData calldata limit
+        LimitOrderData memory limit
     ) external returns (uint256 netLpOut, uint256 netSyFee);
 
     function addLiquiditySingleTokenKeepYt(
@@ -88,7 +88,7 @@ interface IPActionAddRemoveLiqV3 is IPAllEventsV3 {
         uint256 netLpToRemove,
         uint256 minPtOut,
         ApproxParams calldata guessPtReceivedFromSy,
-        LimitOrderData calldata limit
+        LimitOrderData memory limit
     ) external returns (uint256 netPtOut, uint256 netSyFee);
 
     function removeLiquiditySingleToken(
@@ -96,7 +96,7 @@ interface IPActionAddRemoveLiqV3 is IPAllEventsV3 {
         address market,
         uint256 netLpToRemove,
         TokenOutput calldata output,
-        LimitOrderData calldata limit
+        LimitOrderData memory limit
     ) external returns (uint256 netTokenOut, uint256 netSyFee, uint256 netSyInterm);
 
     function removeLiquiditySingleSy(
@@ -104,6 +104,6 @@ interface IPActionAddRemoveLiqV3 is IPAllEventsV3 {
         address market,
         uint256 netLpToRemove,
         uint256 minSyOut,
-        LimitOrderData calldata limit
+        LimitOrderData memory limit
     ) external returns (uint256 netSyOut, uint256 netSyFee);
 }

package/contracts/interfaces/IPActionMarketCoreStatic.sol

@@ -1,6 +1,8 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity ^0.8.0;
 
+import "./IPMarket.sol";
+
 interface IPActionMarketCoreStatic {
     function addLiquidityDualSyAndPtStatic(
         address market,
@@ -288,4 +290,6 @@ interface IPActionMarketCoreStatic {
         address market,
         uint256 exactSyOut
     ) external view returns (uint256 netYtIn, uint256 netSyFee, uint256 priceImpact, uint256 exchangeRateAfter);
+
+    function readMarketState(address market) external view returns (MarketState memory);
 }

package/contracts/interfaces/IPActionMiscV3.sol

@@ -82,12 +82,6 @@ interface IPActionMiscV3 is IPAllEventsV3 {
         uint256[] calldata netSwaps
     ) external payable returns (uint256[] memory netOutFromSwaps);
 
-    function swapTokenToToken(
-        address receiver,
-        uint256 minTokenOut,
-        TokenInput calldata inp
-    ) external payable returns (uint256 netTokenOut);
-
     function swapTokenToTokenViaSy(
         address receiver,
         address SY,
@@ -103,7 +97,7 @@ interface IPActionMiscV3 is IPAllEventsV3 {
         uint256 netYtIn,
         uint256 netLpIn,
         TokenOutput calldata output,
-        LimitOrderData calldata limit
+        LimitOrderData memory limit
     ) external returns (uint256 netTokenOut, ExitPreExpReturnParams memory params);
 
     function exitPreExpToSy(
@@ -113,7 +107,7 @@ interface IPActionMiscV3 is IPAllEventsV3 {
         uint256 netYtIn,
         uint256 netLpIn,
         uint256 minSyOut,
-        LimitOrderData calldata limit
+        LimitOrderData memory limit
     ) external returns (ExitPreExpReturnParams memory params);
 
     function exitPostExpToToken(

package/contracts/interfaces/IPActionSwapLimitV3.sol

@@ -0,0 +1,42 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.0;
+
+import "../router/math/MarketApproxLib.sol";
+import "./IPAllActionTypeV3.sol";
+import {IPAllEventsV3} from "./IPAllEventsV3.sol";
+
+interface IPActionSwapLimitV3 is IPAllEventsV3 {
+    function swapMaxPtForTokenLimitOnly(
+        address receiver,
+        address market,
+        uint256 maxPtIn,
+        uint256 minTokenPtRate,
+        TokenOutput calldata output,
+        LimitOrderData memory limit
+    ) external returns (uint256 netTokenOut, uint256 netPtReturned, uint256 netSyFee, uint256 netSyInterm);
+
+    function swapMaxPtForSyLimitOnly(
+        address receiver,
+        address market,
+        uint256 maxPtIn,
+        uint256 minSyPtRate,
+        LimitOrderData memory limit
+    ) external returns (uint256 netSyOut, uint256 netPtReturned, uint256 netSyFee);
+
+    function swapMaxTokenForYtLimitOnly(
+        address receiver,
+        address market,
+        uint256 minSyInterm,
+        uint256 minYtSyRate,
+        TokenInput calldata input,
+        LimitOrderData memory limit
+    ) external payable returns (uint256 netYtOut, uint256 netSyReturned, uint256 netSyFee, uint256 netSyInterm);
+
+    function swapMaxSyForYtLimitOnly(
+        address receiver,
+        address market,
+        uint256 maxSyIn,
+        uint256 minYtSyRate,
+        LimitOrderData memory limit
+    ) external returns (uint256 netYtOut, uint256 netSyReturned, uint256 netSyFee);
+}

package/contracts/interfaces/IPActionSwapPTV3.sol

@@ -13,7 +13,7 @@ interface IPActionSwapPTV3 is IPAllEventsV3 {
         uint256 minPtOut,
         ApproxParams calldata guessPtOut,
         TokenInput calldata input,
-        LimitOrderData calldata limit
+        LimitOrderData memory limit
     ) external payable returns (uint256 netPtOut, uint256 netSyFee, uint256 netSyInterm);
 
     function swapExactSyForPt(
@@ -22,7 +22,7 @@ interface IPActionSwapPTV3 is IPAllEventsV3 {
         uint256 exactSyIn,
         uint256 minPtOut,
         ApproxParams calldata guessPtOut,
-        LimitOrderData calldata limit
+        LimitOrderData memory limit
     ) external returns (uint256 netPtOut, uint256 netSyFee);
 
     function swapExactPtForToken(
@@ -30,7 +30,7 @@ interface IPActionSwapPTV3 is IPAllEventsV3 {
         address market,
         uint256 exactPtIn,
         TokenOutput calldata output,
-        LimitOrderData calldata limit
+        LimitOrderData memory limit
     ) external returns (uint256 netTokenOut, uint256 netSyFee, uint256 netSyInterm);
 
     function swapExactPtForSy(
@@ -38,6 +38,6 @@ interface IPActionSwapPTV3 is IPAllEventsV3 {
         address market,
         uint256 exactPtIn,
         uint256 minSyOut,
-        LimitOrderData calldata limit
+        LimitOrderData memory limit
     ) external returns (uint256 netSyOut, uint256 netSyFee);
 }

package/contracts/interfaces/IPActionSwapYTV3.sol

@@ -13,7 +13,7 @@ interface IPActionSwapYTV3 is IPAllEventsV3 {
         uint256 minYtOut,
         ApproxParams calldata guessYtOut,
         TokenInput calldata input,
-        LimitOrderData calldata limit
+        LimitOrderData memory limit
     ) external payable returns (uint256 netYtOut, uint256 netSyFee, uint256 netSyInterm);
 
     function swapExactSyForYt(
@@ -22,7 +22,7 @@ interface IPActionSwapYTV3 is IPAllEventsV3 {
         uint256 exactSyIn,
         uint256 minYtOut,
         ApproxParams calldata guessYtOut,
-        LimitOrderData calldata limit
+        LimitOrderData memory limit
     ) external returns (uint256 netYtOut, uint256 netSyFee);
 
     function swapExactYtForToken(
@@ -30,7 +30,7 @@ interface IPActionSwapYTV3 is IPAllEventsV3 {
         address market,
         uint256 exactYtIn,
         TokenOutput calldata output,
-        LimitOrderData calldata limit
+        LimitOrderData memory limit
     ) external returns (uint256 netTokenOut, uint256 netSyFee, uint256 netSyInterm);
 
     function swapExactYtForSy(
@@ -38,7 +38,7 @@ interface IPActionSwapYTV3 is IPAllEventsV3 {
         address market,
         uint256 exactYtIn,
         uint256 minSyOut,
-        LimitOrderData calldata limit
+        LimitOrderData memory limit
     ) external returns (uint256 netSyOut, uint256 netSyFee);
 
     function swapExactPtForYt(

package/contracts/interfaces/IPAllActionTypeV3.sol

@@ -104,6 +104,10 @@ struct LimitOrderData {
     bytes optData;
 }
 
+struct LimitOrder_OptData_V1 {
+    uint256 netOffchain;
+}
+
 struct ApproxParams {
     uint256 guessMin;
     uint256 guessMax;

package/contracts/interfaces/IPAllActionV3.sol

@@ -9,6 +9,7 @@ import "./IPActionMiscV3.sol";
 import "./IPActionCallbackV3.sol";
 import "./IPActionStorageV4.sol";
 import "./IPActionSimple.sol";
+import "./IPActionSwapLimitV3.sol";
 
 interface IPAllActionV3 is
     IPActionAddRemoveLiqV3,
@@ -17,5 +18,6 @@ interface IPAllActionV3 is
     IPActionMiscV3,
     IPActionCallbackV3,
     IPActionStorageV4,
-    IPActionSimple
+    IPActionSimple,
+    IPActionSwapLimitV3
 {}

package/contracts/interfaces/IPAllEventsV3.sol

@@ -265,10 +265,53 @@ interface IPActionStorageEvents {
     event SelectorToFacetSet(bytes4 indexed selector, address indexed facet);
 }
 
+interface IPActionSwapLimitV3Events {
+    event SwapMaxPtForTokenLimitOnly(
+        address indexed caller,
+        address indexed market,
+        address indexed token,
+        address receiver,
+        uint256 maxPtIn,
+        uint256 netTokenOut,
+        uint256 netSyInterm,
+        uint256 netPtReturned
+    );
+
+    event SwapMaxPtForSyLimitOnly(
+        address indexed caller,
+        address indexed market,
+        address indexed receiver,
+        uint256 maxPtIn,
+        uint256 netSyOut,
+        uint256 netPtReturned
+    );
+
+    event SwapMaxTokenForYtLimitOnly(
+        address indexed caller,
+        address indexed market,
+        address indexed token,
+        address receiver,
+        uint256 maxTokenIn,
+        uint256 netYtOut,
+        uint256 netSyInterm,
+        uint256 netSyReturned
+    );
+
+    event SwapMaxSyForYtLimitOnly(
+        address indexed caller,
+        address indexed market,
+        address indexed receiver,
+        uint256 maxSyIn,
+        uint256 netYtOut,
+        uint256 netSyReturned
+    );
+}
+
 interface IPAllEventsV3 is
     IPActionAddRemoveLiqV3Events,
     IPActionSwapPTV3Events,
     IPActionSwapYTV3Events,
     IPActionMiscV3Events,
-    IPActionStorageEvents
+    IPActionStorageEvents,
+    IPActionSwapLimitV3Events
 {}

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

@@ -254,4 +254,9 @@ library SDKErrorsDirectory {
     error InvalidTimestamp();
     error InvalidWithdrawalFee();
     error InvalidTotalSupply();
+    error OperationNotAllowed();
+    error WOMBAT_COV_RATIO_LIMIT_EXCEEDED();
+    error NotEnoughLiquidity();
+    error InvalidAmountToDeposit();
+    error TellerWithMultiAssetSupport__AssetNotSupported();
 }

package/contracts/offchain-helpers/router-static/base/ActionInfoStatic.sol

@@ -70,7 +70,7 @@ contract ActionInfoStatic is IPActionInfoStatic {
 
     function getUserMarketInfo(address market, address user) external returns (UserMarketInfo memory res) {
         IPMarket _market = IPMarket(market);
-        MarketState memory state = _market.readState(address(this));
+        MarketState memory state = IPRouterStatic(address(this)).readMarketState(market);
 
         if (uint256(state.totalLp) == 0) return res; // market not initialized
 

package/contracts/offchain-helpers/router-static/base/ActionMarketAuxStatic.sol

@@ -342,7 +342,7 @@ contract ActionMarketAuxStatic is IPActionMarketAuxStatic {
     }
 
     function _readState(address market) internal view returns (MarketState memory) {
-        return IPMarket(market).readState(address(this));
+        return IPRouterStatic(address(this)).readMarketState(market);
     }
 
     function _readTokens(

package/contracts/offchain-helpers/router-static/base/ActionMarketCoreStatic.sol

@@ -18,6 +18,8 @@ contract ActionMarketCoreStatic is StorageLayout, IPActionMarketCoreStatic {
 
     // ============ ADD REMOVE LIQUIDITY ============
 
+    address internal constant ROUTER_V4 = 0x888888888889758F76e7103c6CbF23ABbF58F946;
+
     function addLiquidityDualSyAndPtStatic(
         address market,
         uint256 netSyDesired,
@@ -625,6 +627,14 @@ contract ActionMarketCoreStatic is StorageLayout, IPActionMarketCoreStatic {
         exchangeRateAfter = _getTradeExchangeRateExcludeFee(market, state);
     }
 
+    function readMarketState(address market) public view returns (MarketState memory) {
+        return _readState(market);
+    }
+
+    function _readState(address market) internal view returns (MarketState memory) {
+        return IPMarket(market).readState(ROUTER_V4);
+    }
+
     function _calcPriceImpactPY(address market, int256 netPtOut) internal view returns (uint256) {
         return IPRouterStatic(address(this)).calcPriceImpactPY(market, netPtOut);
     }
@@ -657,10 +667,6 @@ contract ActionMarketCoreStatic is StorageLayout, IPActionMarketCoreStatic {
         return IPRouterStatic(address(this)).getTradeExchangeRateExcludeFee(market, state);
     }
 
-    function _readState(address market) internal view returns (MarketState memory) {
-        return IPMarket(market).readState(address(this));
-    }
-
     function _pyIndex(address market) private view returns (PYIndex) {
         return PYIndex.wrap(IPRouterStatic(address(this)).pyIndexCurrentViewMarket(market));
     }