@pendle/core-v2 1.2.1-testnet → 1.3.0-testnet

package/contracts/router/base/MarketApproxLib.sol

@@ -48,15 +48,7 @@ library MarketApproxPtInLib {
         uint256 minSyOut,
         uint256 blockTime,
         ApproxParams memory approx
-    )
-        internal
-        pure
-        returns (
-            uint256, /*netPtIn*/
-            uint256, /*netSyOut*/
-            uint256 /*netSyFee*/
-        )
-    {
+    ) internal pure returns (uint256 /*netPtIn*/, uint256 /*netSyOut*/, uint256 /*netSyFee*/) {
         MarketPreCompute memory comp = market.getMarketPreCompute(index, blockTime);
         if (approx.guessOffchain == 0) {
             // no limit on min
@@ -94,14 +86,7 @@ library MarketApproxPtInLib {
         uint256 exactSyIn,
         uint256 blockTime,
         ApproxParams memory approx
-    )
-        internal
-        pure
-        returns (
-            uint256, /*netYtOut*/
-            uint256 /*netSyFee*/
-        )
-    {
+    ) internal pure returns (uint256 /*netYtOut*/, uint256 /*netSyFee*/) {
         MarketPreCompute memory comp = market.getMarketPreCompute(index, blockTime);
         if (approx.guessOffchain == 0) {
             approx.guessMin = Math.max(approx.guessMin, index.syToAsset(exactSyIn));
@@ -149,11 +134,7 @@ library MarketApproxPtInLib {
     )
         internal
         pure
-        returns (
-            uint256, /*netPtSwap*/
-            uint256, /*netSyFromSwap*/
-            uint256 /*netSyFee*/
-        )
+        returns (uint256 /*netPtSwap*/, uint256 /*netSyFromSwap*/, uint256 /*netSyFee*/)
     {
         MarketPreCompute memory comp = market.getMarketPreCompute(index, blockTime);
         if (approx.guessOffchain == 0) {
@@ -245,11 +226,7 @@ library MarketApproxPtInLib {
     )
         internal
         pure
-        returns (
-            uint256, /*netYtOut*/
-            uint256, /*totalPtToSwap*/
-            uint256 /*netSyFee*/
-        )
+        returns (uint256 /*netYtOut*/, uint256 /*totalPtToSwap*/, uint256 /*netSyFee*/)
     {
         MarketPreCompute memory comp = market.getMarketPreCompute(index, blockTime);
         if (approx.guessOffchain == 0) {
@@ -286,15 +263,7 @@ library MarketApproxPtInLib {
         MarketPreCompute memory comp,
         PYIndex index,
         uint256 netPtIn
-    )
-        internal
-        pure
-        returns (
-            uint256 netSyOut,
-            uint256 netSyFee,
-            uint256 netSyToReserve
-        )
-    {
+    ) internal pure returns (uint256 netSyOut, uint256 netSyFee, uint256 netSyToReserve) {
         (int256 _netSyOut, int256 _netSyFee, int256 _netSyToReserve) = market.calcTrade(
             comp,
             index,
@@ -318,11 +287,10 @@ library MarketApproxPtInLib {
             revert Errors.ApproxParamsInvalid(approx.guessMin, approx.guessMax, approx.eps);
     }
 
-    function calcMaxPtIn(MarketState memory market, MarketPreCompute memory comp)
-        internal
-        pure
-        returns (uint256)
-    {
+    function calcMaxPtIn(
+        MarketState memory market,
+        MarketPreCompute memory comp
+    ) internal pure returns (uint256) {
         uint256 low = 0;
         uint256 hi = uint256(comp.totalAsset) - 1;
 
@@ -375,14 +343,7 @@ library MarketApproxPtOutLib {
         uint256 exactSyIn,
         uint256 blockTime,
         ApproxParams memory approx
-    )
-        internal
-        pure
-        returns (
-            uint256, /*netPtOut*/
-            uint256 /*netSyFee*/
-        )
-    {
+    ) internal pure returns (uint256 /*netPtOut*/, uint256 /*netSyFee*/) {
         MarketPreCompute memory comp = market.getMarketPreCompute(index, blockTime);
         if (approx.guessOffchain == 0) {
             // no limit on min
@@ -421,15 +382,7 @@ library MarketApproxPtOutLib {
         uint256 minSyOut,
         uint256 blockTime,
         ApproxParams memory approx
-    )
-        internal
-        pure
-        returns (
-            uint256, /*netYtIn*/
-            uint256, /*netSyOut*/
-            uint256 /*netSyFee*/
-        )
-    {
+    ) internal pure returns (uint256 /*netYtIn*/, uint256 /*netSyOut*/, uint256 /*netSyFee*/) {
         MarketPreCompute memory comp = market.getMarketPreCompute(index, blockTime);
         if (approx.guessOffchain == 0) {
             // no limit on min
@@ -481,11 +434,7 @@ library MarketApproxPtOutLib {
     )
         internal
         pure
-        returns (
-            uint256, /*netPtFromSwap*/
-            uint256, /*netSySwap*/
-            uint256 /*netSyFee*/
-        )
+        returns (uint256 /*netPtFromSwap*/, uint256 /*netSySwap*/, uint256 /*netSyFee*/)
     {
         Args6 memory a = Args6(_market, _index, _totalSyIn, _blockTime, _approx);
 
@@ -560,11 +509,7 @@ library MarketApproxPtOutLib {
     )
         internal
         pure
-        returns (
-            uint256, /*netPtOut*/
-            uint256, /*totalPtSwapped*/
-            uint256 /*netSyFee*/
-        )
+        returns (uint256 /*netPtOut*/, uint256 /*totalPtSwapped*/, uint256 /*netSyFee*/)
     {
         MarketPreCompute memory comp = market.getMarketPreCompute(index, blockTime);
         if (approx.guessOffchain == 0) {
@@ -598,15 +543,7 @@ library MarketApproxPtOutLib {
         MarketPreCompute memory comp,
         PYIndex index,
         uint256 netPtOut
-    )
-        internal
-        pure
-        returns (
-            uint256 netSyIn,
-            uint256 netSyFee,
-            uint256 netSyToReserve
-        )
-    {
+    ) internal pure returns (uint256 netSyIn, uint256 netSyFee, uint256 netSyToReserve) {
         (int256 _netSyIn, int256 _netSyFee, int256 _netSyToReserve) = market.calcTrade(
             comp,
             index,
@@ -619,11 +556,10 @@ library MarketApproxPtOutLib {
         netSyToReserve = uint256(_netSyToReserve);
     }
 
-    function calcMaxPtOut(MarketPreCompute memory comp, int256 totalPt)
-        internal
-        pure
-        returns (uint256)
-    {
+    function calcMaxPtOut(
+        MarketPreCompute memory comp,
+        int256 totalPt
+    ) internal pure returns (uint256) {
         int256 logitP = (comp.feeRate - comp.rateAnchor).mulDown(comp.rateScalar).exp();
         int256 proportion = logitP.divDown(logitP + Math.IONE);
         int256 numerator = proportion.mulDown(totalPt + comp.totalAsset);

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

@@ -20,20 +20,14 @@ interface I1inchAggregationRouterV5 {
         uint256 amount,
         uint256 minReturn,
         uint256[] calldata pools
-    ) external payable returns(uint256 returnAmount);
+    ) 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
-        );
+    ) external payable returns (uint256 returnAmount, uint256 spentAmount);
 
     function unoswapTo(
         address payable recipient,
@@ -41,5 +35,5 @@ interface I1inchAggregationRouterV5 {
         uint256 amount,
         uint256 minReturn,
         uint256[] calldata pools
-    ) external payable returns(uint256 returnAmount);
-}
+    ) external payable returns (uint256 returnAmount);
+}

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

@@ -14,11 +14,10 @@ abstract contract OneInchAggregationRouterHelper {
         return (minAmount * newAmount) / oldAmount;
     }
 
-    function _get1inchScaledInputData(bytes calldata rawCallData, uint256 newAmount)
-        internal
-        pure
-        returns (bytes memory)
-    {
+    function _get1inchScaledInputData(
+        bytes calldata rawCallData,
+        uint256 newAmount
+    ) internal pure returns (bytes memory) {
         bytes4 selector = bytes4(rawCallData[:4]);
         bytes memory args = rawCallData[4:];
 

package/contracts/router/swap-aggregator/IPSwapAggregator.sol

@@ -17,9 +17,5 @@ enum SwapType {
 }
 
 interface IPSwapAggregator {
-    function swap(
-        address tokenIn,
-        uint256 amountIn,
-        SwapData calldata swapData
-    ) external payable;
+    function swap(address tokenIn, uint256 amountIn, SwapData calldata swapData) external payable;
 }

package/contracts/router/swap-aggregator/{PendleSwapAggregator.sol → PendleSwapArbitrum.sol}

@@ -6,21 +6,17 @@ import "../../core/libraries/TokenHelper.sol";
 import "../../core/libraries/Errors.sol";
 import "./IPSwapAggregator.sol";
 import "./1inch/OneInchAggregationRouterHelper.sol";
-import "./kyberswap/KyberAggregationRouterHelper.sol";
+import "./kyberswap/arbitrum/KyberHelperArbitrum.sol";
 
-contract PendleSwapAggregator is
+contract PendleSwapArbitrum is
     IPSwapAggregator,
     TokenHelper,
-    KyberAggregationRouterHelper,
+    KyberHelperArbitrum,
     OneInchAggregationRouterHelper
 {
     using Address for address;
 
-    function swap(
-        address tokenIn,
-        uint256 amountIn,
-        SwapData calldata data
-    ) external payable {
+    function swap(address tokenIn, uint256 amountIn, SwapData calldata data) external payable {
         _safeApproveInf(tokenIn, data.extRouter);
         data.extRouter.functionCallWithValue(
             data.needScale
@@ -43,4 +39,7 @@ contract PendleSwapAggregator is
             assert(false);
         }
     }
+
+    receive() external payable {}
+
 }

package/contracts/router/swap-aggregator/PendleSwapEthereum.sol

@@ -0,0 +1,44 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+import "@openzeppelin/contracts/utils/Address.sol";
+import "../../core/libraries/TokenHelper.sol";
+import "../../core/libraries/Errors.sol";
+import "./IPSwapAggregator.sol";
+import "./1inch/OneInchAggregationRouterHelper.sol";
+import "./kyberswap/ethereum/KyberHelperEthereum.sol";
+
+contract PendleSwapEthereum is
+    IPSwapAggregator,
+    TokenHelper,
+    KyberHelperEthereum,
+    OneInchAggregationRouterHelper
+{
+    using Address for address;
+
+    function swap(address tokenIn, uint256 amountIn, SwapData calldata data) external payable {
+        _safeApproveInf(tokenIn, data.extRouter);
+        data.extRouter.functionCallWithValue(
+            data.needScale
+                ? _getScaledInputData(data.swapType, data.extCalldata, amountIn)
+                : data.extCalldata,
+            tokenIn == NATIVE ? amountIn : 0
+        );
+    }
+
+    function _getScaledInputData(
+        SwapType swapType,
+        bytes calldata rawCallData,
+        uint256 amountIn
+    ) internal pure returns (bytes memory scaledCallData) {
+        if (swapType == SwapType.KYBERSWAP) {
+            scaledCallData = _getKyberScaledInputData(rawCallData, amountIn);
+        } else if (swapType == SwapType.ONE_INCH) {
+            scaledCallData = _get1inchScaledInputData(rawCallData, amountIn);
+        } else {
+            assert(false);
+        }
+    }
+
+    receive() external payable {}
+}

package/contracts/router/swap-aggregator/kyberswap/arbitrum/IAggregationExecutor.sol

@@ -0,0 +1,17 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity >=0.6.12;
+
+interface IAggregationExecutor {
+    function callBytes(bytes calldata data) external payable; // 0xd9c45357
+
+    // callbytes per swap sequence
+    function swapSingleSequence(bytes calldata data) external;
+
+    function finalTransactionProcessing(
+        address tokenIn,
+        address tokenOut,
+        address to,
+        bytes calldata destTokenFeeData
+    ) external;
+}

package/contracts/router/swap-aggregator/kyberswap/arbitrum/IExecutorHelper1.sol

@@ -0,0 +1,195 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.17;
+
+import "./IHashflow.sol";
+
+interface IExecutorHelper1 {
+    struct UniSwap {
+        address pool;
+        address tokenIn;
+        address tokenOut;
+        address recipient;
+        uint256 collectAmount; // amount that should be transferred to the pool
+        uint256 limitReturnAmount;
+        uint32 swapFee;
+        uint32 feePrecision;
+        uint32 tokenWeightInput;
+    }
+
+    struct StableSwap {
+        address pool;
+        address tokenFrom;
+        address tokenTo;
+        uint8 tokenIndexFrom;
+        uint8 tokenIndexTo;
+        uint256 dx;
+        uint256 minDy;
+        uint256 poolLength;
+        address poolLp;
+        bool isSaddle; // true: saddle, false: stable
+    }
+
+    struct CurveSwap {
+        address pool;
+        address tokenFrom;
+        address tokenTo;
+        int128 tokenIndexFrom;
+        int128 tokenIndexTo;
+        uint256 dx;
+        uint256 minDy;
+        bool usePoolUnderlying;
+        bool useTriCrypto;
+    }
+
+    struct UniSwapV3ProMM {
+        address recipient;
+        address pool;
+        address tokenIn;
+        address tokenOut;
+        uint256 swapAmount;
+        uint256 limitReturnAmount;
+        uint160 sqrtPriceLimitX96;
+        bool isUniV3; // true = UniV3, false = ProMM
+    }
+    struct SwapCallbackData {
+        bytes path;
+        address payer;
+    }
+    struct SwapCallbackDataPath {
+        address pool;
+        address tokenIn;
+        address tokenOut;
+    }
+
+    struct BalancerV2 {
+        address vault;
+        bytes32 poolId;
+        address assetIn;
+        address assetOut;
+        uint256 amount;
+        uint256 limit;
+    }
+
+    struct KyberRFQ {
+        address rfq;
+        bytes order;
+        bytes signature;
+        uint256 amount;
+        address payable target;
+    }
+
+    struct DODO {
+        address recipient;
+        address pool;
+        address tokenFrom;
+        address tokenTo;
+        uint256 amount;
+        uint256 minReceiveQuote;
+        address sellHelper;
+        bool isSellBase;
+        bool isVersion2;
+    }
+
+    struct GMX {
+        address vault;
+        address tokenIn;
+        address tokenOut;
+        uint256 amount;
+        uint256 minOut;
+        address receiver;
+    }
+
+    struct Synthetix {
+        address synthetixProxy;
+        address tokenIn;
+        address tokenOut;
+        bytes32 sourceCurrencyKey;
+        uint256 sourceAmount;
+        bytes32 destinationCurrencyKey;
+        uint256 minAmount;
+        bool useAtomicExchange;
+    }
+
+    struct Hashflow {
+        address router;
+        IHashflow.Quote quote;
+    }
+
+    function executeUniSwap(
+        uint256 index,
+        bytes memory data,
+        uint256 previousAmountOut
+    ) external payable returns (uint256);
+
+    function executeStableSwap(
+        uint256 index,
+        bytes memory data,
+        uint256 previousAmountOut
+    ) external payable returns (uint256);
+
+    function executeCurveSwap(
+        uint256 index,
+        bytes memory data,
+        uint256 previousAmountOut
+    ) external payable returns (uint256);
+
+    function executeKyberDMMSwap(
+        uint256 index,
+        bytes memory data,
+        uint256 previousAmountOut
+    ) external payable returns (uint256);
+
+    function executeUniV3ProMMSwap(
+        uint256 index,
+        bytes memory data,
+        uint256 previousAmountOut
+    ) external payable returns (uint256);
+
+    function executeRfqSwap(
+        uint256 index,
+        bytes memory data,
+        uint256 previousAmountOut
+    ) external payable returns (uint256);
+
+    function executeBalV2Swap(
+        uint256 index,
+        bytes memory data,
+        uint256 previousAmountOut
+    ) external payable returns (uint256);
+
+    function executeDODOSwap(
+        uint256 index,
+        bytes memory data,
+        uint256 previousAmountOut
+    ) external payable returns (uint256);
+
+    function executeVelodromeSwap(
+        uint256 index,
+        bytes memory data,
+        uint256 previousAmountOut
+    ) external payable returns (uint256);
+
+    function executeGMXSwap(
+        uint256 index,
+        bytes memory data,
+        uint256 previousAmountOut
+    ) external payable returns (uint256);
+
+    function executeSynthetixSwap(
+        uint256 index,
+        bytes memory data,
+        uint256 previousAmountOut
+    ) external payable returns (uint256);
+
+    function executeHashflowSwap(
+        uint256 index,
+        bytes memory data,
+        uint256 previousAmountOut
+    ) external payable returns (uint256);
+
+    function executeCamelotSwap(
+        uint256 index,
+        bytes memory data,
+        uint256 previousAmountOut
+    ) external payable returns (uint256);
+}

package/contracts/router/swap-aggregator/kyberswap/arbitrum/IExecutorHelper2.sol

@@ -0,0 +1,10 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.17;
+
+interface IExecutorHelper2 {
+    function executeKyberLimitOrder(
+        uint256 index,
+        bytes memory data,
+        uint256 previousAmountOut
+    ) external payable returns (uint256);
+}

package/contracts/router/swap-aggregator/kyberswap/arbitrum/IMetaAggregationRouterV2.sol

@@ -0,0 +1,41 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.17;
+
+import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import { IAggregationExecutor } from "./IAggregationExecutor.sol";
+
+interface IMetaAggregationRouterV2 {
+    struct SwapDescriptionV2 {
+        IERC20 srcToken;
+        IERC20 dstToken;
+        address[] srcReceivers; // transfer src token to these addresses, default
+        uint256[] srcAmounts;
+        address[] feeReceivers;
+        uint256[] feeAmounts;
+        address dstReceiver;
+        uint256 amount;
+        uint256 minReturnAmount;
+        uint256 flags;
+        bytes permit;
+    }
+
+    /// @dev  use for swapGeneric and swap to avoid stack too deep
+    struct SwapExecutionParams {
+        address callTarget; // call this address
+        address approveTarget; // approve this address if _APPROVE_FUND set
+        bytes targetData;
+        SwapDescriptionV2 desc;
+        bytes clientData;
+    }
+
+    function swap(
+        SwapExecutionParams calldata execution
+    ) external payable returns (uint256, uint256);
+
+    function swapSimpleMode(
+        IAggregationExecutor caller,
+        SwapDescriptionV2 memory desc,
+        bytes calldata executorData,
+        bytes calldata clientData
+    ) external returns (uint256, uint256);
+}