@pendle/core-v2 2.29.0 → 3.0.0-beta-1

package/contracts/core/StandardizedYield/implementations/Stader/PendleETHXSY.sol

@@ -0,0 +1,110 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+import "../../SYBase.sol";
+import "../../../libraries/ArrayLib.sol";
+import "../../../../interfaces/Stader/IStaderStakeManager.sol";
+
+contract PendleETHXSY is SYBase {
+    using PMath for uint256;
+
+    error StaderMaxDepositExceed(uint256 amountToDeposit, uint256 maxDeposit);
+    error StaderMinDepositUnreached(uint256 amountToDeposit, uint256 minDeposit);
+
+    address public immutable stakeManager;
+    address public immutable ethx;
+
+    constructor(
+        address _stakeManager,
+        address _ethx
+    ) SYBase("SY Stader Staking ETHx", "SY-ETHx", _ethx) {
+        stakeManager = _stakeManager;
+        ethx = _ethx;
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                    DEPOSIT/REDEEM USING BASE TOKENS
+    //////////////////////////////////////////////////////////////*/
+
+    function _deposit(
+        address tokenIn,
+        uint256 amountDeposited
+    ) internal virtual override returns (uint256 /*amountSharesOut*/) {
+        if (tokenIn == NATIVE) {
+            return
+                IStaderStakeManager(stakeManager).deposit{ value: amountDeposited }(address(this));
+        } else {
+            return amountDeposited;
+        }
+    }
+
+    function _redeem(
+        address receiver,
+        address /*tokenOut*/,
+        uint256 amountSharesToRedeem
+    ) internal virtual override returns (uint256 /*amountTokenOut*/) {
+        _transferOut(ethx, receiver, amountSharesToRedeem);
+        return amountSharesToRedeem;
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                               EXCHANGE-RATE
+    //////////////////////////////////////////////////////////////*/
+
+    function exchangeRate() public view virtual override returns (uint256) {
+        return IStaderStakeManager(stakeManager).getExchangeRate();
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                MISC FUNCTIONS FOR METADATA
+    //////////////////////////////////////////////////////////////*/
+
+    function _previewDeposit(
+        address tokenIn,
+        uint256 amountTokenToDeposit
+    ) internal view override returns (uint256 /*amountSharesOut*/) {
+        if (tokenIn == NATIVE) {
+            uint256 maxDeposit = IStaderStakeManager(stakeManager).maxDeposit();
+            uint256 minDeposit = IStaderStakeManager(stakeManager).minDeposit();
+            if (amountTokenToDeposit > maxDeposit) {
+                revert StaderMaxDepositExceed(amountTokenToDeposit, maxDeposit);
+            }
+            if (amountTokenToDeposit < minDeposit) {
+                revert StaderMinDepositUnreached(amountTokenToDeposit, minDeposit);
+            }
+            return IStaderStakeManager(stakeManager).previewDeposit(amountTokenToDeposit);
+        } else {
+            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(NATIVE, ethx);
+    }
+
+    function getTokensOut() public view virtual override returns (address[] memory) {
+        return ArrayLib.create(ethx);
+    }
+
+    function isValidTokenIn(address token) public view virtual override returns (bool) {
+        return token == ethx || token == NATIVE;
+    }
+
+    function isValidTokenOut(address token) public view virtual override returns (bool) {
+        return token == ethx;
+    }
+
+    function assetInfo()
+        external
+        pure
+        returns (AssetType assetType, address assetAddress, uint8 assetDecimals)
+    {
+        return (AssetType.TOKEN, NATIVE, 18);
+    }
+}

package/contracts/core/libraries/ArrayLib.sol

@@ -39,6 +39,7 @@ library ArrayLib {
         }
         out[length] = element;
     }
+
     /**
      * @dev This function assumes a and b each contains unidentical elements
      * @param a array of addresses a
@@ -52,7 +53,7 @@ library ArrayLib {
         unchecked {
             uint256 countUnidenticalB = 0;
             bool[] memory isUnidentical = new bool[](b.length);
-            for(uint256 i = 0; i < b.length; ++i) {
+            for (uint256 i = 0; i < b.length; ++i) {
                 if (!contains(a, b[i])) {
                     countUnidenticalB++;
                     isUnidentical[i] = true;
@@ -60,11 +61,11 @@ library ArrayLib {
             }
 
             out = new address[](a.length + countUnidenticalB);
-            for(uint256 i = 0; i < a.length; ++i) {
+            for (uint256 i = 0; i < a.length; ++i) {
                 out[i] = a[i];
             }
             uint256 id = a.length;
-            for(uint256 i = 0; i < b.length; ++i) {
+            for (uint256 i = 0; i < b.length; ++i) {
                 if (isUnidentical[i]) {
                     out[id++] = b[i];
                 }

package/contracts/core/libraries/Errors.sol

@@ -2,27 +2,11 @@
 pragma solidity ^0.8.0;
 
 library Errors {
-    // BulkSeller
-    error BulkInsufficientSyForTrade(uint256 currentAmount, uint256 requiredAmount);
-    error BulkInsufficientTokenForTrade(uint256 currentAmount, uint256 requiredAmount);
-    error BulkInSufficientSyOut(uint256 actualSyOut, uint256 requiredSyOut);
-    error BulkInSufficientTokenOut(uint256 actualTokenOut, uint256 requiredTokenOut);
-    error BulkInsufficientSyReceived(uint256 actualBalance, uint256 requiredBalance);
-    error BulkNotMaintainer();
-    error BulkNotAdmin();
-    error BulkSellerAlreadyExisted(address token, address SY, address bulk);
-    error BulkSellerInvalidToken(address token, address SY);
-    error BulkBadRateTokenToSy(uint256 actualRate, uint256 currentRate, uint256 eps);
-    error BulkBadRateSyToToken(uint256 actualRate, uint256 currentRate, uint256 eps);
-
     // APPROX
     error ApproxFail();
     error ApproxParamsInvalid(uint256 guessMin, uint256 guessMax, uint256 eps);
     error ApproxBinarySearchInputInvalid(
-        uint256 approxGuessMin,
-        uint256 approxGuessMax,
-        uint256 minGuessMin,
-        uint256 maxGuessMax
+        uint256 approxGuessMin, uint256 approxGuessMax, uint256 minGuessMin, uint256 maxGuessMax
     );
 
     // MARKET + MARKET MATH CORE
@@ -49,10 +33,7 @@ library Errors {
     error MarketFactoryMarketExists();
 
     error MarketFactoryLnFeeRateRootTooHigh(uint80 lnFeeRateRoot, uint256 maxLnFeeRateRoot);
-    error MarketFactoryReserveFeePercentTooHigh(
-        uint8 reserveFeePercent,
-        uint8 maxReserveFeePercent
-    );
+    error MarketFactoryReserveFeePercentTooHigh(uint8 reserveFeePercent, uint8 maxReserveFeePercent);
     error MarketFactoryZeroTreasury();
     error MarketFactoryInitialAnchorTooLow(int256 initialAnchor, int256 minInitialAnchor);
 
@@ -77,6 +58,8 @@ library Errors {
 
     error RouterKyberSwapDataZero();
 
+    error CallThenRevertError(bool success, bytes res);
+
     // YIELD CONTRACT
     error YCExpired();
     error YCNotExpired();

package/contracts/core/libraries/TokenHelper.sol

@@ -1,11 +1,13 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity ^0.8.0;
+
 import "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
 import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
 import "../../interfaces/IWETH.sol";
 
 abstract contract TokenHelper {
     using SafeERC20 for IERC20;
+
     address internal constant NATIVE = address(0);
     uint256 internal constant LOWER_BOUND_APPROVAL = type(uint96).max / 2; // some tokens use 96 bits for approval
 
@@ -15,13 +17,13 @@ abstract contract TokenHelper {
     }
 
     function _transferFrom(IERC20 token, address from, address to, uint256 amount) internal {
-        if (amount != 0) token.safeTransferFrom(from, to, amount);
+        if (amount != 0 && from != address(this)) token.safeTransferFrom(from, to, amount);
     }
 
     function _transferOut(address token, address to, uint256 amount) internal {
         if (amount == 0) return;
         if (token == NATIVE) {
-            (bool success, ) = to.call{ value: amount }("");
+            (bool success,) = to.call{value: amount}("");
             require(success, "eth send failed");
         } else {
             IERC20(token).safeTransfer(to, amount);
@@ -31,7 +33,7 @@ abstract contract TokenHelper {
     function _transferOut(address[] memory tokens, address to, uint256[] memory amounts) internal {
         uint256 numTokens = tokens.length;
         require(numTokens == amounts.length, "length mismatch");
-        for (uint256 i = 0; i < numTokens; ) {
+        for (uint256 i = 0; i < numTokens;) {
             _transferOut(tokens[i], to, amounts[i]);
             unchecked {
                 i++;
@@ -50,9 +52,7 @@ abstract contract TokenHelper {
     /// @notice Approves the stipulated contract to spend the given allowance in the given token
     /// @dev PLS PAY ATTENTION to tokens that requires the approval to be set to 0 before changing it
     function _safeApprove(address token, address to, uint256 value) internal {
-        (bool success, bytes memory data) = token.call(
-            abi.encodeWithSelector(IERC20.approve.selector, to, value)
-        );
+        (bool success, bytes memory data) = token.call(abi.encodeWithSelector(IERC20.approve.selector, to, value));
         require(success && (data.length == 0 || abi.decode(data, (bool))), "Safe Approve");
     }
 
@@ -65,7 +65,7 @@ abstract contract TokenHelper {
     }
 
     function _wrap_unwrap_ETH(address tokenIn, address tokenOut, uint256 netTokenIn) internal {
-        if (tokenIn == NATIVE) IWETH(tokenOut).deposit{ value: netTokenIn }();
+        if (tokenIn == NATIVE) IWETH(tokenOut).deposit{value: netTokenIn}();
         else IWETH(tokenIn).withdraw(netTokenIn);
     }
 }

package/contracts/interfaces/IDailLikePermit.sol

@@ -0,0 +1,17 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.0;
+
+/// @title Interface for DAI-style permits
+interface IDaiLikePermit {
+    function permit(
+        address holder,
+        address spender,
+        uint256 nonce,
+        uint256 expiry,
+        bool allowed,
+        uint8 v,
+        bytes32 r,
+        bytes32 s
+    ) external;
+}

package/contracts/interfaces/IPActionAddRemoveLiq.sol

@@ -2,7 +2,7 @@
 pragma solidity ^0.8.0;
 
 import "../router/base/MarketApproxLib.sol";
-import "../router/base/ActionBaseMintRedeem.sol";
+import "./IPAllActionType.sol";
 
 interface IPActionAddRemoveLiq {
     event AddLiquidityDualSyAndPt(
@@ -25,19 +25,11 @@ interface IPActionAddRemoveLiq {
     );
 
     event AddLiquiditySinglePt(
-        address indexed caller,
-        address indexed market,
-        address indexed receiver,
-        uint256 netPtIn,
-        uint256 netLpOut
+        address indexed caller, address indexed market, address indexed receiver, uint256 netPtIn, uint256 netLpOut
     );
 
     event AddLiquiditySingleSy(
-        address indexed caller,
-        address indexed market,
-        address indexed receiver,
-        uint256 netSyIn,
-        uint256 netLpOut
+        address indexed caller, address indexed market, address indexed receiver, uint256 netSyIn, uint256 netLpOut
     );
 
     event AddLiquiditySingleToken(
@@ -126,14 +118,15 @@ interface IPActionAddRemoveLiq {
         TokenInput calldata input,
         uint256 netPtDesired,
         uint256 minLpOut
-    ) external payable returns (uint256 netLpOut, uint256 netTokenUsed, uint256 netPtUsed);
+    ) external payable returns (uint256 netLpOut, uint256 netPtUsed);
 
     function addLiquiditySinglePt(
         address receiver,
         address market,
         uint256 netPtIn,
         uint256 minLpOut,
-        ApproxParams calldata guessPtSwapToSy
+        ApproxParams calldata guessPtSwapToSy,
+        LimitOrderData calldata limit
     ) external returns (uint256 netLpOut, uint256 netSyFee);
 
     function addLiquiditySingleSy(
@@ -141,7 +134,8 @@ interface IPActionAddRemoveLiq {
         address market,
         uint256 netSyIn,
         uint256 minLpOut,
-        ApproxParams calldata guessPtReceivedFromSy
+        ApproxParams calldata guessPtReceivedFromSy,
+        LimitOrderData calldata limit
     ) external returns (uint256 netLpOut, uint256 netSyFee);
 
     function addLiquiditySingleToken(
@@ -149,7 +143,8 @@ interface IPActionAddRemoveLiq {
         address market,
         uint256 minLpOut,
         ApproxParams calldata guessPtReceivedFromSy,
-        TokenInput calldata input
+        TokenInput calldata input,
+        LimitOrderData calldata limit
     ) external payable returns (uint256 netLpOut, uint256 netSyFee);
 
     function addLiquiditySingleSyKeepYt(
@@ -189,20 +184,23 @@ interface IPActionAddRemoveLiq {
         address market,
         uint256 netLpToRemove,
         uint256 minPtOut,
-        ApproxParams calldata guessPtOut
+        ApproxParams calldata guessPtOut,
+        LimitOrderData calldata limit
     ) external returns (uint256 netPtOut, uint256 netSyFee);
 
     function removeLiquiditySingleSy(
         address receiver,
         address market,
         uint256 netLpToRemove,
-        uint256 minSyOut
+        uint256 minSyOut,
+        LimitOrderData calldata limit
     ) external returns (uint256 netSyOut, uint256 netSyFee);
 
     function removeLiquiditySingleToken(
         address receiver,
         address market,
         uint256 netLpToRemove,
-        TokenOutput calldata output
+        TokenOutput calldata output,
+        LimitOrderData calldata limit
     ) external returns (uint256 netTokenOut, uint256 netSyFee);
 }

package/contracts/interfaces/IPActionMarketCoreStatic.sol

@@ -2,35 +2,20 @@
 pragma solidity ^0.8.0;
 
 interface IPActionMarketCoreStatic {
-    function addLiquidityDualSyAndPtStatic(
-        address market,
-        uint256 netSyDesired,
-        uint256 netPtDesired
-    )
+    function addLiquidityDualSyAndPtStatic(address market, uint256 netSyDesired, uint256 netPtDesired)
         external
         view
-        returns (
-            uint256 netLpOut,
-            uint256 netSyUsed,
-            uint256 netPtUsed
-        );
+        returns (uint256 netLpOut, uint256 netSyUsed, uint256 netPtUsed);
 
     function addLiquidityDualTokenAndPtStatic(
         address market,
         address tokenIn,
         uint256 netTokenDesired,
-        address bulk,
         uint256 netPtDesired
     )
         external
         view
-        returns (
-            uint256 netLpOut,
-            uint256 netTokenUsed,
-            uint256 netPtUsed,
-            uint256 netSyUsed,
-            uint256 netSyDesired
-        );
+        returns (uint256 netLpOut, uint256 netTokenUsed, uint256 netPtUsed, uint256 netSyUsed, uint256 netSyDesired);
 
     function addLiquiditySinglePtStatic(address market, uint256 netPtIn)
         external
@@ -47,11 +32,7 @@ interface IPActionMarketCoreStatic {
     function addLiquiditySingleSyKeepYtStatic(address market, uint256 netSyIn)
         external
         view
-        returns (
-            uint256 netLpOut,
-            uint256 netYtOut,
-            uint256 netSyToPY
-        );
+        returns (uint256 netLpOut, uint256 netYtOut, uint256 netSyToPY);
 
     function addLiquiditySingleSyStatic(address market, uint256 netSyIn)
         external
@@ -65,27 +46,12 @@ interface IPActionMarketCoreStatic {
             uint256 netSyToSwap
         );
 
-    function addLiquiditySingleTokenKeepYtStatic(
-        address market,
-        address tokenIn,
-        uint256 netTokenIn,
-        address bulk
-    )
+    function addLiquiditySingleTokenKeepYtStatic(address market, address tokenIn, uint256 netTokenIn)
         external
         view
-        returns (
-            uint256 netLpOut,
-            uint256 netYtOut,
-            uint256 netSyMinted,
-            uint256 netSyToPY
-        );
+        returns (uint256 netLpOut, uint256 netYtOut, uint256 netSyMinted, uint256 netSyToPY);
 
-    function addLiquiditySingleTokenStatic(
-        address market,
-        address tokenIn,
-        uint256 netTokenIn,
-        address bulk
-    )
+    function addLiquiditySingleTokenStatic(address market, address tokenIn, uint256 netTokenIn)
         external
         view
         returns (
@@ -103,19 +69,10 @@ interface IPActionMarketCoreStatic {
         view
         returns (uint256 netSyOut, uint256 netPtOut);
 
-    function removeLiquidityDualTokenAndPtStatic(
-        address market,
-        uint256 netLpToRemove,
-        address tokenOut,
-        address bulk
-    )
+    function removeLiquidityDualTokenAndPtStatic(address market, uint256 netLpToRemove, address tokenOut)
         external
         view
-        returns (
-            uint256 netTokenOut,
-            uint256 netPtOut,
-            uint256 netSyToRedeem
-        );
+        returns (uint256 netTokenOut, uint256 netPtOut, uint256 netSyToRedeem);
 
     function removeLiquiditySinglePtStatic(address market, uint256 netLpToRemove)
         external
@@ -143,12 +100,7 @@ interface IPActionMarketCoreStatic {
             uint256 netSyFromSwap
         );
 
-    function removeLiquiditySingleTokenStatic(
-        address market,
-        uint256 netLpToRemove,
-        address tokenOut,
-        address bulk
-    )
+    function removeLiquiditySingleTokenStatic(address market, uint256 netLpToRemove, address tokenOut)
         external
         view
         returns (
@@ -165,19 +117,9 @@ interface IPActionMarketCoreStatic {
     function swapExactPtForSyStatic(address market, uint256 exactPtIn)
         external
         view
-        returns (
-            uint256 netSyOut,
-            uint256 netSyFee,
-            uint256 priceImpact,
-            uint256 exchangeRateAfter
-        );
+        returns (uint256 netSyOut, uint256 netSyFee, uint256 priceImpact, uint256 exchangeRateAfter);
 
-    function swapExactPtForTokenStatic(
-        address market,
-        uint256 exactPtIn,
-        address tokenOut,
-        address bulk
-    )
+    function swapExactPtForTokenStatic(address market, uint256 exactPtIn, address tokenOut)
         external
         view
         returns (
@@ -202,29 +144,14 @@ interface IPActionMarketCoreStatic {
     function swapExactSyForPtStatic(address market, uint256 exactSyIn)
         external
         view
-        returns (
-            uint256 netPtOut,
-            uint256 netSyFee,
-            uint256 priceImpact,
-            uint256 exchangeRateAfter
-        );
+        returns (uint256 netPtOut, uint256 netSyFee, uint256 priceImpact, uint256 exchangeRateAfter);
 
     function swapExactSyForYtStatic(address market, uint256 exactSyIn)
         external
         view
-        returns (
-            uint256 netYtOut,
-            uint256 netSyFee,
-            uint256 priceImpact,
-            uint256 exchangeRateAfter
-        );
+        returns (uint256 netYtOut, uint256 netSyFee, uint256 priceImpact, uint256 exchangeRateAfter);
 
-    function swapExactTokenForPtStatic(
-        address market,
-        address tokenIn,
-        uint256 amountTokenIn,
-        address bulk
-    )
+    function swapExactTokenForPtStatic(address market, address tokenIn, uint256 amountTokenIn)
         external
         view
         returns (
@@ -235,12 +162,7 @@ interface IPActionMarketCoreStatic {
             uint256 exchangeRateAfter
         );
 
-    function swapExactTokenForYtStatic(
-        address market,
-        address tokenIn,
-        uint256 amountTokenIn,
-        address bulk
-    )
+    function swapExactTokenForYtStatic(address market, address tokenIn, uint256 amountTokenIn)
         external
         view
         returns (
@@ -275,12 +197,7 @@ interface IPActionMarketCoreStatic {
             uint256 netPYToRedeemSyOutInt
         );
 
-    function swapExactYtForTokenStatic(
-        address market,
-        uint256 exactYtIn,
-        address tokenOut,
-        address bulk
-    )
+    function swapExactYtForTokenStatic(address market, uint256 exactYtIn, address tokenOut)
         external
         view
         returns (
@@ -297,22 +214,12 @@ interface IPActionMarketCoreStatic {
     function swapPtForExactSyStatic(address market, uint256 exactSyOut)
         external
         view
-        returns (
-            uint256 netPtIn,
-            uint256 netSyFee,
-            uint256 priceImpact,
-            uint256 exchangeRateAfter
-        );
+        returns (uint256 netPtIn, uint256 netSyFee, uint256 priceImpact, uint256 exchangeRateAfter);
 
     function swapSyForExactPtStatic(address market, uint256 exactPtOut)
         external
         view
-        returns (
-            uint256 netSyIn,
-            uint256 netSyFee,
-            uint256 priceImpact,
-            uint256 exchangeRateAfter
-        );
+        returns (uint256 netSyIn, uint256 netSyFee, uint256 priceImpact, uint256 exchangeRateAfter);
 
     function swapSyForExactYtStatic(address market, uint256 exactYtOut)
         external
@@ -329,10 +236,5 @@ interface IPActionMarketCoreStatic {
     function swapYtForExactSyStatic(address market, uint256 exactSyOut)
         external
         view
-        returns (
-            uint256 netYtIn,
-            uint256 netSyFee,
-            uint256 priceImpact,
-            uint256 exchangeRateAfter
-        );
+        returns (uint256 netYtIn, uint256 netSyFee, uint256 priceImpact, uint256 exchangeRateAfter);
 }

package/contracts/interfaces/IPActionMintRedeemStatic.sol

@@ -2,64 +2,34 @@
 pragma solidity ^0.8.0;
 
 interface IPActionMintRedeemStatic {
-    function getAmountTokenToMintSy(
-        address SY,
-        address tokenIn,
-        address bulk,
-        uint256 netSyOut
-    ) external view returns (uint256 netTokenIn);
-
-    function getBulkSellerInfo(
-        address token,
-        address SY,
-        uint256 netTokenIn,
-        uint256 netSyIn
-    )
+    function getAmountTokenToMintSy(address SY, address tokenIn, uint256 netSyOut)
         external
         view
-        returns (
-            address bulk,
-            uint256 totalToken,
-            uint256 totalSy
-        );
+        returns (uint256 netTokenIn);
+
+    function mintPyFromSyStatic(address YT, uint256 netSyToMint) external view returns (uint256 netPYOut);
 
-    function mintPyFromSyStatic(address YT, uint256 netSyToMint)
+    function mintPyFromTokenStatic(address YT, address tokenIn, uint256 netTokenIn)
         external
         view
-        returns (uint256 netPYOut);
-
-    function mintPyFromTokenStatic(
-        address YT,
-        address tokenIn,
-        uint256 netTokenIn,
-        address bulk
-    ) external view returns (uint256 netPyOut);
+        returns (uint256 netPyOut);
 
-    function mintSyFromTokenStatic(
-        address SY,
-        address tokenIn,
-        uint256 netTokenIn,
-        address bulk
-    ) external view returns (uint256 netSyOut);
-
-    function redeemPyToSyStatic(address YT, uint256 netPYToRedeem)
+    function mintSyFromTokenStatic(address SY, address tokenIn, uint256 netTokenIn)
         external
         view
         returns (uint256 netSyOut);
 
-    function redeemPyToTokenStatic(
-        address YT,
-        uint256 netPYToRedeem,
-        address tokenOut,
-        address bulk
-    ) external view returns (uint256 netTokenOut);
+    function redeemPyToSyStatic(address YT, uint256 netPYToRedeem) external view returns (uint256 netSyOut);
 
-    function redeemSyToTokenStatic(
-        address SY,
-        address tokenOut,
-        uint256 netSyIn,
-        address bulk
-    ) external view returns (uint256 netTokenOut);
+    function redeemPyToTokenStatic(address YT, uint256 netPYToRedeem, address tokenOut)
+        external
+        view
+        returns (uint256 netTokenOut);
+
+    function redeemSyToTokenStatic(address SY, address tokenOut, uint256 netSyIn)
+        external
+        view
+        returns (uint256 netTokenOut);
 
     function pyIndexCurrentViewMarket(address market) external view returns (uint256);