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

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/offchain-helpers/PendleMulticall.sol

@@ -0,0 +1,26 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.17;
+
+/// @title PendleMulticall - A more gas-efficient version of Multicall3 (~700 gas saved for each call)
+/// @author UncleGrandpa925 <longvh@pendle.finance>
+contract PendleMulticall {
+    error MulticallFailed(uint256 index);
+
+    struct Call {
+        address target;
+        bytes callData;
+    }
+
+    function aggregate(Call[] calldata calls) external payable {
+        uint256 length = calls.length;
+        Call calldata call;
+        for (uint256 i = 0; i < length; ) {
+            call = calls[i];
+            (bool success, ) = call.target.call(call.callData);
+            if (!success) revert MulticallFailed(i);
+            unchecked {
+                ++i;
+            }
+        }
+    }
+}