@pendle/core-v2 3.0.0-beta-10 → 3.0.0-beta-12

package/contracts/router/base/ActionBase.sol

@@ -11,19 +11,22 @@ import "../../router/base/MarketApproxLib.sol";
 import "../../core/libraries/Errors.sol";
 import "../swap-aggregator/IPSwapAggregator.sol";
 
-abstract contract ActionBase is TokenHelper {
+abstract contract ActionBase is TokenHelper, IPLimitOrderType {
     using MarketApproxPtOutLib for MarketState;
     using PMath for uint256;
     using PYIndexLib for IPYieldToken;
+    using PYIndexLib for PYIndex;
 
     bytes internal constant EMPTY_BYTES = abi.encode();
 
     // ----------------- MINT REDEEM SY PY -----------------
 
-    function _mintSyFromToken(address receiver, address SY, uint256 minSyOut, TokenInput calldata inp)
-        internal
-        returns (uint256 netSyOut)
-    {
+    function _mintSyFromToken(
+        address receiver,
+        address SY,
+        uint256 minSyOut,
+        TokenInput calldata inp
+    ) internal returns (uint256 netSyOut) {
         SwapType swapType = inp.swapData.swapType;
 
         uint256 netTokenMintSy;
@@ -48,23 +51,36 @@ abstract contract ActionBase is TokenHelper {
         else _transferFrom(IERC20(inp.tokenIn), msg.sender, inp.pendleSwap, inp.netTokenIn);
 
         IPSwapAggregator(inp.pendleSwap).swap{value: inp.tokenIn == NATIVE ? inp.netTokenIn : 0}(
-            inp.tokenIn, inp.netTokenIn, inp.swapData
+            inp.tokenIn,
+            inp.netTokenIn,
+            inp.swapData
         );
     }
 
-    function __mintSy(address receiver, address SY, uint256 netTokenMintSy, uint256 minSyOut, TokenInput calldata inp)
-        private
-        returns (uint256 netSyOut)
-    {
+    function __mintSy(
+        address receiver,
+        address SY,
+        uint256 netTokenMintSy,
+        uint256 minSyOut,
+        TokenInput calldata inp
+    ) private returns (uint256 netSyOut) {
         uint256 netNative = inp.tokenMintSy == NATIVE ? netTokenMintSy : 0;
         _safeApproveInf(inp.tokenMintSy, SY);
-        netSyOut = IStandardizedYield(SY).deposit{value: netNative}(receiver, inp.tokenMintSy, netTokenMintSy, minSyOut);
+        netSyOut = IStandardizedYield(SY).deposit{value: netNative}(
+            receiver,
+            inp.tokenMintSy,
+            netTokenMintSy,
+            minSyOut
+        );
     }
 
-    function _redeemSyToToken(address receiver, address SY, uint256 netSyIn, TokenOutput calldata out, bool doPull)
-        internal
-        returns (uint256 netTokenOut)
-    {
+    function _redeemSyToToken(
+        address receiver,
+        address SY,
+        uint256 netSyIn,
+        TokenOutput calldata out,
+        bool doPull
+    ) internal returns (uint256 netTokenOut) {
         SwapType swapType = out.swapData.swapType;
 
         if (swapType == SwapType.NONE) {
@@ -90,10 +106,13 @@ abstract contract ActionBase is TokenHelper {
         }
     }
 
-    function __redeemSy(address receiver, address SY, uint256 netSyIn, TokenOutput calldata out, bool doPull)
-        private
-        returns (uint256 netTokenRedeemed)
-    {
+    function __redeemSy(
+        address receiver,
+        address SY,
+        uint256 netSyIn,
+        TokenOutput calldata out,
+        bool doPull
+    ) private returns (uint256 netTokenRedeemed) {
         if (doPull) {
             _transferFrom(IERC20(SY), msg.sender, SY, netSyIn);
         }
@@ -101,10 +120,14 @@ abstract contract ActionBase is TokenHelper {
         netTokenRedeemed = IStandardizedYield(SY).redeem(receiver, netSyIn, out.tokenRedeemSy, 0, true);
     }
 
-    function _mintPyFromSy(address receiver, address SY, address YT, uint256 netSyIn, uint256 minPyOut, bool doPull)
-        internal
-        returns (uint256 netPyOut)
-    {
+    function _mintPyFromSy(
+        address receiver,
+        address SY,
+        address YT,
+        uint256 netSyIn,
+        uint256 minPyOut,
+        bool doPull
+    ) internal returns (uint256 netPyOut) {
         if (doPull) {
             _transferFrom(IERC20(SY), msg.sender, YT, netSyIn);
         }
@@ -113,10 +136,12 @@ abstract contract ActionBase is TokenHelper {
         if (netPyOut < minPyOut) revert Errors.RouterInsufficientPYOut(netPyOut, minPyOut);
     }
 
-    function _redeemPyToSy(address receiver, address YT, uint256 netPyIn, uint256 minSyOut)
-        internal
-        returns (uint256 netSyOut)
-    {
+    function _redeemPyToSy(
+        address receiver,
+        address YT,
+        uint256 netPyIn,
+        uint256 minSyOut
+    ) internal returns (uint256 netSyOut) {
         address PT = IPYieldToken(YT).PT();
 
         _transferFrom(IERC20(PT), msg.sender, YT, netPyIn);
@@ -147,7 +172,7 @@ abstract contract ActionBase is TokenHelper {
         uint256 minSyOut,
         LimitOrderData calldata limit
     ) internal returns (uint256 netSyOut, uint256 netSyFee) {
-        (, IPPrincipalToken PT,) = IPMarket(market).readTokens();
+        (, IPPrincipalToken PT, ) = IPMarket(market).readTokens();
 
         uint256 netPtLeft = exactPtIn;
         bool doMarketOrder = true;
@@ -160,8 +185,11 @@ abstract contract ActionBase is TokenHelper {
         }
 
         if (doMarketOrder) {
-            (uint256 netSyOutMarket, uint256 netSyFeeMarket) =
-                IPMarket(market).swapExactPtForSy(receiver, netPtLeft, EMPTY_BYTES);
+            (uint256 netSyOutMarket, uint256 netSyFeeMarket) = IPMarket(market).swapExactPtForSy(
+                receiver,
+                netPtLeft,
+                EMPTY_BYTES
+            );
 
             netSyOut += netSyOutMarket;
             netSyFee += netSyFeeMarket;
@@ -182,7 +210,7 @@ abstract contract ActionBase is TokenHelper {
         ApproxParams calldata guessPtOut,
         LimitOrderData calldata limit
     ) internal returns (uint256 netPtOut, uint256 netSyFee) {
-        (IStandardizedYield SY,, IPYieldToken YT) = IPMarket(market).readTokens();
+        (IStandardizedYield SY, , IPYieldToken YT) = IPMarket(market).readTokens();
         uint256 netSyLeft = exactSyIn;
         bool doMarketOrder = true;
 
@@ -194,8 +222,12 @@ abstract contract ActionBase is TokenHelper {
         }
 
         if (doMarketOrder) {
-            (uint256 netPtOutMarket,) =
-                _readMarket(market).approxSwapExactSyForPt(YT.newIndex(), netSyLeft, block.timestamp, guessPtOut);
+            (uint256 netPtOutMarket, ) = _readMarket(market).approxSwapExactSyForPt(
+                YT.newIndex(),
+                netSyLeft,
+                block.timestamp,
+                guessPtOut
+            );
 
             (, uint256 netSyFeeMarket) = IPMarket(market).swapSyForExactPt(receiver, netPtOutMarket, EMPTY_BYTES);
 
@@ -207,29 +239,45 @@ abstract contract ActionBase is TokenHelper {
     }
 
     // ----------------- LIMIT ORDERS -----------------
-    function _fillLimit(address receiver, IERC20 tokenIn, uint256 netInput, LimitOrderData calldata lim)
-        internal
-        returns (uint256 netLeft, uint256 netOut, uint256 netSyFee, bool doMarketOrder)
-    {
+    function _fillLimit(
+        address receiver,
+        IERC20 tokenIn,
+        uint256 netInput,
+        LimitOrderData calldata lim
+    ) internal returns (uint256 netLeft, uint256 netOut, uint256 netSyFee, bool doMarketOrder) {
         IPLimitRouter router = IPLimitRouter(lim.limitRouter);
         netLeft = netInput;
 
-        _safeApproveInf(address(tokenIn), lim.limitRouter);
-
         if (lim.normalFills.length != 0) {
-            (uint256 actualMaking, uint256 actualTaking, uint256 totalFee) =
-                router.normalFill(lim.normalFills, receiver, netLeft, EMPTY_BYTES);
+            _safeApproveInf(address(tokenIn), lim.limitRouter);
+            (uint256 actualMaking, uint256 actualTaking, uint256 totalFee, ) = router.fill(
+                lim.normalFills,
+                receiver,
+                netLeft,
+                lim.optData,
+                EMPTY_BYTES
+            );
             netOut += actualMaking;
-            netSyFee += totalFee;
             netLeft -= actualTaking;
+            netSyFee += totalFee;
         }
 
         if (lim.flashFills.length != 0) {
-            (uint256 totalOutput, uint256 totalInput, uint256 totalFee) =
-                router.flashFill(lim.flashFills, receiver, netLeft, EMPTY_BYTES);
-            netOut += totalOutput;
+            address YT = lim.flashFills[0].order.YT;
+            OrderType orderType = lim.flashFills[0].order.orderType;
+
+            (, , uint256 totalFee, bytes memory ret) = router.fill(
+                lim.flashFills,
+                YT,
+                type(uint256).max,
+                lim.optData,
+                abi.encode(orderType, YT, netLeft, receiver)
+            );
+            (uint256 netUse, uint256 netReceived) = abi.decode(ret, (uint256, uint256));
+
+            netOut += netReceived;
+            netLeft -= netUse;
             netSyFee += totalFee;
-            netLeft -= totalInput;
         }
 
         doMarketOrder = netLeft > netInput.mulDown(lim.epsSkipMarket);

package/contracts/router/base/CallbackHelper.sol

@@ -59,11 +59,12 @@ abstract contract CallbackHelper {
         }
     }
 
-    function _encodeSwapExactYtForPt(address receiver, uint256 netPtOut, IPPrincipalToken PT, IPYieldToken YT)
-        internal
-        pure
-        returns (bytes memory res)
-    {
+    function _encodeSwapExactYtForPt(
+        address receiver,
+        uint256 netPtOut,
+        IPPrincipalToken PT,
+        IPYieldToken YT
+    ) internal pure returns (bytes memory res) {
         res = new bytes(160);
         uint256 actionType = uint256(ActionType.SwapExactYtForPt);
 
@@ -76,11 +77,9 @@ abstract contract CallbackHelper {
         }
     }
 
-    function _decodeSwapExactYtForPt(bytes calldata data)
-        internal
-        pure
-        returns (address receiver, uint256 netPtOut, IPPrincipalToken PT, IPYieldToken YT)
-    {
+    function _decodeSwapExactYtForPt(
+        bytes calldata data
+    ) internal pure returns (address receiver, uint256 netPtOut, IPPrincipalToken PT, IPYieldToken YT) {
         assembly {
             // first 32 bytes is ActionType
             receiver := calldataload(add(data.offset, 32))
@@ -90,11 +89,12 @@ abstract contract CallbackHelper {
         }
     }
 
-    function _encodeSwapExactPtForYt(address receiver, uint256 exactPtIn, uint256 minYtOut, IPYieldToken YT)
-        internal
-        pure
-        returns (bytes memory res)
-    {
+    function _encodeSwapExactPtForYt(
+        address receiver,
+        uint256 exactPtIn,
+        uint256 minYtOut,
+        IPYieldToken YT
+    ) internal pure returns (bytes memory res) {
         res = new bytes(160);
         uint256 actionType = uint256(ActionType.SwapExactPtForYt);
 
@@ -107,11 +107,9 @@ abstract contract CallbackHelper {
         }
     }
 
-    function _decodeSwapExactPtForYt(bytes calldata data)
-        internal
-        pure
-        returns (address receiver, uint256 exactPtIn, uint256 minYtOut, IPYieldToken YT)
-    {
+    function _decodeSwapExactPtForYt(
+        bytes calldata data
+    ) internal pure returns (address receiver, uint256 exactPtIn, uint256 minYtOut, IPYieldToken YT) {
         assembly {
             // first 32 bytes is ActionType
             receiver := calldataload(add(data.offset, 32))

package/contracts/router/base/MarketApproxLib.sol

@@ -10,7 +10,7 @@ struct ApproxParams {
     uint256 guessOffchain; // pass 0 in to skip this variable
     uint256 maxIteration; // every iteration, the diff between guessMin and guessMax will be divided by 2
     uint256 eps; // the max eps between the returned result & the correct result, base 1e18. Normally this number will be set
-        // to 1e15 (1e18/1000 = 0.1%)
+    // to 1e15 (1e18/1000 = 0.1%)
 }
 
 /// Further explanation of the eps. Take swapExactSyForPt for example. To calc the corresponding amount of Pt to swap out,
@@ -48,7 +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
@@ -58,7 +58,7 @@ library MarketApproxPtInLib {
 
         for (uint256 iter = 0; iter < approx.maxIteration; ++iter) {
             uint256 guess = nextGuess(approx, iter);
-            (uint256 netSyOut, uint256 netSyFee,) = calcSyOut(market, comp, index, guess);
+            (uint256 netSyOut, uint256 netSyFee, ) = calcSyOut(market, comp, index, guess);
 
             if (netSyOut >= minSyOut) {
                 if (PMath.isAGreaterApproxB(netSyOut, minSyOut, approx.eps)) {
@@ -87,7 +87,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 = PMath.max(approx.guessMin, index.syToAsset(exactSyIn));
@@ -100,7 +100,7 @@ library MarketApproxPtInLib {
         for (uint256 iter = 0; iter < approx.maxIteration; ++iter) {
             uint256 guess = nextGuess(approx, iter);
 
-            (uint256 netSyOut, uint256 netSyFee,) = calcSyOut(market, comp, index, guess);
+            (uint256 netSyOut, uint256 netSyFee, ) = calcSyOut(market, comp, index, guess);
 
             uint256 netSyToTokenizePt = index.assetToSyUp(guess);
 
@@ -143,7 +143,7 @@ library MarketApproxPtInLib {
         uint256 _netSyHolding,
         uint256 _blockTime,
         ApproxParams memory approx
-    ) internal pure returns (uint256, /*netPtSwap*/ uint256, /*netSyFromSwap*/ uint256 /*netSyFee*/ ) {
+    ) internal pure returns (uint256, /*netPtSwap*/ uint256, /*netSyFromSwap*/ uint256 /*netSyFee*/) {
         Args5 memory a = Args5(_market, _index, _totalPtIn, _netSyHolding, _blockTime, approx);
         MarketPreCompute memory comp = a.market.getMarketPreCompute(a.index, a.blockTime);
         if (approx.guessOffchain == 0) {
@@ -157,8 +157,14 @@ library MarketApproxPtInLib {
         for (uint256 iter = 0; iter < approx.maxIteration; ++iter) {
             uint256 guess = nextGuess(approx, iter);
 
-            (uint256 syNumerator, uint256 ptNumerator, uint256 netSyOut, uint256 netSyFee,) =
-                calcNumerators(a.market, a.index, a.totalPtIn, a.netSyHolding, comp, guess);
+            (uint256 syNumerator, uint256 ptNumerator, uint256 netSyOut, uint256 netSyFee, ) = calcNumerators(
+                a.market,
+                a.index,
+                a.totalPtIn,
+                a.netSyHolding,
+                comp,
+                guess
+            );
 
             if (PMath.isAApproxB(syNumerator, ptNumerator, approx.eps)) {
                 return (guess, netSyOut, netSyFee);
@@ -216,7 +222,7 @@ library MarketApproxPtInLib {
         uint256 exactPtIn,
         uint256 blockTime,
         ApproxParams memory approx
-    ) internal pure returns (uint256, /*netYtOut*/ uint256, /*totalPtToSwap*/ uint256 /*netSyFee*/ ) {
+    ) internal pure returns (uint256, /*netYtOut*/ uint256, /*totalPtToSwap*/ uint256 /*netSyFee*/) {
         MarketPreCompute memory comp = market.getMarketPreCompute(index, blockTime);
         if (approx.guessOffchain == 0) {
             approx.guessMin = PMath.max(approx.guessMin, exactPtIn);
@@ -227,7 +233,7 @@ library MarketApproxPtInLib {
         for (uint256 iter = 0; iter < approx.maxIteration; ++iter) {
             uint256 guess = nextGuess(approx, iter);
 
-            (uint256 netSyOut, uint256 netSyFee,) = calcSyOut(market, comp, index, guess);
+            (uint256 netSyOut, uint256 netSyFee, ) = calcSyOut(market, comp, index, guess);
 
             uint256 netAssetOut = index.syToAsset(netSyOut);
 
@@ -248,11 +254,12 @@ library MarketApproxPtInLib {
 
     ////////////////////////////////////////////////////////////////////////////////
 
-    function calcSyOut(MarketState memory market, MarketPreCompute memory comp, PYIndex index, uint256 netPtIn)
-        internal
-        pure
-        returns (uint256 netSyOut, uint256 netSyFee, uint256 netSyToReserve)
-    {
+    function calcSyOut(
+        MarketState memory market,
+        MarketPreCompute memory comp,
+        PYIndex index,
+        uint256 netPtIn
+    ) internal pure returns (uint256 netSyOut, uint256 netSyFee, uint256 netSyToReserve) {
         (int256 _netSyOut, int256 _netSyFee, int256 _netSyToReserve) = market.calcTrade(comp, index, -int256(netPtIn));
         netSyOut = uint256(_netSyOut);
         netSyFee = uint256(_netSyFee);
@@ -285,11 +292,7 @@ library MarketApproxPtInLib {
         return low;
     }
 
-    function calcSlope(MarketPreCompute memory comp, int256 totalPt, int256 ptToMarket)
-        internal
-        pure
-        returns (int256)
-    {
+    function calcSlope(MarketPreCompute memory comp, int256 totalPt, int256 ptToMarket) internal pure returns (int256) {
         int256 diffAssetPtToMarket = comp.totalAsset - ptToMarket;
         int256 sumPt = ptToMarket + totalPt;
 
@@ -324,7 +327,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
@@ -335,7 +338,7 @@ library MarketApproxPtOutLib {
         for (uint256 iter = 0; iter < approx.maxIteration; ++iter) {
             uint256 guess = nextGuess(approx, iter);
 
-            (uint256 netSyIn, uint256 netSyFee,) = calcSyIn(market, comp, index, guess);
+            (uint256 netSyIn, uint256 netSyFee, ) = calcSyIn(market, comp, index, guess);
 
             if (netSyIn <= exactSyIn) {
                 if (PMath.isASmallerApproxB(netSyIn, exactSyIn, approx.eps)) {
@@ -364,7 +367,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
@@ -375,7 +378,7 @@ library MarketApproxPtOutLib {
         for (uint256 iter = 0; iter < approx.maxIteration; ++iter) {
             uint256 guess = nextGuess(approx, iter);
 
-            (uint256 netSyOwed, uint256 netSyFee,) = calcSyIn(market, comp, index, guess);
+            (uint256 netSyOwed, uint256 netSyFee, ) = calcSyIn(market, comp, index, guess);
 
             uint256 netAssetToRepay = index.syToAssetUp(netSyOwed);
             uint256 netSyOut = index.assetToSy(guess - netAssetToRepay);
@@ -416,7 +419,7 @@ library MarketApproxPtOutLib {
         uint256 _netPtHolding,
         uint256 _blockTime,
         ApproxParams memory _approx
-    ) internal pure returns (uint256, /*netPtFromSwap*/ uint256, /*netSySwap*/ uint256 /*netSyFee*/ ) {
+    ) internal pure returns (uint256, /*netPtFromSwap*/ uint256, /*netSySwap*/ uint256 /*netSyFee*/) {
         Args6 memory a = Args6(_market, _index, _totalSyIn, _netPtHolding, _blockTime, _approx);
 
         MarketPreCompute memory comp = a.market.getMarketPreCompute(a.index, a.blockTime);
@@ -483,7 +486,7 @@ library MarketApproxPtOutLib {
         uint256 exactYtIn,
         uint256 blockTime,
         ApproxParams memory approx
-    ) internal pure returns (uint256, /*netPtOut*/ uint256, /*totalPtSwapped*/ uint256 /*netSyFee*/ ) {
+    ) internal pure returns (uint256, /*netPtOut*/ uint256, /*totalPtSwapped*/ uint256 /*netSyFee*/) {
         MarketPreCompute memory comp = market.getMarketPreCompute(index, blockTime);
         if (approx.guessOffchain == 0) {
             approx.guessMin = PMath.max(approx.guessMin, exactYtIn);
@@ -494,7 +497,7 @@ library MarketApproxPtOutLib {
         for (uint256 iter = 0; iter < approx.maxIteration; ++iter) {
             uint256 guess = nextGuess(approx, iter);
 
-            (uint256 netSyOwed, uint256 netSyFee,) = calcSyIn(market, comp, index, guess);
+            (uint256 netSyOwed, uint256 netSyFee, ) = calcSyIn(market, comp, index, guess);
 
             uint256 netYtToPull = index.syToAssetUp(netSyOwed);
 
@@ -512,11 +515,12 @@ library MarketApproxPtOutLib {
 
     ////////////////////////////////////////////////////////////////////////////////
 
-    function calcSyIn(MarketState memory market, MarketPreCompute memory comp, PYIndex index, uint256 netPtOut)
-        internal
-        pure
-        returns (uint256 netSyIn, uint256 netSyFee, uint256 netSyToReserve)
-    {
+    function calcSyIn(
+        MarketState memory market,
+        MarketPreCompute memory comp,
+        PYIndex index,
+        uint256 netPtOut
+    ) internal pure returns (uint256 netSyIn, uint256 netSyFee, uint256 netSyToReserve) {
         (int256 _netSyIn, int256 _netSyFee, int256 _netSyToReserve) = market.calcTrade(comp, index, int256(netPtOut));
 
         // all safe since totalPt and totalSy is int128

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

@@ -3,10 +3,11 @@ pragma solidity ^0.8.17;
 
 import "../../core/libraries/TokenHelper.sol";
 import "./IPSwapAggregator.sol";
-import "./kyberswap/KyberInputScalingHelper.sol";
+import "./kyberswap/l1-contracts/InputScalingHelper.sol";
+import "./kyberswap/l2-contracts/InputScalingHelperL2.sol";
 import "./oneinch/OneInchAggregationRouterHelper.sol";
 
-contract PendleSwap is IPSwapAggregator, TokenHelper, KyberInputScalingHelper, OneInchAggregationRouterHelper {
+abstract contract PendleSwapBase is IPSwapAggregator, TokenHelper, OneInchAggregationRouterHelper {
     using Address for address;
 
     function swap(address tokenIn, uint256 amountIn, SwapData calldata data) external payable {
@@ -17,11 +18,11 @@ contract PendleSwap is IPSwapAggregator, TokenHelper, KyberInputScalingHelper, O
         );
     }
 
-    function _getScaledInputData(SwapType swapType, bytes calldata rawCallData, uint256 amountIn)
-        internal
-        pure
-        returns (bytes memory scaledCallData)
-    {
+    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) {
@@ -31,5 +32,28 @@ contract PendleSwap is IPSwapAggregator, TokenHelper, KyberInputScalingHelper, O
         }
     }
 
+    function _getKyberScaledInputData(
+        bytes calldata rawCallData,
+        uint256 amountIn
+    ) internal pure virtual returns (bytes memory scaledCallData);
+
     receive() external payable {}
 }
+
+contract PendleSwapL1 is PendleSwapBase {
+    function _getKyberScaledInputData(
+        bytes calldata rawCallData,
+        uint256 amountIn
+    ) internal pure override returns (bytes memory) {
+        return InputScalingHelper._getScaledInputData(rawCallData, amountIn);
+    }
+}
+
+contract PendleSwapL2 is PendleSwapBase {
+    function _getKyberScaledInputData(
+        bytes calldata rawCallData,
+        uint256 amountIn
+    ) internal pure override returns (bytes memory) {
+        return InputScalingHelperL2._getScaledInputData(rawCallData, amountIn);
+    }
+}

package/contracts/router/swap-aggregator/kyberswap/interfaces/IAggregationExecutorOptimistic.sol

@@ -0,0 +1,63 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity >=0.6.12;
+
+interface IAggregationExecutorOptimistic {
+    event Exchange(address pair, uint256 amountOut, address output);
+
+    struct Swap {
+        bytes data;
+        bytes4 functionSelector;
+    }
+
+    struct SwapCallbackData {
+        bytes path;
+        address payer;
+    }
+
+    struct SwapCallbackDataPath {
+        address pool;
+        address tokenIn;
+        address tokenOut;
+    }
+
+    struct PositiveSlippageFeeData {
+        uint256 partnerPSInfor; // [partnerReceiver (160 bit) + partnerPercent(96bits)]
+        uint256 expectedReturnAmount; // [minimumPSAmount (128 bits) + expectedReturnAmount (128 bits)]
+    }
+
+    struct SwapExecutorDescription {
+        Swap[][] swapSequences;
+        address tokenIn;
+        address tokenOut;
+        address to;
+        uint256 deadline;
+        bytes positiveSlippageData;
+    }
+
+    function rescueFunds(address token, uint256 amount) external;
+
+    function callBytes(bytes calldata data) external payable;
+
+    function swapSingleSequence(bytes calldata data) external;
+
+    function multihopBatchSwapExactIn(
+        Swap[][] memory swapSequences,
+        address tokenIn,
+        address tokenOut,
+        address to,
+        uint256 deadline,
+        bytes memory positiveSlippageData
+    ) external payable;
+
+    function finalTransactionProcessing(
+        address tokenIn,
+        address tokenOut,
+        address to,
+        bytes calldata destTokenFeeData
+    ) external;
+
+    function updateExecutor(bytes4 functionSelector, address executor) external;
+
+    function updateBatchExecutors(bytes4[] memory functionSelectors, address[] memory executors) external;
+}