@pendle/core-v2 0.20.1-testnet → 0.20.2-testnet

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

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(
@@ -145,9 +145,8 @@ interface IPActionMintRedeem {
     struct RouterSwapAllStruct {
         // key-value pair
         address[] tokens;
-        bytes[] kybercalls;
+        SwapData[] data;
         //
-        address kyberRouter;
         address outputToken;
         uint256 minTokenOut;
     }

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/IPActionSwapPTYT.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 IPActionSwapPTYT {
     event SwapPtAndYt(

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(

package/contracts/interfaces/IPFeeDistributor.sol

@@ -6,6 +6,8 @@ interface IPFeeDistributor {
 
     event ClaimReward(address indexed pool, address indexed user, uint256 wTime, uint256 amount);
 
+    event PoolAdded(address indexed pool, uint256 indexed startWeek);
+
     struct UserInfo {
         uint128 firstUnclaimedWeek;
         uint128 iter;

package/contracts/offchain-helpers/Multicall2.sol

@@ -0,0 +1,103 @@
+pragma solidity >=0.5.0;
+pragma experimental ABIEncoderV2;
+
+/// @title Multicall2 - Aggregate results from multiple read-only function calls
+/// @author Michael Elliot <mike@makerdao.com>
+/// @author Joshua Levine <joshua@makerdao.com>
+/// @author Nick Johnson <arachnid@notdot.net>
+
+contract Multicall2 {
+    struct Call {
+        address target;
+        bytes callData;
+    }
+    struct Result {
+        bool success;
+        bytes returnData;
+    }
+
+    function aggregate(Call[] memory calls)
+        public
+        returns (uint256 blockNumber, bytes[] memory returnData)
+    {
+        blockNumber = block.number;
+        returnData = new bytes[](calls.length);
+        for (uint256 i = 0; i < calls.length; i++) {
+            (bool success, bytes memory ret) = calls[i].target.call(calls[i].callData);
+            require(success, "Multicall aggregate: call failed");
+            returnData[i] = ret;
+        }
+    }
+
+    function blockAndAggregate(Call[] memory calls)
+        public
+        returns (
+            uint256 blockNumber,
+            bytes32 blockHash,
+            Result[] memory returnData
+        )
+    {
+        (blockNumber, blockHash, returnData) = tryBlockAndAggregate(true, calls);
+    }
+
+    function getBlockHash(uint256 blockNumber) public view returns (bytes32 blockHash) {
+        blockHash = blockhash(blockNumber);
+    }
+
+    function getBlockNumber() public view returns (uint256 blockNumber) {
+        blockNumber = block.number;
+    }
+
+    function getCurrentBlockCoinbase() public view returns (address coinbase) {
+        coinbase = block.coinbase;
+    }
+
+    function getCurrentBlockDifficulty() public view returns (uint256 difficulty) {
+        difficulty = block.difficulty;
+    }
+
+    function getCurrentBlockGasLimit() public view returns (uint256 gaslimit) {
+        gaslimit = block.gaslimit;
+    }
+
+    function getCurrentBlockTimestamp() public view returns (uint256 timestamp) {
+        timestamp = block.timestamp;
+    }
+
+    function getEthBalance(address addr) public view returns (uint256 balance) {
+        balance = addr.balance;
+    }
+
+    function getLastBlockHash() public view returns (bytes32 blockHash) {
+        blockHash = blockhash(block.number - 1);
+    }
+
+    function tryAggregate(bool requireSuccess, Call[] memory calls)
+        public
+        returns (Result[] memory returnData)
+    {
+        returnData = new Result[](calls.length);
+        for (uint256 i = 0; i < calls.length; i++) {
+            (bool success, bytes memory ret) = calls[i].target.call(calls[i].callData);
+
+            if (requireSuccess) {
+                require(success, "Multicall2 aggregate: call failed");
+            }
+
+            returnData[i] = Result(success, ret);
+        }
+    }
+
+    function tryBlockAndAggregate(bool requireSuccess, Call[] memory calls)
+        public
+        returns (
+            uint256 blockNumber,
+            bytes32 blockHash,
+            Result[] memory returnData
+        )
+    {
+        blockNumber = block.number;
+        blockHash = blockhash(block.number);
+        returnData = tryAggregate(requireSuccess, calls);
+    }
+}

package/contracts/router/ActionAddRemoveLiq.sol

@@ -24,8 +24,8 @@ contract ActionAddRemoveLiq is IPActionAddRemoveLiq, ActionBaseMintRedeem {
     using BulkSellerMathCore for BulkSellerState;
 
     /// @dev since this contract will be proxied, it must not contains non-immutable variables
-    constructor(address _kyberScalingLib)
-        ActionBaseMintRedeem(_kyberScalingLib) //solhint-disable-next-line no-empty-blocks
+    constructor(address _swapAggregator)
+        ActionBaseMintRedeem(_swapAggregator) //solhint-disable-next-line no-empty-blocks
     {}
 
     /**

package/contracts/router/ActionMintRedeem.sol

@@ -12,8 +12,8 @@ contract ActionMintRedeem is IPActionMintRedeem, ActionBaseMintRedeem {
     using Math for int256;
 
     /// @dev since this contract will be proxied, it must not contains non-immutable variables
-    constructor(address _kyberScalingLib)
-        ActionBaseMintRedeem(_kyberScalingLib) //solhint-disable-next-line no-empty-blocks
+    constructor(address _swapAggregator)
+        ActionBaseMintRedeem(_swapAggregator) //solhint-disable-next-line no-empty-blocks
     {}
 
     /**
@@ -180,8 +180,7 @@ contract ActionMintRedeem is IPActionMintRedeem, ActionBaseMintRedeem {
         address[] calldata markets,
         RouterSwapAllStruct calldata dataSwap
     ) external returns (uint256 netTokenOut, uint256[] memory amountsSwapped) {
-        if (dataSwap.tokens.length != dataSwap.kybercalls.length)
-            revert Errors.ArrayLengthMismatch();
+        if (dataSwap.tokens.length != dataSwap.data.length) revert Errors.ArrayLengthMismatch();
 
         if (dataYT.tokenRedeemSys.length != dataYT.syAddrs.length)
             revert Errors.ArrayLengthMismatch();
@@ -226,7 +225,7 @@ contract ActionMintRedeem is IPActionMintRedeem, ActionBaseMintRedeem {
             _transferFrom(
                 IERC20(tokensOut.tokens[i]),
                 msg.sender,
-                address(this),
+                swapAggregator,
                 tokensOut.amounts[i]
             );
         }
@@ -270,7 +269,7 @@ contract ActionMintRedeem is IPActionMintRedeem, ActionBaseMintRedeem {
 
             TokenOutput memory output = _wrapTokenOutput(tokenRedeemSys[i], 1, bulks[i]);
             uint256 amountOut = _redeemSyToToken(
-                address(this),
+                swapAggregator,
                 sys.tokens[i],
                 sys.amounts[i],
                 output,
@@ -287,11 +286,10 @@ contract ActionMintRedeem is IPActionMintRedeem, ActionBaseMintRedeem {
     ) internal returns (uint256 netTokenOut) {
         for (uint256 i = 0; i < tokens.tokens.length; ++i) {
             if (tokens.amounts[i] == 0) continue;
-            _kyberswap(
+            ISwapAggregator(swapAggregator).swap(
                 tokens.tokens[i],
                 tokens.amounts[i],
-                dataSwap.kyberRouter,
-                dataSwap.kybercalls[i]
+                dataSwap.data[i]
             );
         }
         netTokenOut = _selfBalance(dataSwap.outputToken);

package/contracts/router/ActionSwapPT.sol

@@ -16,8 +16,8 @@ contract ActionSwapPT is IPActionSwapPT, ActionBaseMintRedeem {
     using PYIndexLib for IPYieldToken;
 
     /// @dev since this contract will be proxied, it must not contains non-immutable variables
-    constructor(address _kyberScalingLib)
-        ActionBaseMintRedeem(_kyberScalingLib) //solhint-disable-next-line no-empty-blocks
+    constructor(address _swapAggregator)
+        ActionBaseMintRedeem(_swapAggregator) //solhint-disable-next-line no-empty-blocks
     {}
 
     /**

package/contracts/router/ActionSwapYT.sol

@@ -17,8 +17,8 @@ contract ActionSwapYT is IPActionSwapYT, ActionBaseMintRedeem, CallbackHelper {
     using PYIndexLib for IPYieldToken;
 
     /// @dev since this contract will be proxied, it must not contains non-immutable variables
-    constructor(address _kyberScalingLib)
-        ActionBaseMintRedeem(_kyberScalingLib) //solhint-disable-next-line no-empty-blocks
+    constructor(address _swapAggregator)
+        ActionBaseMintRedeem(_swapAggregator) //solhint-disable-next-line no-empty-blocks
     {}
 
     /**

package/contracts/router/base/ActionBaseMintRedeem.sol

@@ -1,19 +1,43 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity 0.8.17;
 
-import "../kyberswap/KyberSwapHelper.sol";
 import "../../core/libraries/TokenHelper.sol";
 import "../../interfaces/IStandardizedYield.sol";
 import "../../interfaces/IPYieldToken.sol";
 import "../../interfaces/IPBulkSeller.sol";
 import "../../core/libraries/Errors.sol";
+import "../swap-aggregator/ISwapAggregator.sol";
+
+struct TokenInput {
+    // Token/Sy data
+    address tokenIn;
+    uint256 netTokenIn;
+    address tokenMintSy;
+    address bulk;
+    // aggregator data
+    SwapData data;
+}
+
+struct TokenOutput {
+    // Token/Sy data
+    address tokenOut;
+    uint256 minTokenOut;
+    address tokenRedeemSy;
+    address bulk;
+    // Kyber data
+    SwapData data;
+}
 
 // solhint-disable no-empty-blocks
-abstract contract ActionBaseMintRedeem is TokenHelper, KyberSwapHelper {
+abstract contract ActionBaseMintRedeem is TokenHelper {
     bytes internal constant EMPTY_BYTES = abi.encode();
 
+    address public immutable swapAggregator;
+
     /// @dev since this contract will be proxied, it must not contains non-immutable variables
-    constructor(address _kyberScalingLib) KyberSwapHelper(_kyberScalingLib) {}
+    constructor(address _swapAggregator) {
+        swapAggregator = _swapAggregator;
+    }
 
     function _mintSyFromToken(
         address receiver,
@@ -21,14 +45,23 @@ abstract contract ActionBaseMintRedeem is TokenHelper, KyberSwapHelper {
         uint256 minSyOut,
         TokenInput calldata input
     ) internal returns (uint256 netSyOut) {
-        _transferIn(input.tokenIn, msg.sender, input.netTokenIn);
-
         bool requireSwap = input.tokenIn != input.tokenMintSy;
 
         uint256 netTokenMintSy;
 
+        if (input.tokenIn != NATIVE) {
+            _transferFrom(
+                IERC20(input.tokenIn),
+                msg.sender,
+                requireSwap ? swapAggregator : address(this),
+                input.netTokenIn
+            );
+        }
+
         if (requireSwap) {
-            _kyberswap(input.tokenIn, input.netTokenIn, input.kyberRouter, input.kybercall);
+            ISwapAggregator(swapAggregator).swap{
+                value: input.tokenIn == NATIVE ? input.netTokenIn : 0
+            }(input.tokenIn, input.netTokenIn, input.data);
             netTokenMintSy = _selfBalance(input.tokenMintSy);
         } else {
             netTokenMintSy = input.netTokenIn;
@@ -66,7 +99,7 @@ abstract contract ActionBaseMintRedeem is TokenHelper, KyberSwapHelper {
         }
 
         bool requireSwap = output.tokenRedeemSy != output.tokenOut;
-        address receiverRedeemSy = requireSwap ? address(this) : receiver;
+        address receiverRedeemSy = requireSwap ? swapAggregator : receiver;
         uint256 netTokenRedeemed;
 
         if (output.bulk != address(0)) {
@@ -87,12 +120,9 @@ abstract contract ActionBaseMintRedeem is TokenHelper, KyberSwapHelper {
         }
 
         if (requireSwap) {
-            _kyberswap(
-                output.tokenRedeemSy,
-                netTokenRedeemed,
-                output.kyberRouter,
-                output.kybercall
-            );
+            ISwapAggregator(swapAggregator).swap{
+                value: output.tokenRedeemSy == NATIVE ? netTokenRedeemed : 0
+            }(output.tokenRedeemSy, netTokenRedeemed, output.data);
 
             netTokenOut = _selfBalance(output.tokenOut);
 
@@ -153,6 +183,13 @@ abstract contract ActionBaseMintRedeem is TokenHelper, KyberSwapHelper {
         uint256 minTokenOut,
         address bulk
     ) internal pure returns (TokenOutput memory) {
-        return TokenOutput(tokenOut, minTokenOut, tokenOut, bulk, address(0), EMPTY_BYTES);
+        return
+            TokenOutput(
+                tokenOut,
+                minTokenOut,
+                tokenOut,
+                bulk,
+                SwapData(AGGREGATOR.KYBERSWAP, address(0), EMPTY_BYTES)
+            );
     }
 }

package/contracts/router/swap-aggregator/1inch/I1inchAggregationRouterV5.sol

@@ -0,0 +1,45 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity 0.8.17;
+
+import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
+
+interface I1inchAggregationRouterV5 {
+    struct SwapDescription {
+        IERC20 srcToken;
+        IERC20 dstToken;
+        address payable srcReceiver;
+        address payable dstReceiver;
+        uint256 amount;
+        uint256 minReturnAmount;
+        uint256 flags;
+    }
+
+    function uniswapV3SwapTo(
+        address payable recipient,
+        uint256 amount,
+        uint256 minReturn,
+        uint256[] calldata pools
+    ) external payable returns(uint256 returnAmount);
+
+    function swap(
+        address executor,
+        SwapDescription calldata desc,
+        bytes calldata permit,
+        bytes calldata data
+    )
+        external
+        payable
+        returns (
+            uint256 returnAmount,
+            uint256 spentAmount
+        );
+
+    function unoswapTo(
+        address payable recipient,
+        address srcToken,
+        uint256 amount,
+        uint256 minReturn,
+        uint256[] calldata pools
+    ) external payable returns(uint256 returnAmount);
+}

package/contracts/router/swap-aggregator/1inch/OneInchAggregationRouterHelper.sol

@@ -0,0 +1,71 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity 0.8.17;
+
+import "./I1inchAggregationRouterV5.sol";
+import "../../../core/libraries/Errors.sol";
+
+abstract contract OneInchAggregationRouterHelper {
+    constructor() {}
+
+    function _rescaleMinAmount(
+        uint256 minAmount,
+        uint256 oldAmount,
+        uint256 newAmount
+    ) internal pure returns (uint256) {
+        return (minAmount * newAmount) / oldAmount;
+    }
+
+    function _get1inchScaledInputData(bytes calldata rawCallData, uint256 newAmount)
+        internal
+        pure
+        returns (bytes memory)
+    {
+        bytes4 selector = bytes4(rawCallData[:4]);
+        bytes memory args = rawCallData[4:];
+
+        if (selector == I1inchAggregationRouterV5.uniswapV3SwapTo.selector) {
+            (
+                address payable recipient,
+                uint256 amount,
+                uint256 minReturn,
+                uint256[] memory pools
+            ) = abi.decode(args, (address, uint256, uint256, uint256[]));
+
+            minReturn = _rescaleMinAmount(minReturn, amount, newAmount);
+            amount = newAmount;
+            return abi.encodeWithSelector(selector, recipient, amount, minReturn, pools);
+        }
+
+        if (selector == I1inchAggregationRouterV5.swap.selector) {
+            (
+                address executor,
+                I1inchAggregationRouterV5.SwapDescription memory desc,
+                bytes memory permit,
+                bytes memory data
+            ) = abi.decode(
+                    args,
+                    (address, I1inchAggregationRouterV5.SwapDescription, bytes, bytes)
+                );
+
+            desc.minReturnAmount = _rescaleMinAmount(desc.minReturnAmount, desc.amount, newAmount);
+            desc.amount = newAmount;
+            return abi.encodeWithSelector(selector, executor, desc, permit, data);
+        }
+
+        if (selector == I1inchAggregationRouterV5.unoswapTo.selector) {
+            (
+                address payable recipient,
+                address srcToken,
+                uint256 amount,
+                uint256 minReturn,
+                uint256[] memory pools
+            ) = abi.decode(args, (address, address, uint256, uint256, uint256[]));
+
+            minReturn = _rescaleMinAmount(minReturn, amount, newAmount);
+            amount = newAmount;
+            return abi.encodeWithSelector(selector, recipient, srcToken, amount, minReturn, pools);
+        }
+        revert Errors.UnsupportedSelector(1, selector);
+    }
+}