@pendle/core-v2 5.2.0-beta-5 → 5.2.1-beta-1

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

@@ -0,0 +1,83 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.17;
+
+import "../SYBaseUpg.sol";
+import "../../../interfaces/IERC4626.sol";
+
+contract PendleERC4626SYUpg is SYBaseUpg {
+    using PMath for uint256;
+    address public immutable asset;
+
+    constructor(address _erc4626) SYBaseUpg(_erc4626) {
+        asset = IERC4626(_erc4626).asset();
+        _safeApproveInf(asset, _erc4626);
+    }
+
+    function _deposit(
+        address tokenIn,
+        uint256 amountDeposited
+    ) internal virtual override returns (uint256 /*amountSharesOut*/) {
+        if (tokenIn == yieldToken) {
+            return amountDeposited;
+        } else {
+            return IERC4626(yieldToken).deposit(amountDeposited, address(this));
+        }
+    }
+
+    function _redeem(
+        address receiver,
+        address tokenOut,
+        uint256 amountSharesToRedeem
+    ) internal override returns (uint256 amountTokenOut) {
+        if (tokenOut == yieldToken) {
+            amountTokenOut = amountSharesToRedeem;
+            _transferOut(yieldToken, receiver, amountTokenOut);
+        } else {
+            amountTokenOut = IERC4626(yieldToken).redeem(amountSharesToRedeem, receiver, address(this));
+        }
+    }
+
+    function exchangeRate() public view virtual override returns (uint256) {
+        return IERC4626(yieldToken).convertToAssets(PMath.ONE);
+    }
+
+    function _previewDeposit(
+        address tokenIn,
+        uint256 amountTokenToDeposit
+    ) internal view override returns (uint256 /*amountSharesOut*/) {
+        if (tokenIn == yieldToken) return amountTokenToDeposit;
+        else return IERC4626(yieldToken).previewDeposit(amountTokenToDeposit);
+    }
+
+    function _previewRedeem(
+        address tokenOut,
+        uint256 amountSharesToRedeem
+    ) internal view override returns (uint256 /*amountTokenOut*/) {
+        if (tokenOut == yieldToken) return amountSharesToRedeem;
+        else return IERC4626(yieldToken).previewRedeem(amountSharesToRedeem);
+    }
+
+    function getTokensIn() public view override returns (address[] memory res) {
+        res = new address[](2);
+        res[0] = asset;
+        res[1] = yieldToken;
+    }
+
+    function getTokensOut() public view override returns (address[] memory res) {
+        res = new address[](2);
+        res[0] = asset;
+        res[1] = yieldToken;
+    }
+
+    function isValidTokenIn(address token) public view override returns (bool) {
+        return token == yieldToken || token == asset;
+    }
+
+    function isValidTokenOut(address token) public view override returns (bool) {
+        return token == yieldToken || token == asset;
+    }
+
+    function assetInfo() external view returns (AssetType assetType, address assetAddress, uint8 assetDecimals) {
+        return (AssetType.TOKEN, asset, IERC20Metadata(asset).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/core/StandardizedYield/implementations/Solv/PendleSolvBTCBBNBaseSYUpg.sol

@@ -0,0 +1,103 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.17;
+
+import "../../SYBaseUpg.sol";
+import "./PendleSolvHelperBase.sol";
+import "../../../../interfaces/IPExchangeRateOracle.sol";
+
+contract PendleSolvBTCBBNBaseSYUpg is SYBaseUpg {
+    event SetNewExchangeRateOracle(address oracle);
+
+    address public constant CBBTC = PendleSolvHelperBase.CBBTC;
+    address public constant SOLV_BTC = PendleSolvHelperBase.SOLV_BTC_TOKEN;
+    address public constant SOLV_BTCBBN = PendleSolvHelperBase.SOLV_BTCBBN_TOKEN;
+
+    address public exchangeRateOracle;
+
+    constructor() SYBaseUpg(SOLV_BTCBBN) {}
+
+    function initialize(address _initialExchangeRateOracle) external initializer {
+        __SYBaseUpg_init("SY SolvBTC Babylon", "SY-SolvBTC.BBN");
+        _setExchangeRateOracle(_initialExchangeRateOracle);
+        _safeApproveInf(CBBTC, PendleSolvHelperBase.SOLV_BTC_ROUTER);
+        _safeApproveInf(SOLV_BTC, PendleSolvHelperBase.SOLV_BTCBBN_ROUTER);
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                    DEPOSIT/REDEEM USING BASE TOKENS
+    //////////////////////////////////////////////////////////////*/
+
+    function _deposit(address tokenIn, uint256 amountDeposited) internal virtual override returns (uint256) {
+        if (tokenIn == SOLV_BTCBBN) {
+            return amountDeposited;
+        }
+        return PendleSolvHelperBase._mintBTCBBN(tokenIn, amountDeposited);
+    }
+
+    function _redeem(
+        address receiver,
+        address /*tokenOut*/,
+        uint256 amountSharesToRedeem
+    ) internal virtual override returns (uint256) {
+        _transferOut(SOLV_BTCBBN, receiver, amountSharesToRedeem);
+        return amountSharesToRedeem;
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                               EXCHANGE-RATE
+    //////////////////////////////////////////////////////////////*/
+
+    function exchangeRate() public view virtual override returns (uint256) {
+        return IPExchangeRateOracle(exchangeRateOracle).getExchangeRate();
+    }
+
+    function setExchangeRateOracle(address newOracle) external virtual onlyOwner {
+        _setExchangeRateOracle(newOracle);
+    }
+
+    function _setExchangeRateOracle(address newOracle) internal virtual {
+        exchangeRateOracle = newOracle;
+        emit SetNewExchangeRateOracle(newOracle);
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                MISC FUNCTIONS FOR METADATA
+    //////////////////////////////////////////////////////////////*/
+
+    function _previewDeposit(
+        address tokenIn,
+        uint256 amountTokenToDeposit
+    ) internal view virtual override returns (uint256 /*amountSharesOut*/) {
+        if (tokenIn == SOLV_BTCBBN) {
+            return amountTokenToDeposit;
+        }
+        return PendleSolvHelperBase._previewMintBTCBBN(tokenIn, 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) {
+        return ArrayLib.create(CBBTC, SOLV_BTC, SOLV_BTCBBN);
+    }
+
+    function getTokensOut() public view virtual override returns (address[] memory) {
+        return ArrayLib.create(SOLV_BTCBBN);
+    }
+
+    function isValidTokenIn(address token) public view virtual override returns (bool) {
+        return token == CBBTC || token == SOLV_BTC || token == SOLV_BTCBBN;
+    }
+
+    function isValidTokenOut(address token) public view virtual override returns (bool) {
+        return token == SOLV_BTCBBN;
+    }
+
+    function assetInfo() external view returns (AssetType assetType, address assetAddress, uint8 assetDecimals) {
+        return (AssetType.TOKEN, CBBTC, IERC20Metadata(CBBTC).decimals());
+    }
+}

package/contracts/core/StandardizedYield/implementations/Solv/PendleSolvHelperBase.sol

@@ -0,0 +1,47 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.17;
+
+import "../../../../interfaces/Solv/ISolvRouter.sol";
+import "../../../../interfaces/Solv/ISolvOpenFundMarket.sol";
+import "../../../../interfaces/Solv/ISolvOracle.sol";
+import "../../../../interfaces/Solv/ISolvERC3525.sol";
+
+library PendleSolvHelperBase {
+    address public constant SOLV_BTCBBN_ROUTER = 0x814F3ae67dF0da9fe2399a29516FD14b9085263a;
+    address public constant SOLV_BTCBBN_TOKEN = 0xC26C9099BD3789107888c35bb41178079B282561;
+    bytes32 public constant SOLV_BTCBBN_POOLID = 0xb20032ac848893cf4820a7b3259020ffd5057d49f537c2adc5f74a337cc56ddc;
+
+    address public constant SOLV_BTC_ROUTER = 0x65EFfDA5e69dF470d4dBd31a805e15855Cae65c7;
+    address public constant SOLV_BTC_TOKEN = 0x3B86Ad95859b6AB773f55f8d94B4b9d443EE931f;
+    bytes32 public constant SOLV_BTC_POOLID = 0x0d85d41382f6f2effeaa41a46855870ec8b1577c6c59cf16d72856a22988e3f5;
+
+    address public constant CBBTC = 0xcbB7C0000aB88B473b1f5aFd9ef808440eed33Bf;
+
+    address public constant SOLV_OPEN_FUND_MARKET = 0xf5a247157656678398B08d3eFa1673358C611A3f;
+
+    function _mintBTCBBN(address tokenIn, uint256 amountIn) internal returns (uint256) {
+        assert(tokenIn == CBBTC || tokenIn == SOLV_BTC_TOKEN);
+
+        if (tokenIn == CBBTC) {
+            amountIn = ISolvRouter(SOLV_BTC_ROUTER).createSubscription(SOLV_BTC_POOLID, amountIn);
+        }
+        return ISolvRouter(SOLV_BTCBBN_ROUTER).createSubscription(SOLV_BTCBBN_POOLID, amountIn);
+    }
+
+    function _previewMintBTCBBN(address tokenIn, uint256 amountIn) internal view returns (uint256) {
+        assert(tokenIn == CBBTC || tokenIn == SOLV_BTC_TOKEN);
+
+        if (tokenIn == CBBTC) {
+            amountIn = _convertToShare(CBBTC, amountIn);
+        }
+        return _convertToShare(SOLV_BTC_TOKEN, amountIn);
+    }
+
+    function _convertToShare(address tokenIn, uint256 amountIn) internal view returns (uint256) {
+        bytes32 poolId = tokenIn == CBBTC ? SOLV_BTC_POOLID : SOLV_BTCBBN_POOLID;
+        ISolvOpenFundMarket.PoolInfo memory info = ISolvOpenFundMarket(SOLV_OPEN_FUND_MARKET).poolInfos(poolId);
+        uint256 numerator = 10 ** ISolvERC3525(info.poolSFTInfo.openFundShare).valueDecimals();
+        (uint256 price, ) = ISolvOracle(info.navOracle).getSubscribeNav(poolId, block.timestamp);
+        return (amountIn * numerator) / price;
+    }
+}

package/contracts/core/StandardizedYield/implementations/Zerolend/PendleZerolendEBTCSYUpg.sol

@@ -0,0 +1,102 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.23;
+
+import "../AaveV3/PendleAaveV3WithRewardsSYUpg.sol";
+import "../../../../interfaces/IPExchangeRateOracle.sol";
+import "../PendleERC20SYUpg.sol";
+import "../../../../interfaces/EtherFi/IVedaTeller.sol";
+import "../../../../interfaces/EtherFi/IVedaAccountant.sol";
+import "../../../../interfaces/Zerolend/IZerolendPool.sol";
+import "../../../../interfaces/Zerolend/IZerolendZ0Token.sol";
+import "../../../../interfaces/IPTokenWithSupplyCap.sol";
+
+contract PendleZerolendEBTCSYUpg is PendleAaveV3WithRewardsSYUpg {
+    // solhint-disable immutable-vars-naming
+    // solhint-disable const-name-snakecase
+    // solhint-disable ordering
+
+    address public constant Z0EBTC = 0x52bB650211e8a6986287306A4c09B73A9Affd5e9;
+    address public constant ZEROLEND_POOL = 0xCD2b31071119D7eA449a9D211AC8eBF7Ee97F987;
+    address public constant ZEROLEND_INCENTIVE_CONTROLLER = 0x938e23c10C501CE5D42Bc516eCFDf5AbD9C51d2b; // no reward currently, leave as address(0) for gas saving
+    address public constant ZERO = 0x2Da17fAf782ae884faf7dB2208BBC66b6E085C22;
+
+    address public constant eBTC = 0x657e8C867D8B37dCC18fA4Caead9C45EB088C642;
+    address public constant cbBTC = 0xcbB7C0000aB88B473b1f5aFd9ef808440eed33Bf;
+    address public constant wBTC = 0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599;
+    address public constant LBTC = 0x8236a87084f8B84306f72007F36F2618A5634494;
+    address public constant vedaTeller = 0x458797A320e6313c980C2bC7D270466A6288A8bB;
+
+    uint256 public constant ONE_SHARE = 10 ** 8;
+    uint256 public constant PREMIUM_SHARE_BPS = 10 ** 4;
+
+    address public immutable vedaAccountant;
+
+    constructor() PendleAaveV3WithRewardsSYUpg(ZEROLEND_POOL, Z0EBTC, ZEROLEND_INCENTIVE_CONTROLLER, ZERO) {
+        vedaAccountant = IVedaTeller(vedaTeller).accountant();
+    }
+
+    function approveAllForTeller() external {
+        _safeApproveInf(cbBTC, eBTC);
+        _safeApproveInf(wBTC, eBTC);
+        _safeApproveInf(LBTC, eBTC);
+    }
+
+    function _deposit(
+        address tokenIn,
+        uint256 amountDeposited
+    ) internal virtual override returns (uint256 /*amountSharesOut*/) {
+        if (tokenIn != eBTC && tokenIn != aToken) {
+            (tokenIn, amountDeposited) = (
+                eBTC,
+                IVedaTeller(vedaTeller).bulkDeposit(tokenIn, amountDeposited, 0, address(this))
+            );
+        }
+
+        return super._deposit(tokenIn, amountDeposited);
+    }
+
+    function _previewDeposit(
+        address tokenIn,
+        uint256 amountTokenToDeposit
+    ) internal view virtual override returns (uint256) {
+        if (tokenIn != eBTC && tokenIn != aToken) {
+            uint256 rate = IVedaAccountant(vedaAccountant).getRateInQuoteSafe(tokenIn);
+
+            uint256 amountEBTCRaw = (amountTokenToDeposit * ONE_SHARE) / rate;
+            IVedaTeller.Asset memory data = IVedaTeller(vedaTeller).assetData(tokenIn);
+
+            amountTokenToDeposit = (amountEBTCRaw * (PREMIUM_SHARE_BPS - data.sharePremium)) / PREMIUM_SHARE_BPS;
+            tokenIn = eBTC;
+        }
+        return super._previewDeposit(tokenIn, amountTokenToDeposit);
+    }
+
+    function isValidTokenIn(address token) public view override returns (bool) {
+        return token == eBTC || token == wBTC || token == cbBTC || token == LBTC || token == aToken;
+    }
+
+    function getTokensIn() public view override returns (address[] memory res) {
+        return ArrayLib.create(wBTC, cbBTC, eBTC, LBTC, aToken);
+    }
+
+    function assetInfo()
+        external
+        view
+        virtual
+        override
+        returns (AssetType assetType, address assetAddress, uint8 assetDecimals)
+    {
+        return (AssetType.TOKEN, eBTC, IERC20Metadata(eBTC).decimals());
+    }
+
+    function getAbsoluteSupplyCap() external view returns (uint256) {
+        uint256 data = (IZerolendPool(ZEROLEND_POOL).getConfiguration(eBTC)).data;
+        uint256 unscaledSupplyCap = (data &
+            (~uint256(0xFFFFFFFFFFFFFFFFFFFFFFFFFF000000000FFFFFFFFFFFFFFFFFFFFFFFFFFFFF))) >> 116;
+        return unscaledSupplyCap * (10 ** IERC20Metadata(eBTC).decimals());
+    }
+
+    function getAbsoluteTotalSupply() external view returns (uint256) {
+        return IZerolendZ0Token(Z0EBTC).scaledTotalSupply();
+    }
+}

package/contracts/core/StandardizedYield/implementations/Zerolend/PendleZerolendLBTCSYUpg.sol

@@ -0,0 +1,32 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.23;
+
+import "../AaveV3/PendleAaveV3WithRewardsSYUpg.sol";
+import "../../../../interfaces/IPExchangeRateOracle.sol";
+
+contract PendleZerolendLBTCSYUpg is PendleAaveV3WithRewardsSYUpg {
+    address public constant Z0LBTC = 0xcABB8fa209CcdF98a7A0DC30b1979fC855Cb3Eb3;
+    address public constant ZEROLEND_POOL = 0xCD2b31071119D7eA449a9D211AC8eBF7Ee97F987;
+    address public constant ZEROLEND_INCENTIVE_CONTROLLER = address(0); // no reward currently, leave as address(0) for gas saving
+    address public constant ZERO = 0x2Da17fAf782ae884faf7dB2208BBC66b6E085C22;
+
+    address public constant LBTC_ORACLE = 0x1F0318B5Ab2c4084692986A2C25916Cec1195cD9;
+
+    address public constant WBTC = 0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599;
+
+    constructor() PendleAaveV3WithRewardsSYUpg(ZEROLEND_POOL, Z0LBTC, ZEROLEND_INCENTIVE_CONTROLLER, ZERO) {}
+
+    function exchangeRate() public view virtual override returns (uint256) {
+        return PMath.mulDown(super.exchangeRate(), IPExchangeRateOracle(LBTC_ORACLE).getExchangeRate());
+    }
+
+    function assetInfo()
+        external
+        view
+        virtual
+        override
+        returns (AssetType assetType, address assetAddress, uint8 assetDecimals)
+    {
+        return (AssetType.TOKEN, WBTC, IERC20Metadata(WBTC).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/IERC4626.sol

@@ -40,4 +40,6 @@ interface IERC4626 is IERC20Metadata {
     function previewRedeem(uint256 shares) external view returns (uint256);
 
     function totalAssets() external view returns (uint256);
+
+    function maxMint(address) external view returns (uint256);
 }

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(