@pendle/core-v2 1.4.0-mainnet → 1.4.1-testnet

package/contracts/interfaces/GMX/IGlpManager.sol

@@ -0,0 +1,12 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.17;
+
+interface IGlpManager {
+    function getAumInUsdg(bool maximise) external view returns (uint256);
+
+    function vault() external view returns (address);
+
+    function gov() external view returns (address);
+
+    function setCooldownDuration(uint256 _cooldownDuration) external;
+}

package/contracts/interfaces/GMX/IRewardRouterV2.sol

@@ -0,0 +1,43 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+interface IRewardRouterV2 {
+    function weth() external view returns (address);
+
+    function handleRewards(
+        bool _shouldClaimGmx,
+        bool _shouldStakeGmx,
+        bool _shouldClaimEsGmx,
+        bool _shouldStakeEsGmx,
+        bool _shouldStakeMultiplierPoints,
+        bool _shouldClaimWeth,
+        bool _shouldConvertWethToEth
+    ) external;
+
+    function glpManager() external view returns (address);
+
+    function mintAndStakeGlp(
+        address _token,
+        uint256 _amount,
+        uint256 _minUsdg,
+        uint256 _minGlp
+    ) external returns (uint256);
+
+    function mintAndStakeGlpETH(
+        uint256 _minUsdg,
+        uint256 _minGlp
+    ) external payable returns (uint256);
+
+    function unstakeAndRedeemGlp(
+        address _tokenOut,
+        uint256 _glpAmount,
+        uint256 _minOut,
+        address _receiver
+    ) external returns (uint256);
+
+    function unstakeAndRedeemGlpETH(
+        uint256 _glpAmount,
+        uint256 _minOut,
+        address payable _receiver
+    ) external returns (uint256);
+}

package/contracts/interfaces/GMX/IVaultPriceFeed.sol

@@ -0,0 +1,11 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.17;
+
+interface IVaultPriceFeed {
+    function getPrice(
+        address _token,
+        bool _maximise,
+        bool _includeAmmPrice,
+        bool _useSwapPricing
+    ) external view returns (uint256);
+}

package/contracts/interfaces/IAddressProvider.sol

@@ -0,0 +1,7 @@
+pragma solidity 0.8.17;
+
+interface IAddressProvider {
+    function get(uint256) external view returns (address);
+
+    function set(uint256 id, address addr) external;
+}

package/contracts/interfaces/IApeStaking.sol

@@ -20,10 +20,9 @@ interface IApeStaking {
         uint256 _tokenId
     ) external view returns (uint256);
 
-    function addressPosition(address addr)
-        external
-        view
-        returns (uint256 stakedAmount, int256 rewardsDebt);
+    function addressPosition(
+        address addr
+    ) external view returns (uint256 stakedAmount, int256 rewardsDebt);
 
     // for SDK
     function pools(uint256 id) external view returns (uint48, uint16, uint96 totalStaked, uint96);

package/contracts/interfaces/IDiamondCut.sol

@@ -0,0 +1,36 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+/******************************************************************************\
+* Author: Nick Mudge <nick@perfectabstractions.com> (https://twitter.com/mudgen)
+* EIP-2535 Diamonds: https://eips.ethereum.org/EIPS/eip-2535
+/******************************************************************************/
+
+interface IDiamondCut {
+    enum FacetCutAction {
+        Add,
+        Replace,
+        Remove
+    }
+    // Add=0, Replace=1, Remove=2
+
+    struct FacetCut {
+        address facetAddress;
+        FacetCutAction action;
+        bytes4[] functionSelectors;
+    }
+
+    /// @notice Add/replace/remove any number of functions and optionally execute
+    ///         a function with delegatecall
+    /// @param _diamondCut Contains the facet addresses and function selectors
+    /// @param _init The address of the contract or facet to execute _calldata
+    /// @param _calldata A function call, including function selector and arguments
+    ///                  _calldata is executed with delegatecall on _init
+    function diamondCut(
+        FacetCut[] calldata _diamondCut,
+        address _init,
+        bytes calldata _calldata
+    ) external;
+
+    event DiamondCut(FacetCut[] _diamondCut, address _init, bytes _calldata);
+}

package/contracts/interfaces/IDiamondLoupe.sol

@@ -0,0 +1,40 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+/******************************************************************************\
+* Author: Nick Mudge <nick@perfectabstractions.com> (https://twitter.com/mudgen)
+* EIP-2535 Diamonds: https://eips.ethereum.org/EIPS/eip-2535
+/******************************************************************************/
+
+// A loupe is a small magnifying glass used to look at diamonds.
+// These functions look at diamonds
+interface IDiamondLoupe {
+    /// These functions are expected to be called frequently
+    /// by tools.
+
+    struct Facet {
+        address facetAddress;
+        bytes4[] functionSelectors;
+    }
+
+    /// @notice Gets all facet addresses and their four byte function selectors.
+    /// @return facets_ Facet
+    function facets() external view returns (Facet[] memory facets_);
+
+    /// @notice Gets all the function selectors supported by a specific facet.
+    /// @param _facet The facet address.
+    /// @return facetFunctionSelectors_
+    function facetFunctionSelectors(
+        address _facet
+    ) external view returns (bytes4[] memory facetFunctionSelectors_);
+
+    /// @notice Get all the facet addresses used by a diamond.
+    /// @return facetAddresses_
+    function facetAddresses() external view returns (address[] memory facetAddresses_);
+
+    /// @notice Gets the facet that supports the given selector.
+    /// @dev If facet is not found return address(0).
+    /// @param _functionSelector The function selector.
+    /// @return facetAddress_ The facet address.
+    function facetAddress(bytes4 _functionSelector) external view returns (address facetAddress_);
+}

package/contracts/interfaces/IERC4626.sol

@@ -29,11 +29,9 @@ interface IERC4626 is IERC20Metadata {
 
     function deposit(uint256 assets, address receiver) external returns (uint256);
 
-    function redeem(
-        uint256 shares,
-        address receiver,
-        address owner
-    ) external returns (uint256);
+    function redeem(uint256 shares, address receiver, address owner) external returns (uint256);
 
     function convertToAssets(uint256 shares) external view returns (uint256);
+
+    function previewDeposit(uint256 assets) external view returns (uint256);
 }

package/contracts/interfaces/IPActionAddRemoveLiq.sol

@@ -2,7 +2,7 @@
 pragma solidity 0.8.17;
 
 import "../router/base/MarketApproxLib.sol";
-import "../router/kyberswap/KyberSwapHelper.sol";
+import "../router/base/ActionBaseMintRedeem.sol";
 
 interface IPActionAddRemoveLiq {
     event AddLiquidityDualSyAndPt(
@@ -49,6 +49,25 @@ interface IPActionAddRemoveLiq {
         uint256 netLpOut
     );
 
+    event AddLiquiditySingleSyKeepYt(
+        address indexed caller,
+        address indexed market,
+        address indexed receiver,
+        uint256 netSyIn,
+        uint256 netLpOut,
+        uint256 netYtOut
+    );
+
+    event AddLiquiditySingleTokenKeepYt(
+        address indexed caller,
+        address indexed market,
+        address indexed token,
+        address receiver,
+        uint256 netTokenIn,
+        uint256 netLpOut,
+        uint256 netYtOut
+    );
+
     event RemoveLiquidityDualSyAndPt(
         address indexed caller,
         address indexed market,
@@ -99,13 +118,7 @@ interface IPActionAddRemoveLiq {
         uint256 netSyDesired,
         uint256 netPtDesired,
         uint256 minLpOut
-    )
-        external
-        returns (
-            uint256 netLpOut,
-            uint256 netSyUsed,
-            uint256 netPtUsed
-        );
+    ) external returns (uint256 netLpOut, uint256 netSyUsed, uint256 netPtUsed);
 
     function addLiquidityDualTokenAndPt(
         address receiver,
@@ -113,14 +126,7 @@ interface IPActionAddRemoveLiq {
         TokenInput calldata input,
         uint256 netPtDesired,
         uint256 minLpOut
-    )
-        external
-        payable
-        returns (
-            uint256 netLpOut,
-            uint256 netTokenUsed,
-            uint256 netPtUsed
-        );
+    ) external payable returns (uint256 netLpOut, uint256 netTokenUsed, uint256 netPtUsed);
 
     function addLiquiditySinglePt(
         address receiver,
@@ -146,6 +152,22 @@ interface IPActionAddRemoveLiq {
         TokenInput calldata input
     ) external payable returns (uint256 netLpOut, uint256 netSyFee);
 
+    function addLiquiditySingleSyKeepYt(
+        address receiver,
+        address market,
+        uint256 netSyIn,
+        uint256 minLpOut,
+        uint256 minYtOut
+    ) external returns (uint256 netLpOut, uint256 netYtOut);
+
+    function addLiquiditySingleTokenKeepYt(
+        address receiver,
+        address market,
+        uint256 minLpOut,
+        uint256 minYtOut,
+        TokenInput calldata input
+    ) external returns (uint256 netLpOut, uint256 netYtOut);
+
     function removeLiquidityDualSyAndPt(
         address receiver,
         address market,

package/contracts/interfaces/IPActionInfoStatic.sol

@@ -0,0 +1,43 @@
+pragma solidity ^0.8.17;
+
+interface IPActionInfoStatic {
+    struct TokenAmount {
+        address token;
+        uint256 amount;
+    }
+
+    struct UserSYInfo {
+        TokenAmount syBalance;
+        TokenAmount[] unclaimedRewards;
+    }
+
+    struct UserPYInfo {
+        TokenAmount ptBalance;
+        TokenAmount ytBalance;
+        TokenAmount unclaimedInterest;
+        TokenAmount[] unclaimedRewards;
+    }
+
+    struct UserMarketInfo {
+        TokenAmount lpBalance;
+        TokenAmount ptBalance;
+        TokenAmount syBalance;
+        TokenAmount[] unclaimedRewards;
+    }
+
+    function getPY(address py) external view returns (address pt, address yt);
+
+    /// can be SY, PY or Market
+    function getTokensInOut(
+        address token
+    ) external view returns (address[] memory tokensIn, address[] memory tokensOut);
+
+    function getUserSYInfo(address sy, address user) external returns (UserSYInfo memory res);
+
+    function getUserPYInfo(address py, address user) external returns (UserPYInfo memory res);
+
+    function getUserMarketInfo(
+        address market,
+        address user
+    ) external returns (UserMarketInfo memory res);
+}

package/contracts/interfaces/IPActionMarketAuxStatic.sol

@@ -0,0 +1,34 @@
+pragma solidity ^0.8.17;
+
+import "./IPMarket.sol";
+
+interface IPActionMarketAuxStatic {
+    function calcPriceImpactPY(address market, int256 netPtOut) external returns (uint256);
+
+    function calcPriceImpactPt(address market, int256 netPtOut) external returns (uint256);
+
+    function calcPriceImpactYt(address market, int256 netPtOut) external returns (uint256);
+
+    function getMarketState(
+        address market
+    )
+        external
+        returns (
+            address pt,
+            address yt,
+            address sy,
+            int256 impliedYield,
+            uint256 marketExchangeRateExcludeFee,
+            MarketState memory state
+        );
+
+    function getTradeExchangeRateExcludeFee(
+        address market,
+        MarketState memory state
+    ) external returns (uint256);
+
+    function getTradeExchangeRateIncludeFee(
+        address market,
+        int256 netPtOut
+    ) external returns (uint256);
+}

package/contracts/interfaces/IPActionMarketCoreStatic.sol

@@ -0,0 +1,335 @@
+pragma solidity ^0.8.17;
+
+interface IPActionMarketCoreStatic {
+    function addLiquidityDualSyAndPtStatic(
+        address market,
+        uint256 netSyDesired,
+        uint256 netPtDesired
+    ) external view 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
+        );
+
+    function addLiquiditySinglePtStatic(
+        address market,
+        uint256 netPtIn
+    )
+        external
+        returns (
+            uint256 netLpOut,
+            uint256 netPtToSwap,
+            uint256 netSyFee,
+            uint256 priceImpact,
+            uint256 exchangeRateAfter,
+            uint256 netSyFromSwap
+        );
+
+    function addLiquiditySingleSyKeepYtStatic(
+        address market,
+        uint256 netSyIn
+    ) external returns (uint256 netLpOut, uint256 netYtOut, uint256 netSyToPY);
+
+    function addLiquiditySingleSyStatic(
+        address market,
+        uint256 netSyIn
+    )
+        external
+        returns (
+            uint256 netLpOut,
+            uint256 netPtFromSwap,
+            uint256 netSyFee,
+            uint256 priceImpact,
+            uint256 exchangeRateAfter,
+            uint256 netSyToSwap
+        );
+
+    function addLiquiditySingleTokenKeepYtStatic(
+        address market,
+        address tokenIn,
+        uint256 netTokenIn,
+        address bulk
+    )
+        external
+        returns (uint256 netLpOut, uint256 netYtOut, uint256 netSyMinted, uint256 netSyToPY);
+
+    function addLiquiditySingleTokenStatic(
+        address market,
+        address tokenIn,
+        uint256 netTokenIn,
+        address bulk
+    )
+        external
+        returns (
+            uint256 netLpOut,
+            uint256 netPtFromSwap,
+            uint256 netSyFee,
+            uint256 priceImpact,
+            uint256 exchangeRateAfter,
+            uint256 netSyMinted,
+            uint256 netSyToSwap
+        );
+
+    function removeLiquidityDualSyAndPtStatic(
+        address market,
+        uint256 netLpToRemove
+    ) external view returns (uint256 netSyOut, uint256 netPtOut);
+
+    function removeLiquidityDualTokenAndPtStatic(
+        address market,
+        uint256 netLpToRemove,
+        address tokenOut,
+        address bulk
+    ) external view returns (uint256 netTokenOut, uint256 netPtOut, uint256 netSyToRedeem);
+
+    function removeLiquiditySinglePtStatic(
+        address market,
+        uint256 netLpToRemove
+    )
+        external
+        returns (
+            uint256 netPtOut,
+            uint256 netPtFromSwap,
+            uint256 netSyFee,
+            uint256 priceImpact,
+            uint256 exchangeRateAfter,
+            uint256 netSyFromBurn,
+            uint256 netPtFromBurn
+        );
+
+    function removeLiquiditySingleSyStatic(
+        address market,
+        uint256 netLpToRemove
+    )
+        external
+        returns (
+            uint256 netSyOut,
+            uint256 netSyFee,
+            uint256 priceImpact,
+            uint256 exchangeRateAfter,
+            uint256 netSyFromBurn,
+            uint256 netPtFromBurn,
+            uint256 netSyFromSwap
+        );
+
+    function removeLiquiditySingleTokenStatic(
+        address market,
+        uint256 netLpToRemove,
+        address tokenOut,
+        address bulk
+    )
+        external
+        returns (
+            uint256 netTokenOut,
+            uint256 netSyFee,
+            uint256 priceImpact,
+            uint256 exchangeRateAfter,
+            uint256 netSyOut,
+            uint256 netSyFromBurn,
+            uint256 netPtFromBurn,
+            uint256 netSyFromSwap
+        );
+
+    function swapExactPtForSyStatic(
+        address market,
+        uint256 exactPtIn
+    )
+        external
+        returns (
+            uint256 netSyOut,
+            uint256 netSyFee,
+            uint256 priceImpact,
+            uint256 exchangeRateAfter
+        );
+
+    function swapExactPtForTokenStatic(
+        address market,
+        uint256 exactPtIn,
+        address tokenOut,
+        address bulk
+    )
+        external
+        returns (
+            uint256 netTokenOut,
+            uint256 netSyToRedeem,
+            uint256 netSyFee,
+            uint256 priceImpact,
+            uint256 exchangeRateAfter
+        );
+
+    function swapExactPtForYtStatic(
+        address market,
+        uint256 exactPtIn
+    )
+        external
+        returns (
+            uint256 netYtOut,
+            uint256 totalPtToSwap,
+            uint256 netSyFee,
+            uint256 priceImpact,
+            uint256 exchangeRateAfter
+        );
+
+    function swapExactSyForPtStatic(
+        address market,
+        uint256 exactSyIn
+    )
+        external
+        returns (
+            uint256 netPtOut,
+            uint256 netSyFee,
+            uint256 priceImpact,
+            uint256 exchangeRateAfter
+        );
+
+    function swapExactSyForYtStatic(
+        address market,
+        uint256 exactSyIn
+    )
+        external
+        returns (
+            uint256 netYtOut,
+            uint256 netSyFee,
+            uint256 priceImpact,
+            uint256 exchangeRateAfter
+        );
+
+    function swapExactTokenForPtStatic(
+        address market,
+        address tokenIn,
+        uint256 amountTokenIn,
+        address bulk
+    )
+        external
+        returns (
+            uint256 netPtOut,
+            uint256 netSyMinted,
+            uint256 netSyFee,
+            uint256 priceImpact,
+            uint256 exchangeRateAfter
+        );
+
+    function swapExactTokenForYtStatic(
+        address market,
+        address tokenIn,
+        uint256 amountTokenIn,
+        address bulk
+    )
+        external
+        returns (
+            uint256 netYtOut,
+            uint256 netSyMinted,
+            uint256 netSyFee,
+            uint256 priceImpact,
+            uint256 exchangeRateAfter
+        );
+
+    function swapExactYtForPtStatic(
+        address market,
+        uint256 exactYtIn
+    )
+        external
+        returns (
+            uint256 netPtOut,
+            uint256 totalPtSwapped,
+            uint256 netSyFee,
+            uint256 priceImpact,
+            uint256 exchangeRateAfter
+        );
+
+    function swapExactYtForSyStatic(
+        address market,
+        uint256 exactYtIn
+    )
+        external
+        returns (
+            uint256 netSyOut,
+            uint256 netSyFee,
+            uint256 priceImpact,
+            uint256 exchangeRateAfter,
+            uint256 netSyOwedInt,
+            uint256 netPYToRepaySyOwedInt,
+            uint256 netPYToRedeemSyOutInt
+        );
+
+    function swapExactYtForTokenStatic(
+        address market,
+        uint256 exactYtIn,
+        address tokenOut,
+        address bulk
+    )
+        external
+        returns (
+            uint256 netTokenOut,
+            uint256 netSyFee,
+            uint256 priceImpact,
+            uint256 exchangeRateAfter,
+            uint256 netSyOut,
+            uint256 netSyOwedInt,
+            uint256 netPYToRepaySyOwedInt,
+            uint256 netPYToRedeemSyOutInt
+        );
+
+    function swapPtForExactSyStatic(
+        address market,
+        uint256 exactSyOut
+    )
+        external
+        returns (
+            uint256 netPtIn,
+            uint256 netSyFee,
+            uint256 priceImpact,
+            uint256 exchangeRateAfter
+        );
+
+    function swapSyForExactPtStatic(
+        address market,
+        uint256 exactPtOut
+    )
+        external
+        returns (
+            uint256 netSyIn,
+            uint256 netSyFee,
+            uint256 priceImpact,
+            uint256 exchangeRateAfter
+        );
+
+    function swapSyForExactYtStatic(
+        address market,
+        uint256 exactYtOut
+    )
+        external
+        returns (
+            uint256 netSyIn,
+            uint256 netSyFee,
+            uint256 priceImpact,
+            uint256 exchangeRateAfter,
+            uint256 netSyReceivedInt,
+            uint256 totalSyNeedInt
+        );
+
+    function swapYtForExactSyStatic(
+        address market,
+        uint256 exactSyOut
+    )
+        external
+        returns (
+            uint256 netYtIn,
+            uint256 netSyFee,
+            uint256 priceImpact,
+            uint256 exchangeRateAfter
+        );
+}