@pendle/core-v2 5.0.7-beta → 5.1.0

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/Pump/IPumpStaking.sol

@@ -0,0 +1,14 @@
+// SPDX-License-Identifier: BUSL-1.1
+pragma solidity ^0.8.0;
+
+interface IPumpStaking {
+    function stake(uint256 amount) external;
+
+    function unstakeInstant(uint256 amount) external;
+
+    function onlyAllowStake() external view returns (bool);
+
+    function instantUnstakeFee() external view returns (uint256);
+
+    function pendingStakeAmount() external view returns (uint256);
+}

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/Solv/ISolvERC3525.sol

@@ -0,0 +1,13 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.0;
+
+interface ISolvERC3525 {
+    /**
+     * @notice Get the number of decimals the token uses for value - e.g. 6, means the user
+     *  representation of the value of a token can be calculated by dividing it by 1,000,000.
+     *  Considering the compatibility with third-party wallets, this function is defined as
+     *  `valueDecimals()` instead of `decimals()` to avoid conflict with ERC20 tokens.
+     * @return The number of decimals for value
+     */
+    function valueDecimals() external view returns (uint8);
+}

package/contracts/interfaces/Solv/ISolvOpenFundMarket.sol

@@ -0,0 +1,46 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.0;
+
+interface ISolvOpenFundMarket {
+    struct SFTInfo {
+        address manager;
+        bool isValid;
+    }
+    struct SubscribeLimitInfo {
+        uint256 hardCap;
+        uint256 subscribeMin;
+        uint256 subscribeMax;
+        uint64 fundraisingStartTime;
+        uint64 fundraisingEndTime;
+    }
+    struct PoolSFTInfo {
+        address openFundShare;
+        address openFundRedemption;
+        uint256 openFundShareSlot;
+        uint256 latestRedeemSlot;
+    }
+    struct PoolFeeInfo {
+        uint16 carryRate;
+        address carryCollector;
+        uint64 latestProtocolFeeSettleTime;
+    }
+    struct ManagerInfo {
+        address poolManager;
+        address subscribeNavManager;
+        address redeemNavManager;
+    }
+    struct PoolInfo {
+        PoolSFTInfo poolSFTInfo;
+        PoolFeeInfo poolFeeInfo;
+        ManagerInfo managerInfo;
+        SubscribeLimitInfo subscribeLimitInfo;
+        address vault;
+        address currency;
+        address navOracle;
+        uint64 valueDate;
+        bool permissionless;
+        uint256 fundraisingAmount;
+    }
+
+    function poolInfos(bytes32) external view returns (PoolInfo memory);
+}

package/contracts/interfaces/Solv/ISolvOracle.sol

@@ -0,0 +1,10 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.0;
+
+interface ISolvOracle {
+    function setSubscribeNavOnlyMarket(bytes32 poolId_, uint256 time_, uint256 nav_) external;
+    function updateAllTimeHighRedeemNavOnlyMarket(bytes32 poolId_, uint256 nav_) external;
+    function getSubscribeNav(bytes32 poolId_, uint256 time_) external view returns (uint256 nav_, uint256 navTime_);
+    function getAllTimeHighRedeemNav(bytes32 poolId_) external view returns (uint256);
+}

package/contracts/interfaces/Solv/ISolvRouter.sol

@@ -0,0 +1,6 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.0;
+
+interface ISolvRouter {
+    function createSubscription(bytes32 poolId_, uint256 currencyAmount_) external returns (uint256 shareValue_);
+}

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/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;

package/contracts/oracles/PendleBoringOneracle.sol

@@ -0,0 +1,11 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.17;
+
+import "../core/libraries/math/PMath.sol";
+import "../interfaces/IPExchangeRateOracle.sol";
+
+contract PendleBoringOneracle is IPExchangeRateOracle {
+    function getExchangeRate() external pure returns (uint256) {
+        return PMath.ONE;
+    }
+}

package/contracts/oracles/PendleBoringSolvBTCOneracle.sol

@@ -0,0 +1,11 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.17;
+
+import "../core/libraries/math/PMath.sol";
+import "../interfaces/IPExchangeRateOracle.sol";
+
+contract PendleBoringSolvBTCOneracle is IPExchangeRateOracle {
+    function getExchangeRate() external pure returns (uint256) {
+        return 10 ** 8;
+    }
+}

package/contracts/oracles/PendleSparkLinearDiscountOracle.sol

@@ -0,0 +1,45 @@
+// SPDX-License-Identifier: SEE LICENSE IN LICENSE
+pragma solidity ^0.8.19;
+
+contract PendleSparkLinearDiscountOracle {
+    uint256 private constant SECONDS_PER_YEAR = 365 days;
+    uint256 private constant ONE = 1e18;
+
+    address public immutable PT;
+    uint256 public immutable maturity;
+    uint256 public immutable baseDiscountPerYear; // 100% = 1e18
+
+    constructor(address _pt, uint256 _baseDiscountPerYear) {
+        require(_baseDiscountPerYear <= 1e18, "invalid discount");
+        require(_pt != address(0), "zero address");
+
+        PT = _pt;
+        maturity = PTExpiry(PT).expiry();
+        baseDiscountPerYear = _baseDiscountPerYear;
+    }
+
+    function latestRoundData()
+        external
+        view
+        returns (uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound)
+    {
+        uint256 timeLeft = (maturity > block.timestamp) ? maturity - block.timestamp : 0;
+        uint256 discount = getDiscount(timeLeft);
+
+        require(discount <= ONE, "discount overflow");
+
+        return (0, int256(ONE - discount), 0, 0, 0);
+    }
+
+    function decimals() external pure returns (uint8) {
+        return 18;
+    }
+
+    function getDiscount(uint256 timeLeft) public view returns (uint256) {
+        return (timeLeft * baseDiscountPerYear) / SECONDS_PER_YEAR;
+    }
+}
+
+interface PTExpiry {
+    function expiry() external view returns (uint256);
+}