@pendle/core-v2 1.2.0-mainnet → 1.2.0-testnet

package/contracts/core/libraries/ArrayLib.sol

@@ -13,24 +13,16 @@ library ArrayLib {
         return value;
     }
 
-    function max(uint256[] memory input) internal pure returns (uint256 value) {
-        for (uint256 i = 0; i < input.length; ) {
-            if (input[i] > value) value = input[i];
-            unchecked {
-                i++;
-            }
-        }
-    }
-
-    function contains(address[] memory array, address element) internal pure returns (bool) {
+    /// @notice return index of the element if found, else return uint256.max
+    function find(address[] memory array, address element) internal pure returns (uint256 index) {
         uint256 length = array.length;
         for (uint256 i = 0; i < length; ) {
-            if (array[i] == element) return true;
+            if (array[i] == element) return i;
             unchecked {
                 i++;
             }
         }
-        return false;
+        return type(uint256).max;
     }
 
     function append(address[] memory inp, address element)
@@ -48,4 +40,27 @@ library ArrayLib {
         }
         out[length] = element;
     }
+
+    // various version of contains
+    function contains(address[] memory array, address element) internal pure returns (bool) {
+        uint256 length = array.length;
+        for (uint256 i = 0; i < length; ) {
+            if (array[i] == element) return true;
+            unchecked {
+                i++;
+            }
+        }
+        return false;
+    }
+
+    function contains(bytes4[] memory array, bytes4 element) internal pure returns (bool) {
+        uint256 length = array.length;
+        for (uint256 i = 0; i < length; ) {
+            if (array[i] == element) return true;
+            unchecked {
+                i++;
+            }
+        }
+        return false;
+    }
 }

package/contracts/core/libraries/Errors.sol

@@ -1,8 +1,6 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity 0.8.17;
 
-/// Adapted from UniswapV3's Oracle
-
 library Errors {
     // BulkSeller
     error BulkInsufficientSyForTrade(uint256 currentAmount, uint256 requiredAmount);
@@ -75,6 +73,7 @@ library Errors {
     error RouterTimeRangeZero();
     error RouterCallbackNotPendleMarket(address caller);
     error RouterInvalidAction(bytes4 selector);
+    error RouterInvalidFacet(address facet);
 
     error RouterKyberSwapDataZero();
 
@@ -112,6 +111,8 @@ library Errors {
     error SYCurve3crvPoolNotFound();
 
     error SYApeDepositAmountTooSmall(uint256 amountDeposited);
+    error SYBalancerInvalidPid();
+    error SYInvalidRewardToken(address token);
 
     // Liquidity Mining
     error VCInactivePool(address pool);
@@ -161,9 +162,14 @@ library Errors {
     error ArrayEmpty();
     error ArrayOutOfBounds();
     error ZeroAddress();
+    error FailedToSendEther();
 
     error OnlyLayerZeroEndpoint();
     error OnlyYT();
     error OnlyYCFactory();
     error OnlyWhitelisted();
+
+    // Swap Aggregator
+    error SAInsufficientTokenIn(address tokenIn, uint256 amountExpected, uint256 amountActual);
+    error UnsupportedSelector(uint256 aggregatorType, bytes4 selector);
 }

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/Balancer/IAsset.sol

@@ -0,0 +1,4 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+interface IAsset {}

package/contracts/interfaces/Balancer/IBalancerFees.sol

@@ -0,0 +1,6 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+interface IBalancerFees {
+    function getSwapFeePercentage() external view returns (uint256);
+}

package/contracts/interfaces/Balancer/IBalancerStablePreview.sol

@@ -0,0 +1,22 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+import "./IVault.sol";
+
+interface IBalancerStablePreview {
+    function joinPoolPreview(
+        bytes32 poolId,
+        address sender,
+        address recipient,
+        IVault.JoinPoolRequest memory request,
+        bytes memory data
+    ) external view returns (uint256 amountBptOut);
+
+    function exitPoolPreview(
+        bytes32 poolId,
+        address sender,
+        address recipient,
+        IVault.ExitPoolRequest memory request,
+        bytes memory data
+    ) external view returns (uint256 amountTokenOut);
+}

package/contracts/interfaces/Balancer/IBasePool.sol

@@ -0,0 +1,30 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+
+interface IBasePool is IERC20 {
+    function onJoinPool(
+        bytes32 poolId,
+        address sender,
+        address recipient,
+        uint256[] memory balances,
+        uint256 lastChangeBlock,
+        uint256 protocolSwapFeePercentage,
+        bytes memory userData
+    ) external returns (uint256[] memory amountsIn, uint256[] memory dueProtocolFeeAmounts);
+
+    function onExitPool(
+        bytes32 poolId,
+        address sender,
+        address recipient,
+        uint256[] memory balances,
+        uint256 lastChangeBlock,
+        uint256 protocolSwapFeePercentage,
+        bytes memory userData
+    ) external returns (uint256[] memory amountsOut, uint256[] memory dueProtocolFeeAmounts);
+
+    function getPoolId() external view returns (bytes32);
+
+    function getSwapFeePercentage() external view returns (uint256);
+}

package/contracts/interfaces/Balancer/IComposableStable.sol

@@ -0,0 +1,39 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+import "./IBasePool.sol";
+import "./IRateProvider.sol";
+
+interface IComposableStable is IBasePool {
+    function getLastJoinExitData()
+        external
+        view
+        returns (uint256 lastJoinExitAmplification, uint256 lastPostJoinExitInvariant);
+
+    function getAmplificationParameter()
+        external
+        view
+        returns (
+            uint256 value,
+            bool isUpdating,
+            uint256 precision
+        );
+
+    function getProtocolFeePercentageCache(uint256 feeType) external view returns (uint256);
+
+    function isTokenExemptFromYieldProtocolFee(IERC20 token) external view returns (bool);
+
+    function getTokenRateCache(IERC20 token)
+        external
+        view
+        returns (
+            uint256 rate,
+            uint256 oldRate,
+            uint256 duration,
+            uint256 expires
+        );
+
+    function getRateProviders() external view returns (IRateProvider[] memory);
+
+    function getBptIndex() external view returns (uint256);
+}

package/contracts/interfaces/Balancer/IGauge.sol

@@ -0,0 +1,10 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+interface IGauge {
+    function claim_rewards(address _addr, address _receiver) external;
+
+    function reward_count() external view returns (uint256);
+
+    function reward_tokens(uint256 arg0) external view returns (address);
+}

package/contracts/interfaces/Balancer/ILiquidityGaugeFactory.sol

@@ -0,0 +1,6 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+interface ILiquidityGaugeFactory {
+    function getPoolGauge(address poolAddress) external view returns (address);
+}

package/contracts/interfaces/Balancer/IMetaStablePool.sol

@@ -0,0 +1,31 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+import "./IBasePool.sol";
+
+interface IMetaStablePool is IBasePool {
+    function getLastInvariant()
+        external
+        view
+        returns (uint256 lastInvariant, uint256 lastInvariantAmp);
+
+    function getAmplificationParameter()
+        external
+        view
+        returns (
+            uint256 value,
+            bool isUpdating,
+            uint256 precision
+        );
+
+    function getSwapFeePercentage() external view returns (uint256);
+
+    function getPriceRateCache(IERC20 token)
+        external
+        view
+        returns (
+            uint256 rate,
+            uint256 duration,
+            uint256 expires
+        );
+}

package/contracts/interfaces/Balancer/IRateProvider.sol

@@ -0,0 +1,6 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+interface IRateProvider {
+    function getRate() external view returns (uint256);
+}

package/contracts/interfaces/Balancer/IVault.sol

@@ -0,0 +1,78 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import "./IAsset.sol";
+
+interface IVault {
+    struct JoinPoolRequest {
+        address[] assets;
+        uint256[] maxAmountsIn;
+        bytes userData;
+        bool fromInternalBalance;
+    }
+
+    function joinPool(
+        bytes32 poolId,
+        address sender,
+        address recipient,
+        JoinPoolRequest memory request
+    ) external payable;
+
+    struct ExitPoolRequest {
+        address[] assets;
+        uint256[] minAmountsOut;
+        bytes userData;
+        bool toInternalBalance;
+    }
+
+    function exitPool(
+        bytes32 poolId,
+        address sender,
+        address payable recipient,
+        ExitPoolRequest memory request
+    ) external;
+
+    enum SwapKind {
+        GIVEN_IN,
+        GIVEN_OUT
+    }
+
+    struct SingleSwap {
+        bytes32 poolId;
+        SwapKind kind;
+        IAsset assetIn;
+        IAsset assetOut;
+        uint256 amount;
+        bytes userData;
+    }
+
+    struct FundManagement {
+        address sender;
+        bool fromInternalBalance;
+        address payable recipient;
+        bool toInternalBalance;
+    }
+
+    function swap(
+        SingleSwap memory singleSwap,
+        FundManagement memory funds,
+        uint256 limit,
+        uint256 deadline
+    ) external payable returns (uint256);
+
+    function getPoolTokens(bytes32 poolId)
+        external
+        view
+        returns (
+            IERC20[] memory tokens,
+            uint256[] memory balances,
+            uint256 lastChangeBlock
+        );
+
+    function WETH() external view returns (IERC20);
+
+    function getPool(bytes32 poolId) external view returns (address, uint8);
+
+    function getProtocolFeesCollector() external view returns (address);
+}

package/contracts/interfaces/ConvexCurve/IRewards.sol

@@ -14,6 +14,11 @@ interface IRewards {
 
     function exit(address) external;
 
+    function getReward(
+        address, /*_account*/
+        bool /*_claimExtras*/
+    ) external;
+
     function getReward() external;
 
     function queueNewRewards(uint256) external;

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,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/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/IERC4626.sol

@@ -36,4 +36,6 @@ interface IERC4626 is IERC20Metadata {
     ) 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,
@@ -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,