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

package/contracts/interfaces/IPActionMisc.sol

@@ -1,6 +1,9 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity ^0.8.0;
 
+import "../router/base/MarketApproxLib.sol";
+import "./IPAllActionType.sol";
+
 interface IPActionMisc {
     struct MultiApproval {
         address[] tokens;
@@ -17,7 +20,91 @@ interface IPActionMisc {
         bytes returnData;
     }
 
+    event MintSyFromToken(
+        address indexed caller,
+        address indexed tokenIn,
+        address indexed SY,
+        address receiver,
+        uint256 netTokenIn,
+        uint256 netSyOut
+    );
+
+    event RedeemSyToToken(
+        address indexed caller,
+        address indexed tokenOut,
+        address indexed SY,
+        address receiver,
+        uint256 netSyIn,
+        uint256 netTokenOut
+    );
+
+    event MintPyFromSy(
+        address indexed caller, address indexed receiver, address indexed YT, uint256 netSyIn, uint256 netPyOut
+    );
+
+    event RedeemPyToSy(
+        address indexed caller, address indexed receiver, address indexed YT, uint256 netPyIn, uint256 netSyOut
+    );
+
+    event MintPyFromToken(
+        address indexed caller,
+        address indexed tokenIn,
+        address indexed YT,
+        address receiver,
+        uint256 netTokenIn,
+        uint256 netPyOut
+    );
+
+    event RedeemPyToToken(
+        address indexed caller,
+        address indexed tokenOut,
+        address indexed YT,
+        address receiver,
+        uint256 netPyIn,
+        uint256 netTokenOut
+    );
+
+    function mintSyFromToken(address receiver, address SY, uint256 minSyOut, TokenInput calldata input)
+        external
+        payable
+        returns (uint256 netSyOut);
+
+    function redeemSyToToken(address receiver, address SY, uint256 netSyIn, TokenOutput calldata output)
+        external
+        returns (uint256 netTokenOut);
+
+    function mintPyFromToken(address receiver, address YT, uint256 minPyOut, TokenInput calldata input)
+        external
+        payable
+        returns (uint256 netPyOut);
+
+    function redeemPyToToken(address receiver, address YT, uint256 netPyIn, TokenOutput calldata output)
+        external
+        returns (uint256 netTokenOut);
+
+    function mintPyFromSy(address receiver, address YT, uint256 netSyIn, uint256 minPyOut)
+        external
+        returns (uint256 netPyOut);
+
+    function redeemPyToSy(address receiver, address YT, uint256 netPyIn, uint256 minSyOut)
+        external
+        returns (uint256 netSyOut);
+
+    function redeemDueInterestAndRewards(
+        address user,
+        address[] calldata sys,
+        address[] calldata yts,
+        address[] calldata markets
+    ) external;
+
     function approveInf(MultiApproval[] calldata) external;
 
-    function batchExec(Call3[] calldata calls) external returns (Result[] memory returnData);
+    function multicall(Call3[] calldata calls) external payable returns (Result[] memory returnData);
+
+    function multicallRevert(uint256 gasLimit, Call3[] calldata calls)
+        external
+        payable
+        returns (bytes[] memory res, uint256[] memory gasUsed);
+
+    function callThenRevert(address target, bytes memory callData) external payable;
 }

package/contracts/interfaces/IPActionStorageStatic.sol

@@ -9,14 +9,7 @@ interface IPActionStorageStatic {
 
     function getDefaultApproxParams() external view returns (ApproxParams memory);
 
-    function setBulkSellerFactory(address _bulkSellerFactory) external;
-
-    function getBulkSellerFactory() external view returns (address);
-
-    function getOwnerAndPendingOwner()
-        external
-        view
-        returns (address _owner, address _pendingOwner);
+    function getOwnerAndPendingOwner() external view returns (address _owner, address _pendingOwner);
 
     function transferOwnership(address newOwner, bool direct, bool renounce) external;
 

package/contracts/interfaces/IPActionSwapPT.sol

@@ -2,7 +2,7 @@
 pragma solidity ^0.8.0;
 
 import "../router/base/MarketApproxLib.sol";
-import "../router/base/ActionBaseMintRedeem.sol";
+import "./IPAllActionType.sol";
 
 interface IPActionSwapPT {
     event SwapPtAndSy(
@@ -26,30 +26,17 @@ interface IPActionSwapPT {
         address receiver,
         address market,
         uint256 exactPtIn,
-        uint256 minSyOut
+        uint256 minSyOut,
+        LimitOrderData calldata limit
     ) external returns (uint256 netSyOut, uint256 netSyFee);
 
-    function swapPtForExactSy(
-        address receiver,
-        address market,
-        uint256 exactSyOut,
-        uint256 maxPtIn,
-        ApproxParams calldata guessPtIn
-    ) external returns (uint256 netPtIn, uint256 netSyFee);
-
-    function swapSyForExactPt(
-        address receiver,
-        address market,
-        uint256 exactPtOut,
-        uint256 maxSyIn
-    ) external returns (uint256 netSyIn, uint256 netSyFee);
-
     function swapExactSyForPt(
         address receiver,
         address market,
         uint256 exactSyIn,
         uint256 minPtOut,
-        ApproxParams calldata guessPtOut
+        ApproxParams calldata guessPtOut,
+        LimitOrderData calldata limit
     ) external returns (uint256 netPtOut, uint256 netSyFee);
 
     function swapExactTokenForPt(
@@ -57,13 +44,15 @@ interface IPActionSwapPT {
         address market,
         uint256 minPtOut,
         ApproxParams calldata guessPtOut,
-        TokenInput calldata input
+        TokenInput calldata input,
+        LimitOrderData calldata limit
     ) external payable returns (uint256 netPtOut, uint256 netSyFee);
 
     function swapExactPtForToken(
         address receiver,
         address market,
         uint256 exactPtIn,
-        TokenOutput calldata output
+        TokenOutput calldata output,
+        LimitOrderData calldata limit
     ) external returns (uint256 netTokenOut, uint256 netSyFee);
 }

package/contracts/interfaces/IPActionSwapYT.sol

@@ -2,7 +2,7 @@
 pragma solidity ^0.8.0;
 
 import "../router/base/MarketApproxLib.sol";
-import "../router/base/ActionBaseMintRedeem.sol";
+import "./IPAllActionType.sol";
 
 interface IPActionSwapYT {
     event SwapYtAndSy(
@@ -35,44 +35,33 @@ interface IPActionSwapYT {
         address market,
         uint256 exactSyIn,
         uint256 minYtOut,
-        ApproxParams calldata guessYtOut
+        ApproxParams calldata guessYtOut,
+        LimitOrderData calldata limit
     ) external returns (uint256 netYtOut, uint256 netSyFee);
 
     function swapExactYtForSy(
         address receiver,
         address market,
         uint256 exactYtIn,
-        uint256 minSyOut
+        uint256 minSyOut,
+        LimitOrderData calldata limit
     ) external returns (uint256 netSyOut, uint256 netSyFee);
 
-    function swapSyForExactYt(
-        address receiver,
-        address market,
-        uint256 exactYtOut,
-        uint256 maxSyIn
-    ) external returns (uint256 netSyIn, uint256 netSyFee);
-
-    function swapYtForExactSy(
-        address receiver,
-        address market,
-        uint256 exactSyOut,
-        uint256 maxYtIn,
-        ApproxParams calldata guessYtIn
-    ) external returns (uint256 netYtIn, uint256 netSyFee);
-
     function swapExactTokenForYt(
         address receiver,
         address market,
         uint256 minYtOut,
         ApproxParams calldata guessYtOut,
-        TokenInput calldata input
+        TokenInput calldata input,
+        LimitOrderData calldata limit
     ) external payable returns (uint256 netYtOut, uint256 netSyFee);
 
     function swapExactYtForToken(
         address receiver,
         address market,
-        uint256 netYtIn,
-        TokenOutput calldata output
+        uint256 exactYtIn,
+        TokenOutput calldata output,
+        LimitOrderData calldata limit
     ) external returns (uint256 netTokenOut, uint256 netSyFee);
 
     function swapExactPtForYt(

package/contracts/interfaces/IPAllAction.sol

@@ -5,7 +5,6 @@ pragma solidity ^0.8.0;
 import "./IPActionAddRemoveLiq.sol";
 import "./IPActionSwapPT.sol";
 import "./IPActionSwapYT.sol";
-import "./IPActionMintRedeem.sol";
 import "./IPActionMisc.sol";
 import "./IPMarketSwapCallback.sol";
 import "./IDiamondLoupe.sol";
@@ -14,7 +13,6 @@ interface IPAllAction is
     IPActionAddRemoveLiq,
     IPActionSwapPT,
     IPActionSwapYT,
-    IPActionMintRedeem,
     IPActionMisc,
     IPMarketSwapCallback,
     IDiamondLoupe

package/contracts/interfaces/IPAllActionType.sol

@@ -0,0 +1,33 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+pragma solidity ^0.8.0;
+
+import "../router/swap-aggregator/IPSwapAggregator.sol";
+import "./IPLimitRouter.sol";
+
+struct TokenInput {
+    // Token/Sy data
+    address tokenIn;
+    uint256 netTokenIn;
+    address tokenMintSy;
+    // aggregator data
+    address pendleSwap;
+    SwapData swapData;
+}
+
+struct TokenOutput {
+    // Token/Sy data
+    address tokenOut;
+    uint256 minTokenOut;
+    address tokenRedeemSy;
+    // aggregator data
+    address pendleSwap;
+    SwapData swapData;
+}
+
+struct LimitOrderData {
+    address limitRouter;
+    uint256 epsSkipMarket; // only used for swap operations, will be ignored otherwise
+    FillOrderParams[] normalFills;
+    FillOrderParams[] flashFills;
+}

package/contracts/interfaces/IPLimitRouter.sol

@@ -0,0 +1,162 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.0;
+
+import "../core/StandardizedYield/PYIndex.sol";
+
+interface IPOrderMixinType {
+    enum OrderType {
+        SY_FOR_PT,
+        PT_FOR_SY,
+        SY_FOR_YT,
+        YT_FOR_SY
+    }
+
+    // Fixed-size order part with core information
+    struct StaticOrder {
+        uint256 salt;
+        uint256 expiry;
+        uint256 nonce;
+        OrderType orderType;
+        address token;
+        address YT;
+        address maker;
+        address receiver;
+        uint256 makingAmount;
+        uint256 lnImpliedRate;
+    }
+
+    struct NormalResults {
+        uint256 totalMaking;
+        uint256 totalTaking;
+        uint256 totalFee;
+        uint256[] netMakings;
+        uint256[] netTakings;
+        uint256[] netFees;
+    }
+
+    struct OnchainParams {
+        uint256 timeToExpiry;
+        uint256 pyIndex;
+        address feeRecipient;
+        uint256 lnFeeRateRoot;
+    }
+}
+
+struct Order {
+    uint256 salt;
+    uint256 expiry;
+    uint256 nonce;
+    IPOrderMixinType.OrderType orderType;
+    address token;
+    address YT;
+    address maker;
+    address receiver;
+    uint256 makingAmount;
+    uint256 lnImpliedRate;
+    bytes permit; // On first fill: permit.1.call(abi.encodePacked(permit.selector, permit.2))
+}
+
+struct FillOrderParams {
+    Order order;
+    bytes signature;
+    uint256 makingAmount;
+}
+
+interface IPOrderMixin is IPOrderMixinType {
+    event OrderCanceled(address indexed maker, bytes32 indexed orderHash, uint256 remaining);
+
+    event OrderRemainingUpdated(bytes32 indexed orderHash, uint256 remaining);
+
+    event NormalFill(
+        OrderType indexed orderType,
+        address indexed YT,
+        address indexed taker,
+        uint256 actualMaking,
+        uint256 actualTaking,
+        uint256 totalFee,
+        uint256 rawTotalMaking,
+        uint256 rawTotalTaking
+    );
+
+    event FlashFill(
+        OrderType indexed orderType,
+        address indexed YT,
+        address indexed taker,
+        uint256 netOutputToTaker,
+        uint256 netInputFromTaker,
+        uint256 totalFee,
+        uint256 rawTotalMaking,
+        uint256 rawTotalTaking
+    );
+
+    /**
+     * (making, taking)
+     * SY_FOR_PT: (SY, PT)
+     * PT_FOR_SY: (PT, SY)
+     * SY_FOR_YT: (SY, YT)
+     * YT_FOR_SY: (YT, SY)
+     */
+    function normalFill(FillOrderParams[] memory params, address receiver, uint256 maxTaking, bytes calldata callback)
+        external
+        returns (uint256 actualMaking, uint256 actualTaking, uint256 totalFee);
+
+    /**
+     * (output, input)
+     * SY_FOR_PT: (YT, SY)
+     * PT_FOR_SY: (SY, YT)
+     * SY_FOR_YT: (PT, SY)
+     * YT_FOR_SY: (SY, PT)
+     */
+    function flashFill(FillOrderParams[] memory params, address receiver, uint256 maxInput, bytes calldata callback)
+        external
+        returns (uint256 netOutputToTaker, uint256 netInputFromTaker, uint256 totalFee);
+
+    function feeRecipient() external view returns (address);
+
+    function lnFeeRateRoot() external view returns (uint96);
+
+    function hashOrder(Order memory order) external view returns (bytes32);
+
+    function getOnchainParams(address YT) external returns (OnchainParams memory);
+}
+
+interface ILimitOrderCallee is IPOrderMixinType {
+    /// Refer to normalFill
+    function normalFillCall(
+        OrderType orderType,
+        uint256 actualMaking,
+        uint256 actualTaking,
+        uint256 totalFee,
+        bytes memory data
+    ) external;
+
+    /// Refer to flashFill
+    function flashFillCall(
+        OrderType orderType,
+        uint256 netOutputToTaker,
+        uint256 netInputFromTaker,
+        uint256 totalFee,
+        bytes memory data
+    ) external;
+}
+
+interface IPLimitRouter is IPOrderMixin {
+    struct MultiApproval {
+        address[] tokens;
+        address spender;
+    }
+
+    function cancelSingle(Order calldata order) external;
+
+    function cancelBatch(Order[] calldata orders) external;
+
+    function approveInf(MultiApproval[] calldata arr) external;
+
+    function remaining(bytes32 orderHash) external view returns (uint256);
+
+    function remainingRaw(bytes32 orderHash) external view returns (uint256);
+
+    function remainingsRaw(bytes32[] memory orderHashes) external view returns (uint256[] memory);
+
+    function DOMAIN_SEPARATOR() external view returns (bytes32);
+}

package/contracts/interfaces/IPMarketFactory.sol

@@ -29,4 +29,6 @@ interface IPMarketFactory {
     function getMarketConfig(
         address router
     ) external view returns (address treasury, uint80 lnFeeRateRoot, uint8 reserveFeePercent);
+
+
 }

package/contracts/interfaces/IPRouterHelper.sol

@@ -2,13 +2,13 @@
 pragma solidity ^0.8.0;
 
 import "../router/base/MarketApproxLib.sol";
-import "../router/base/ActionBaseMintRedeem.sol";
+import "../interfaces/IPAllActionType.sol";
 
 interface IPRouterHelper {
     /**
      * @param output This output struct should be filled the same way as the normal removeLiquiditySingleToken
-     operation (This means all BulkSeller, PendleSwap still works the same way). Note that the
-     output.tokenOut will also be used as the input token for the addLiquidity
+     *  operation (This means PendleSwap still works the same way). Note that the
+     *  output.tokenOut will also be used as the input token for the addLiquidity
      */
     struct RemoveLiquiditySingleTokenStruct {
         address market;
@@ -19,10 +19,10 @@ interface IPRouterHelper {
 
     /**
      * @param guessNetTokenIn the predicted amount of tokenIn that will be used to add liquidity. This
-     should be the same amount that was used to generate guessPtReceivedFromSy (if any).
+     *  should be the same amount that was used to generate guessPtReceivedFromSy (if any).
      * @param guessPtReceivedFromSy the same guess struct in the normal addLiquiditySingleToken operation.
-     Again, note that this struct, if not empty (i.e. if guessOffchain == 0), should be generated
-     using `guessNetTokenIn` amount of tokenIn
+     *  Again, note that this struct, if not empty (i.e. if guessOffchain == 0), should be generated
+     *  using `guessNetTokenIn` amount of tokenIn
      * @dev tokenIn is the output.tokenOut of the removeLiquiditySingleTokenStruct
      */
     struct AddLiquiditySingleTokenStruct {
@@ -30,7 +30,6 @@ interface IPRouterHelper {
         uint256 minLpOut;
         uint256 guessNetTokenIn;
         ApproxParams guessPtReceivedFromSy;
-        address bulk;
     }
 
     /**
@@ -40,7 +39,6 @@ interface IPRouterHelper {
         address market;
         uint256 minLpOut;
         uint256 minYtOut;
-        address bulk;
     }
 
     struct RemoveLiquiditySingleSyStruct {
@@ -92,11 +90,7 @@ interface IPRouterHelper {
     );
 
     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 AddLiquiditySingleTokenKeepYt(
@@ -121,50 +115,22 @@ interface IPRouterHelper {
     function transferLiquidityDifferentSyNormal(
         RemoveLiquiditySingleTokenStruct calldata fromMarket,
         AddLiquiditySingleTokenStruct calldata toMarket
-    )
-        external
-        returns (
-            uint256 netLpOut,
-            uint256 netTokenZapIn,
-            uint256 netSyFeeOfRemove,
-            uint256 netSyFeeOfAdd
-        );
+    ) external returns (uint256 netLpOut, uint256 netTokenZapIn, uint256 netSyFeeOfRemove, uint256 netSyFeeOfAdd);
 
     function transferLiquidityDifferentSyKeepYt(
         RemoveLiquiditySingleTokenStruct calldata fromMarket,
         AddLiquiditySingleTokenKeepYtStruct calldata toMarket
-    )
-        external
-        returns (
-            uint256 netLpOut,
-            uint256 netYtOut,
-            uint256 netTokenZapIn,
-            uint256 netSyFeeOfRemove
-        );
+    ) external returns (uint256 netLpOut, uint256 netYtOut, uint256 netTokenZapIn, uint256 netSyFeeOfRemove);
 
     function transferLiquiditySameSyNormal(
         RemoveLiquiditySingleSyStruct calldata fromMarket,
         AddLiquiditySingleSyStruct calldata toMarket
-    )
-        external
-        returns (
-            uint256 netLpOut,
-            uint256 netSyZapIn,
-            uint256 netSyFeeOfRemove,
-            uint256 netSyFeeOfAdd
-        );
+    ) external returns (uint256 netLpOut, uint256 netSyZapIn, uint256 netSyFeeOfRemove, uint256 netSyFeeOfAdd);
 
     function transferLiquiditySameSyKeepYt(
         RemoveLiquiditySingleSyStruct calldata fromMarket,
         AddLiquiditySingleSyKeepYtStruct calldata toMarket
-    )
-        external
-        returns (
-            uint256 netLpOut,
-            uint256 netYtOut,
-            uint256 netSyZapIn,
-            uint256 netSyFeeOfRemove
-        );
+    ) external returns (uint256 netLpOut, uint256 netYtOut, uint256 netSyZapIn, uint256 netSyFeeOfRemove);
 
     function removeLiquiditySingleToken(RemoveLiquiditySingleTokenStruct calldata fromMarket)
         external

package/contracts/interfaces/Stader/IStaderStakeManager.sol

@@ -0,0 +1,57 @@
+pragma solidity 0.8.17;
+
+interface IStaderStakeManager {
+    // Errors
+    error InvalidDepositAmount();
+    error UnsupportedOperation();
+    error InsufficientBalance();
+    error TransferFailed();
+    error PoolIdDoesNotExit();
+    error CooldownNotComplete();
+    error UnsupportedOperationInSafeMode();
+
+    // Events
+    event UpdatedStaderConfig(address staderConfig);
+    event Deposited(address indexed caller, address indexed owner, uint256 assets, uint256 shares);
+    event ExecutionLayerRewardsReceived(uint256 amount);
+    event AuctionedEthReceived(uint256 amount);
+    event ReceivedExcessEthFromPool(uint8 indexed poolId);
+    event TransferredETHToUserWithdrawManager(uint256 amount);
+    event ETHTransferredToPool(uint256 indexed poolId, address poolAddress, uint256 validatorCount);
+    event WithdrawVaultUserShareReceived(uint256 amount);
+    event UpdatedExcessETHDepositCoolDown(uint256 excessETHDepositCoolDown);
+
+    function deposit(address _receiver) external payable returns (uint256);
+
+    function previewDeposit(uint256 _assets) external view returns (uint256);
+
+    function previewWithdraw(uint256 _shares) external view returns (uint256);
+
+    function getExchangeRate() external view returns (uint256);
+
+    function totalAssets() external view returns (uint256);
+
+    function convertToShares(uint256 _assets) external view returns (uint256);
+
+    function convertToAssets(uint256 _shares) external view returns (uint256);
+
+    function maxDeposit() external view returns (uint256);
+
+    function minDeposit() external view returns (uint256);
+
+    function receiveExecutionLayerRewards() external payable;
+
+    function receiveWithdrawVaultUserShare() external payable;
+
+    function receiveEthFromAuction() external payable;
+
+    function receiveExcessEthFromPool(uint8 _poolId) external payable;
+
+    function transferETHToUserWithdrawManager(uint256 _amount) external;
+
+    function validatorBatchDeposit(uint8 _poolId) external;
+
+    function depositETHOverTargetWeight() external;
+
+    function isVaultHealthy() external view returns (bool);
+}