@pendle/core-v2 0.21.0-testnet → 1.0.0-testnet

package/contracts/core/libraries/TokenHelper.sol

@@ -2,6 +2,7 @@
 pragma solidity 0.8.17;
 import "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
 import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
+import "../../interfaces/IWETH.sol";
 
 abstract contract TokenHelper {
     using SafeERC20 for IERC20;
@@ -83,4 +84,13 @@ abstract contract TokenHelper {
             _safeApprove(token, to, type(uint256).max);
         }
     }
+
+    function _wrap_unwrap_ETH(
+        address tokenIn,
+        address tokenOut,
+        uint256 netTokenIn
+    ) internal {
+        if (tokenIn == NATIVE) IWETH(tokenOut).deposit{ value: netTokenIn }();
+        else IWETH(tokenIn).withdraw(netTokenIn);
+    }
 }

package/contracts/interfaces/GMX/IGMXVault.sol

@@ -0,0 +1,47 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+interface IGMXVault {
+    function BASIS_POINTS_DIVISOR() external view returns (uint256);
+
+    function PRICE_PRECISION() external view returns (uint256);
+
+    function priceFeed() external view returns (address);
+
+    function usdg() external view returns (address);
+
+    function hasDynamicFees() external view returns (bool);
+
+    function totalTokenWeights() external view returns (uint256);
+
+    function tokenBalances(address) external view returns (uint256);
+
+    function usdgAmounts(address) external view returns (uint256);
+
+    function getMinPrice(address _token) external view returns (uint256);
+
+    function getRedemptionAmount(address _token, uint256 _usdgAmount)
+        external
+        view
+        returns (uint256);
+
+    function taxBasisPoints() external view returns (uint256);
+
+    function mintBurnFeeBasisPoints() external view returns (uint256);
+
+    function allWhitelistedTokensLength() external view returns (uint256);
+
+    function allWhitelistedTokens(uint256) external view returns (address);
+
+    function whitelistedTokens(address) external view returns (bool);
+
+    function whitelistedTokenCount() external view returns (uint256);
+
+    function tokenWeights(address _token) external view returns (uint256);
+
+    function adjustForDecimals(
+        uint256 _amount,
+        address _tokenDiv,
+        address _tokenMul
+    ) external view returns (uint256);
+}

package/contracts/interfaces/GMX/IGlpManager.sol

@@ -0,0 +1,8 @@
+// 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);
+}

package/contracts/interfaces/GMX/IRewardRouterV2.sol

@@ -0,0 +1,35 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+interface IRewardRouterV2 {
+    function weth() external view returns (address);
+
+    function claim() 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/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,38 @@
+// 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/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,
@@ -146,6 +165,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/IPActionMintRedeem.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 IPActionMintRedeem {
     event MintSyFromToken(
@@ -57,26 +57,6 @@ interface IPActionMintRedeem {
         uint256 netTokenOut
     );
 
-    event RedeemDueInterestAndRewards(
-        address indexed user,
-        address[] sys,
-        address[] yts,
-        address[] markets,
-        uint256[][] syRewards,
-        uint256[] ytInterests,
-        uint256[][] ytRewards,
-        uint256[][] marketRewards
-    );
-
-    event RedeemDueInterestAndRewardsThenSwapAll(
-        address indexed user,
-        address[] sys,
-        address[] yts,
-        address[] markets,
-        address indexed tokenOut,
-        uint256 netTokenOut
-    );
-
     function mintSyFromToken(
         address receiver,
         address SY,
@@ -124,38 +104,5 @@ interface IPActionMintRedeem {
         address[] calldata sys,
         address[] calldata yts,
         address[] calldata markets
-    )
-        external
-        returns (
-            uint256[][] memory syRewards,
-            uint256[] memory ytInterests,
-            uint256[][] memory ytRewards,
-            uint256[][] memory marketRewards
-        );
-
-    struct RouterYtRedeemStruct {
-        address[] yts;
-        // key-value pair
-        address[] syAddrs;
-        address[] tokenRedeemSys;
-        address[] bulks;
-        //
-    }
-
-    struct RouterSwapAllStruct {
-        // key-value pair
-        address[] tokens;
-        bytes[] kybercalls;
-        //
-        address kyberRouter;
-        address outputToken;
-        uint256 minTokenOut;
-    }
-
-    function redeemDueInterestAndRewardsThenSwapAll(
-        address[] calldata sys,
-        RouterYtRedeemStruct calldata dataYT,
-        address[] calldata markets,
-        RouterSwapAllStruct calldata dataSwap
-    ) external returns (uint256 netTokenOut, uint256[] memory amountsSwapped);
+    ) external;
 }

package/contracts/interfaces/IPActionMisc.sol

@@ -2,8 +2,25 @@
 pragma solidity 0.8.17;
 
 interface IPActionMisc {
-    function consult(address market, uint32 secondsAgo)
+    struct MultiApproval {
+        address[] tokens;
+        address spender;
+    }
+
+    struct Call3 {
+        bool allowFailure;
+        bytes callData;
+    }
+
+    struct Result {
+        bool success;
+        bytes returnData;
+    }
+
+    function approveInf(MultiApproval[] calldata) external;
+
+    function batchExec(Call3[] calldata calls)
         external
-        view
-        returns (uint96 lnImpliedRateMean);
+        payable
+        returns (Result[] memory returnData);
 }

package/contracts/interfaces/IPActionSwapPT.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 IPActionSwapPT {
     event SwapPtAndSy(

package/contracts/interfaces/IPActionSwapYT.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 IPActionSwapYT {
     event SwapYtAndSy(
@@ -22,12 +22,20 @@ interface IPActionSwapYT {
         int256 netTokenToAccount
     );
 
+    event SwapPtAndYt(
+        address indexed caller,
+        address indexed market,
+        address indexed receiver,
+        int256 netPtToAccount,
+        int256 netYtToAccount
+    );
+
     function swapExactSyForYt(
         address receiver,
         address market,
         uint256 exactSyIn,
         uint256 minYtOut,
-        ApproxParams memory guessYtOut
+        ApproxParams calldata guessYtOut
     ) external returns (uint256 netYtOut, uint256 netSyFee);
 
     function swapExactYtForSy(
@@ -49,14 +57,14 @@ interface IPActionSwapYT {
         address market,
         uint256 exactSyOut,
         uint256 maxYtIn,
-        ApproxParams memory guessYtIn
+        ApproxParams calldata guessYtIn
     ) external returns (uint256 netYtIn, uint256 netSyFee);
 
     function swapExactTokenForYt(
         address receiver,
         address market,
         uint256 minYtOut,
-        ApproxParams memory guessYtOut,
+        ApproxParams calldata guessYtOut,
         TokenInput calldata input
     ) external payable returns (uint256 netYtOut, uint256 netSyFee);
 
@@ -66,4 +74,20 @@ interface IPActionSwapYT {
         uint256 netYtIn,
         TokenOutput calldata output
     ) external returns (uint256 netTokenOut, uint256 netSyFee);
+
+    function swapExactPtForYt(
+        address receiver,
+        address market,
+        uint256 exactPtIn,
+        uint256 minYtOut,
+        ApproxParams calldata guessTotalPtToSwap
+    ) external returns (uint256 netYtOut, uint256 netSyFee);
+
+    function swapExactYtForPt(
+        address receiver,
+        address market,
+        uint256 exactYtIn,
+        uint256 minPtOut,
+        ApproxParams calldata guessTotalPtSwapped
+    ) external returns (uint256 netPtOut, uint256 netSyFee);
 }

package/contracts/interfaces/IPAllAction.sol

@@ -5,15 +5,17 @@ pragma solidity 0.8.17;
 import "./IPActionAddRemoveLiq.sol";
 import "./IPActionSwapPT.sol";
 import "./IPActionSwapYT.sol";
-import "./IPActionSwapPTYT.sol";
 import "./IPActionMintRedeem.sol";
 import "./IPActionMisc.sol";
+import "./IPMarketSwapCallback.sol";
+import "./IDiamondLoupe.sol";
 
 interface IPAllAction is
     IPActionAddRemoveLiq,
     IPActionSwapPT,
     IPActionSwapYT,
-    IPActionSwapPTYT,
     IPActionMintRedeem,
-    IPActionMisc
+    IPActionMisc,
+    IPMarketSwapCallback,
+    IDiamondLoupe
 {}

package/contracts/interfaces/IPInterestManagerYTV2.sol

@@ -0,0 +1,13 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+interface IPInterestManagerYTV2 {
+    function userInterest(address user)
+        external
+        view
+        returns (
+            uint128 lastInterestIndex,
+            uint128 accruedInterest,
+            uint256 lastPYIndex
+        );
+}

package/contracts/interfaces/IPYieldTokenV2.sol

@@ -0,0 +1,66 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+import "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
+import "./IRewardManager.sol";
+import "./IPInterestManagerYTV2.sol";
+
+interface IPYieldTokenV2 is IERC20Metadata, IRewardManager, IPInterestManagerYTV2 {
+    event Mint(
+        address indexed caller,
+        address indexed receiverPT,
+        address indexed receiverYT,
+        uint256 amountSyToMint,
+        uint256 amountPYOut
+    );
+
+    event Burn(
+        address indexed caller,
+        address indexed receiver,
+        uint256 amountPYToRedeem,
+        uint256 amountSyOut
+    );
+
+    event RedeemRewards(address indexed user, uint256[] amountRewardsOut);
+
+    event RedeemInterest(address indexed user, uint256 interestOut);
+
+    event WithdrawFeeToTreasury(uint256[] amountRewardsOut, uint256 syOut);
+
+    event CollectInterestFee(uint256 amountInterestFee);
+
+    event CollectRewardFee(address indexed rewardToken, uint256 amountRewardFee);
+
+    function mintPY(address receiverPT, address receiverYT) external returns (uint256 amountPYOut);
+
+    function redeemPY(address receiver) external returns (uint256 amountSyOut);
+
+    function redeemPYMulti(address[] calldata receivers, uint256[] calldata amountPYToRedeems)
+        external
+        returns (uint256[] memory amountSyOuts);
+
+    function redeemDueInterestAndRewards(
+        address user,
+        bool redeemInterest,
+        bool redeemRewards
+    ) external returns (uint256 interestOut, uint256[] memory rewardsOut);
+
+    function rewardIndexesCurrent() external returns (uint256[] memory);
+
+    function pyIndexCurrent() external returns (uint256);
+
+    function pyIndexStored() external view returns (uint256);
+
+    function getRewardTokens() external view returns (address[] memory);
+
+    function SY() external view returns (address);
+
+    function PT() external view returns (address);
+
+    function factory() external view returns (address);
+
+    function expiry() external view returns (uint256);
+
+    function isExpired() external view returns (bool);
+
+    function doCacheIndexSameBlock() external view returns (bool);
+}

package/contracts/offchain-helpers/MarketMathStatic.sol

@@ -118,6 +118,21 @@ library MarketMathStatic {
         exchangeRateAfter = _getTradeExchangeRateExcludeFee(market, state);
     }
 
+    function addLiquiditySingleSyKeepYtStatic(address market, uint256 netSyIn)
+        public
+        returns (uint256 netLpOut, uint256 netYtOut)
+    {
+        MarketState memory state = IPMarket(market).readState(address(this));
+        PYIndex index = pyIndex(market);
+
+        uint256 netSyToPt = (netSyIn * state.totalPt.Uint()) /
+            (state.totalPt.Uint() + index.syToAsset(state.totalSy.Uint()));
+
+        netYtOut = index.syToAsset(netSyToPt);
+
+        (, netLpOut, , ) = state.addLiquidity(netSyIn - netSyToPt, netYtOut, block.timestamp);
+    }
+
     function removeLiquidityDualSyAndPtStatic(address market, uint256 netLpToRemove)
         external
         view

package/contracts/offchain-helpers/RouterStatic.sol

@@ -368,6 +368,28 @@ contract RouterStatic is Initializable, Proxy, BoringOwnableUpgradeable, UUPSUpg
         return MarketMathStatic.addLiquiditySingleSyStatic(market, netSyIn);
     }
 
+    function addLiquiditySingleSyKeepYtStatic(address market, uint256 netSyIn)
+        external
+        returns (uint256 netLpOut, uint256 netYtOut)
+    {
+        return MarketMathStatic.addLiquiditySingleSyKeepYtStatic(market, netSyIn);
+    }
+
+    function addLiquiditySingleTokenKeepYtStatic(
+        address market,
+        address baseToken,
+        uint256 netBaseTokenIn,
+        address bulk
+    ) external returns (uint256 netLpOut, uint256 netYtOut) {
+        uint256 netSyIn = previewDepositStatic(
+            getSyMarket(market),
+            baseToken,
+            netBaseTokenIn,
+            bulk
+        );
+        return MarketMathStatic.addLiquiditySingleSyKeepYtStatic(market, netSyIn);
+    }
+
     function removeLiquidityDualSyAndPtStatic(address market, uint256 netLpToRemove)
         external
         view