@pendle/core-v2 5.0.7 → 5.1.1-beta

package/contracts/interfaces/IPActionStorageV4.sol

@@ -1,16 +1,14 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity ^0.8.0;
 
-interface IPActionStorageV4 {
+import {IPAllEventsV3} from "./IPAllEventsV3.sol";
+
+interface IPActionStorageV4 is IPAllEventsV3 {
     struct SelectorsToFacet {
         address facet;
         bytes4[] selectors;
     }
 
-    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
-
-    event SelectorToFacetSet(bytes4 indexed selector, address indexed facet);
-
     function owner() external view returns (address);
 
     function pendingOwner() external view returns (address);

package/contracts/interfaces/IPActionSwapPTV3.sol

@@ -1,39 +1,12 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity ^0.8.0;
 
-import "../router/base/MarketApproxLib.sol";
+import "../router/math/MarketApproxLib.sol";
 import "./IPAllActionTypeV3.sol";
+import {IPAllEventsV3} from "./IPAllEventsV3.sol";
 
-/*
- *******************************************************************************************************************
- *******************************************************************************************************************
- * NOTICE *
- * Refer to https://docs.pendle.finance/Developers/Contracts/PendleRouter for more information on
- * TokenInput, TokenOutput, ApproxParams, LimitOrderData
- * It's recommended to use Pendle's Hosted SDK to generate the params
- *******************************************************************************************************************
- *******************************************************************************************************************
- */
-
-interface IPActionSwapPTV3 {
-    event SwapPtAndSy(
-        address indexed caller,
-        address indexed market,
-        address indexed receiver,
-        int256 netPtToAccount,
-        int256 netSyToAccount
-    );
-
-    event SwapPtAndToken(
-        address indexed caller,
-        address indexed market,
-        address indexed token,
-        address receiver,
-        int256 netPtToAccount,
-        int256 netTokenToAccount,
-        uint256 netSyInterm
-    );
-
+/// Refer to IPAllActionTypeV3.sol for details on the parameters
+interface IPActionSwapPTV3 is IPAllEventsV3 {
     function swapExactTokenForPt(
         address receiver,
         address market,

package/contracts/interfaces/IPActionSwapYTV3.sol

@@ -1,47 +1,12 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity ^0.8.0;
 
-import "../router/base/MarketApproxLib.sol";
+import "../router/math/MarketApproxLib.sol";
 import "./IPAllActionTypeV3.sol";
+import {IPAllEventsV3} from "./IPAllEventsV3.sol";
 
-/*
- *******************************************************************************************************************
- *******************************************************************************************************************
- * NOTICE *
- * Refer to https://docs.pendle.finance/Developers/Contracts/PendleRouter for more information on
- * TokenInput, TokenOutput, ApproxParams, LimitOrderData
- * It's recommended to use Pendle's Hosted SDK to generate the params
- *******************************************************************************************************************
- *******************************************************************************************************************
- */
-
-interface IPActionSwapYTV3 {
-    event SwapYtAndSy(
-        address indexed caller,
-        address indexed market,
-        address indexed receiver,
-        int256 netYtToAccount,
-        int256 netSyToAccount
-    );
-
-    event SwapYtAndToken(
-        address indexed caller,
-        address indexed market,
-        address indexed token,
-        address receiver,
-        int256 netYtToAccount,
-        int256 netTokenToAccount,
-        uint256 netSyInterm
-    );
-
-    event SwapPtAndYt(
-        address indexed caller,
-        address indexed market,
-        address indexed receiver,
-        int256 netPtToAccount,
-        int256 netYtToAccount
-    );
-
+/// Refer to IPAllActionTypeV3.sol for details on the parameters
+interface IPActionSwapYTV3 is IPAllEventsV3 {
     function swapExactTokenForYt(
         address receiver,
         address market,

package/contracts/interfaces/IPAllActionTypeV3.sol

@@ -1,45 +1,141 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-
 pragma solidity ^0.8.0;
 
 import "../router/swap-aggregator/IPSwapAggregator.sol";
 import "./IPLimitRouter.sol";
 
 /*
- *******************************************************************************************************************
- *******************************************************************************************************************
- * NOTICE *
- * Refer to https://docs.pendle.finance/Developers/Contracts/PendleRouter for more information on
- * TokenInput, TokenOutput, ApproxParams, LimitOrderData
- * It's recommended to use Pendle's Hosted SDK to generate the params
- *******************************************************************************************************************
- *******************************************************************************************************************
+ * NOTICE:
+ * For detailed information on TokenInput, TokenOutput, ApproxParams, and LimitOrderData,
+ * refer to https://docs.pendle.finance/Developers/Contracts/PendleRouter
+ *
+ * It's recommended to use Pendle's Hosted SDK to generate these parameters for:
+ * 1. Optimal liquidity and gas efficiency
+ * 2. Access to deeper liquidity via limit orders
+ * 3. Zapping in/out using any ERC20 token
+ *
+ * Else, to generate these parameters fully onchain, use the following functions:
+ * - For TokenInput: Use createTokenInputSimple
+ * - For TokenOutput: Use createTokenOutputSimple
+ * - For ApproxParams: Use createDefaultApproxParams
+ * - For LimitOrderData: Use createEmptyLimitOrderData
+ *
+ * These generated parameters can be directly passed into the respective function calls.
+ *
+ * Examples:
+ *
+ * addLiquiditySingleToken(
+ *     msg.sender,
+ *     MARKET_ADDRESS,
+ *     minLpOut,
+ *     createDefaultApproxParams(),
+ *     createTokenInputSimple(USDC_ADDRESS, 1000e6),
+ *     createEmptyLimitOrderData()
+ * )
+ *
+ * swapExactTokenForPt(
+ *     msg.sender,
+ *     MARKET_ADDRESS,
+ *     minPtOut,
+ *     createDefaultApproxParams(),
+ *     createTokenInputSimple(USDC_ADDRESS, 1000e6),
+ *     createEmptyLimitOrderData()
+ * )
  */
 
+/// @dev Creates a TokenInput struct without using any swap aggregator
+/// @param tokenIn must be one of the SY's tokens in (obtain via `IStandardizedYield#getTokensIn`)
+/// @param netTokenIn amount of token in
+function createTokenInputSimple(address tokenIn, uint256 netTokenIn) pure returns (TokenInput memory) {
+    return
+        TokenInput({
+            tokenIn: tokenIn,
+            netTokenIn: netTokenIn,
+            tokenMintSy: tokenIn,
+            pendleSwap: address(0),
+            swapData: createSwapTypeNoAggregator()
+        });
+}
+
+/// @dev Creates a TokenOutput struct without using any swap aggregator
+/// @param tokenOut must be one of the SY's tokens out (obtain via `IStandardizedYield#getTokensOut`)
+/// @param minTokenOut minimum amount of token out
+function createTokenOutputSimple(address tokenOut, uint256 minTokenOut) pure returns (TokenOutput memory) {
+    return
+        TokenOutput({
+            tokenOut: tokenOut,
+            minTokenOut: minTokenOut,
+            tokenRedeemSy: tokenOut,
+            pendleSwap: address(0),
+            swapData: createSwapTypeNoAggregator()
+        });
+}
+
+function createEmptyLimitOrderData() pure returns (LimitOrderData memory) {}
+
+/// @dev Creates default ApproxParams for on-chain approximation
+function createDefaultApproxParams() pure returns (ApproxParams memory) {
+    return ApproxParams({guessMin: 0, guessMax: type(uint256).max, guessOffchain: 0, maxIteration: 256, eps: 1e14});
+}
+
+function createSwapTypeNoAggregator() pure returns (SwapData memory) {}
+
 struct TokenInput {
-    // TOKEN DATA
     address tokenIn;
     uint256 netTokenIn;
     address tokenMintSy;
-    // AGGREGATOR DATA
     address pendleSwap;
     SwapData swapData;
 }
 
 struct TokenOutput {
-    // TOKEN 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
+    uint256 epsSkipMarket;
     FillOrderParams[] normalFills;
     FillOrderParams[] flashFills;
     bytes optData;
 }
+
+struct ApproxParams {
+    uint256 guessMin;
+    uint256 guessMax;
+    uint256 guessOffchain;
+    uint256 maxIteration;
+    uint256 eps;
+}
+
+struct ExitPreExpReturnParams {
+    uint256 netPtFromRemove;
+    uint256 netSyFromRemove;
+    uint256 netPyRedeem;
+    uint256 netSyFromRedeem;
+    uint256 netPtSwap;
+    uint256 netYtSwap;
+    uint256 netSyFromSwap;
+    uint256 netSyFee;
+    uint256 totalSyOut;
+}
+
+struct ExitPostExpReturnParams {
+    uint256 netPtFromRemove;
+    uint256 netSyFromRemove;
+    uint256 netPtRedeem;
+    uint256 netSyFromRedeem;
+    uint256 totalSyOut;
+}
+
+struct RedeemYtIncomeToTokenStruct {
+    IPYieldToken yt;
+    bool doRedeemInterest;
+    bool doRedeemRewards;
+    address tokenRedeemSy;
+    uint256 minTokenRedeemOut;
+}

package/contracts/interfaces/IPAllActionV3.sol

@@ -8,6 +8,7 @@ import "./IPActionSwapYTV3.sol";
 import "./IPActionMiscV3.sol";
 import "./IPActionCallbackV3.sol";
 import "./IPActionStorageV4.sol";
+import "./IPActionSimple.sol";
 
 interface IPAllActionV3 is
     IPActionAddRemoveLiqV3,
@@ -15,5 +16,6 @@ interface IPAllActionV3 is
     IPActionSwapYTV3,
     IPActionMiscV3,
     IPActionCallbackV3,
-    IPActionStorageV4
+    IPActionStorageV4,
+    IPActionSimple
 {}

package/contracts/interfaces/IPAllEventsV3.sol

@@ -0,0 +1,274 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.0;
+
+import {ExitPreExpReturnParams, ExitPostExpReturnParams} from "./IPAllActionTypeV3.sol";
+
+interface IPActionAddRemoveLiqV3Events {
+    event AddLiquidityDualSyAndPt(
+        address indexed caller,
+        address indexed market,
+        address indexed receiver,
+        uint256 netSyUsed,
+        uint256 netPtUsed,
+        uint256 netLpOut
+    );
+
+    event AddLiquidityDualTokenAndPt(
+        address indexed caller,
+        address indexed market,
+        address indexed tokenIn,
+        address receiver,
+        uint256 netTokenUsed,
+        uint256 netPtUsed,
+        uint256 netLpOut,
+        uint256 netSyInterm
+    );
+
+    event AddLiquiditySinglePt(
+        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
+    );
+
+    event AddLiquiditySingleToken(
+        address indexed caller,
+        address indexed market,
+        address indexed token,
+        address receiver,
+        uint256 netTokenIn,
+        uint256 netLpOut,
+        uint256 netSyInterm
+    );
+
+    event AddLiquiditySingleSyKeepYt(
+        address indexed caller,
+        address indexed market,
+        address indexed receiver,
+        uint256 netSyIn,
+        uint256 netSyMintPy,
+        uint256 netLpOut,
+        uint256 netYtOut
+    );
+
+    event AddLiquiditySingleTokenKeepYt(
+        address indexed caller,
+        address indexed market,
+        address indexed token,
+        address receiver,
+        uint256 netTokenIn,
+        uint256 netLpOut,
+        uint256 netYtOut,
+        uint256 netSyMintPy,
+        uint256 netSyInterm
+    );
+
+    event RemoveLiquidityDualSyAndPt(
+        address indexed caller,
+        address indexed market,
+        address indexed receiver,
+        uint256 netLpToRemove,
+        uint256 netPtOut,
+        uint256 netSyOut
+    );
+
+    event RemoveLiquidityDualTokenAndPt(
+        address indexed caller,
+        address indexed market,
+        address indexed tokenOut,
+        address receiver,
+        uint256 netLpToRemove,
+        uint256 netPtOut,
+        uint256 netTokenOut,
+        uint256 netSyInterm
+    );
+
+    event RemoveLiquiditySinglePt(
+        address indexed caller,
+        address indexed market,
+        address indexed receiver,
+        uint256 netLpToRemove,
+        uint256 netPtOut
+    );
+
+    event RemoveLiquiditySingleSy(
+        address indexed caller,
+        address indexed market,
+        address indexed receiver,
+        uint256 netLpToRemove,
+        uint256 netSyOut
+    );
+
+    event RemoveLiquiditySingleToken(
+        address indexed caller,
+        address indexed market,
+        address indexed token,
+        address receiver,
+        uint256 netLpToRemove,
+        uint256 netTokenOut,
+        uint256 netSyInterm
+    );
+}
+
+interface IPActionSwapPTV3Events {
+    event SwapPtAndSy(
+        address indexed caller,
+        address indexed market,
+        address indexed receiver,
+        int256 netPtToAccount,
+        int256 netSyToAccount
+    );
+
+    event SwapPtAndToken(
+        address indexed caller,
+        address indexed market,
+        address indexed token,
+        address receiver,
+        int256 netPtToAccount,
+        int256 netTokenToAccount,
+        uint256 netSyInterm
+    );
+}
+
+interface IPActionSwapYTV3Events {
+    event SwapYtAndSy(
+        address indexed caller,
+        address indexed market,
+        address indexed receiver,
+        int256 netYtToAccount,
+        int256 netSyToAccount
+    );
+
+    event SwapYtAndToken(
+        address indexed caller,
+        address indexed market,
+        address indexed token,
+        address receiver,
+        int256 netYtToAccount,
+        int256 netTokenToAccount,
+        uint256 netSyInterm
+    );
+
+    event SwapPtAndYt(
+        address indexed caller,
+        address indexed market,
+        address indexed receiver,
+        int256 netPtToAccount,
+        int256 netYtToAccount
+    );
+}
+
+interface IPActionMiscV3Events {
+    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,
+        uint256 netSyInterm
+    );
+
+    event RedeemPyToToken(
+        address indexed caller,
+        address indexed tokenOut,
+        address indexed YT,
+        address receiver,
+        uint256 netPyIn,
+        uint256 netTokenOut,
+        uint256 netSyInterm
+    );
+
+    event ExitPreExpToToken(
+        address indexed caller,
+        address indexed market,
+        address indexed token,
+        address receiver,
+        uint256 netLpIn,
+        uint256 totalTokenOut,
+        ExitPreExpReturnParams params
+    );
+
+    event ExitPreExpToSy(
+        address indexed caller,
+        address indexed market,
+        address indexed receiver,
+        uint256 netLpIn,
+        ExitPreExpReturnParams params
+    );
+
+    event ExitPostExpToToken(
+        address indexed caller,
+        address indexed market,
+        address indexed token,
+        address receiver,
+        uint256 netLpIn,
+        uint256 totalTokenOut,
+        ExitPostExpReturnParams params
+    );
+
+    event ExitPostExpToSy(
+        address indexed caller,
+        address indexed market,
+        address indexed receiver,
+        uint256 netLpIn,
+        ExitPostExpReturnParams params
+    );
+}
+
+interface IPActionStorageEvents {
+    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
+
+    event SelectorToFacetSet(bytes4 indexed selector, address indexed facet);
+}
+
+interface IPAllEventsV3 is
+    IPActionAddRemoveLiqV3Events,
+    IPActionSwapPTV3Events,
+    IPActionSwapYTV3Events,
+    IPActionMiscV3Events,
+    IPActionStorageEvents
+{}

package/contracts/interfaces/Sky/ISkyConverter.sol

@@ -0,0 +1,8 @@
+// SPDX-License-Identifier: BUSL-1.1
+pragma solidity ^0.8.0;
+
+interface ISkyConverter {
+    function daiToUsds(address usr, uint256 wad) external;
+
+    function usdsToDai(address usr, uint256 wad) external;
+}

package/contracts/interfaces/Sky/ISkyStaking.sol

@@ -0,0 +1,10 @@
+// SPDX-License-Identifier: BUSL-1.1
+pragma solidity ^0.8.0;
+
+interface ISkyStaking {
+    function stake(uint256 amount) external;
+
+    function withdraw(uint256 amount) external;
+
+    function getReward() external;
+}

package/contracts/interfaces/Syrup/ISyrupRouter.sol

@@ -0,0 +1,9 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+pragma solidity ^0.8.0;
+
+interface ISyrupRouter {
+    function pool() external view returns (address);
+
+    function deposit(uint256 amount_, bytes32 depositData_) external returns (uint256 shares_);
+}

package/contracts/interfaces/Usual/IUsualUSD0PP.sol

@@ -0,0 +1,6 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.17;
+
+interface IUsualUSD0PP {
+    function mint(uint256 amountUsd0) external;
+}

package/contracts/interfaces/Venus/IVenusBNB.sol

@@ -0,0 +1,8 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.0;
+
+interface IVenusBNB {
+    function mint() external payable;
+
+    function redeem(uint256 redeemTokens) external returns (uint256);
+}

package/contracts/interfaces/Venus/IVenusComptroller.sol

@@ -0,0 +1,6 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.0;
+
+interface IVenusComptroller {
+    function claimVenus(address holder, address[] memory vTokens) external;
+}

package/contracts/interfaces/Venus/IVenusInterestModel.sol

@@ -0,0 +1,13 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.0;
+
+interface IVenusInterestRateModel {
+    function getBorrowRate(uint256 cash, uint256 borrows, uint256 reserves) external view returns (uint256);
+
+    function getSupplyRate(
+        uint256 cash,
+        uint256 borrows,
+        uint256 reserves,
+        uint256 reserveFactorMantissa
+    ) external view returns (uint256);
+}

package/contracts/interfaces/Venus/IVenusToken.sol

@@ -0,0 +1,22 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.0;
+
+interface IVenusToken {
+    function exchangeRateCurrent() external returns (uint256);
+
+    function exchangeRateStored() external view returns (uint256);
+
+    function getCash() external view returns (uint256);
+
+    function totalBorrows() external view returns (uint256);
+
+    function totalReserves() external view returns (uint256);
+
+    function totalSupply() external view returns (uint256);
+
+    function accrualBlockNumber() external view returns (uint256);
+
+    function interestRateModel() external view returns (address);
+
+    function reserveFactorMantissa() external view returns (uint256);
+}

package/contracts/offchain-helpers/PendleOffchainStorage.sol

@@ -42,8 +42,6 @@ contract PendleOffchainStorage is IPOffchainStorage, UUPSUpgradeable, AccessCont
         emit SetStorage(key, value);
     }
 
-    // TODO: update more getSomething functions later when theres a need
-
     /*///////////////////////////////////////////////////////////////
                             UPGRADABLE RELATED
     //////////////////////////////////////////////////////////////*/

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

@@ -297,8 +297,8 @@ contract ActionMarketAuxStatic is IPActionMarketAuxStatic {
         uint256 MIN_EPS_CAP = PMath.ONE / 10 ** 5;
         uint256 eps = PMath.min(slippage / 2, MIN_EPS_CAP);
 
-        uint256 guessMin = PMath.max(guessLowerBound, netPtOut.slipDown(slippage));
-        uint256 guessMax = PMath.min(guessUpperBound, netPtOut.slipUp(5 * slippage));
+        uint256 guessMin = PMath.max(guessLowerBound, netPtOut.tweakDown(slippage));
+        uint256 guessMax = PMath.min(guessUpperBound, netPtOut.tweakUp(5 * slippage));
 
         return
             ApproxParams({

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

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity ^0.8.17;
 
-import "../../../router/base/MarketApproxLib.sol";
+import "../../../router/math/MarketApproxLib.sol";
 
 abstract contract StorageLayout {
     address internal owner;