@pendle/core-v2 2.1.2-mainnet → 2.3.0-mainnet

package/contracts/offchain-helpers/router-static/base/ActionMintRedeemStatic.sol

@@ -0,0 +1,158 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+import "../../../interfaces/IPRouterStatic.sol";
+import "../../../interfaces/IPBulkSeller.sol";
+import "../../../interfaces/IPBulkSellerFactory.sol";
+import "./StorageLayout.sol";
+
+contract ActionMintRedeemStatic is StorageLayout, IPActionMintRedeemStatic {
+    using Math for uint256;
+    using BulkSellerMathCore for BulkSellerState;
+
+    function mintPyFromSyStatic(
+        address YT,
+        uint256 netSyToMint
+    ) public returns (uint256 netPYOut) {
+        if (IPYieldToken(YT).isExpired()) revert Errors.YCExpired();
+        return netSyToMint.mulDown(IPYieldToken(YT).pyIndexCurrent());
+    }
+
+    function redeemPyToSyStatic(
+        address YT,
+        uint256 netPYToRedeem
+    ) public returns (uint256 netSyOut) {
+        return netPYToRedeem.divDown(IPYieldToken(YT).pyIndexCurrent());
+    }
+
+    function mintPyFromTokenStatic(
+        address YT,
+        address tokenIn,
+        uint256 netTokenIn,
+        address bulk
+    ) external returns (uint256 netPyOut) {
+        address SY = IPYieldToken(YT).SY();
+        uint256 netSyReceived = mintSyFromTokenStatic(SY, tokenIn, netTokenIn, bulk);
+        netPyOut = mintPyFromSyStatic(YT, netSyReceived);
+    }
+
+    function redeemPyToTokenStatic(
+        address YT,
+        uint256 netPYToRedeem,
+        address tokenOut,
+        address bulk
+    ) external returns (uint256 netTokenOut) {
+        address SY = IPYieldToken(YT).SY();
+        uint256 netSyReceived = redeemPyToSyStatic(YT, netPYToRedeem);
+        netTokenOut = redeemSyToTokenStatic(SY, tokenOut, netSyReceived, bulk);
+    }
+
+    function mintSyFromTokenStatic(
+        address SY,
+        address tokenIn,
+        uint256 netTokenIn,
+        address bulk
+    ) public view returns (uint256 netSyOut) {
+        if (bulk != address(0)) {
+            BulkSellerState memory state = _readBulkSellerState(bulk);
+            return state.calcSwapExactTokenForSy(netTokenIn);
+        } else {
+            return IStandardizedYield(SY).previewDeposit(tokenIn, netTokenIn);
+        }
+    }
+
+    function redeemSyToTokenStatic(
+        address SY,
+        address tokenOut,
+        uint256 netSyIn,
+        address bulk
+    ) public view returns (uint256 netTokenOut) {
+        if (bulk != address(0)) {
+            BulkSellerState memory state = _readBulkSellerState(bulk);
+            return state.calcSwapExactSyForToken(netSyIn);
+        } else {
+            return IStandardizedYield(SY).previewRedeem(tokenOut, netSyIn);
+        }
+    }
+
+    function getAmountTokenToMintSy(
+        address SY,
+        address tokenIn,
+        address bulk,
+        uint256 netSyOut
+    ) external view returns (uint256 netTokenIn) {
+        uint256 pivotAmount;
+
+        if (tokenIn == address(0)) pivotAmount = 1e18;
+        else pivotAmount = 10 ** IStandardizedYield(SY).decimals();
+
+        uint256 low = pivotAmount;
+        {
+            while (true) {
+                uint256 lowSyOut = mintSyFromTokenStatic(SY, tokenIn, low, bulk);
+                if (lowSyOut >= netSyOut) low /= 10;
+                else break;
+            }
+        }
+
+        uint256 high = pivotAmount;
+        {
+            while (true) {
+                uint256 highSyOut = mintSyFromTokenStatic(SY, tokenIn, high, bulk);
+                if (highSyOut < netSyOut) high *= 10;
+                else break;
+            }
+        }
+
+        while (low <= high) {
+            uint256 mid = (low + high) / 2;
+            uint256 syOut = mintSyFromTokenStatic(SY, tokenIn, mid, bulk);
+
+            if (syOut >= netSyOut) {
+                netTokenIn = mid;
+                high = mid - 1;
+            } else {
+                low = mid + 1;
+            }
+        }
+
+        assert(netTokenIn > 0);
+    }
+
+    function getBulkSellerInfo(
+        address token,
+        address SY,
+        uint256 netTokenIn,
+        uint256 netSyIn
+    ) external view returns (address bulk, uint256 totalToken, uint256 totalSy) {
+        if (address(bulkSellerFactory) == address(0)) return (address(0), 0, 0);
+
+        bulk = bulkSellerFactory.get(token, SY);
+        if (bulk == address(0)) return (address(0), 0, 0);
+
+        BulkSellerState memory state = _readBulkSellerState(bulk);
+
+        // Paused check
+        if (state.rateTokenToSy == 0 || state.rateSyToToken == 0) {
+            return (address(0), 0, 0);
+        }
+
+        // Liquidity check
+        uint256 postFeeRateTokenToSy = state.rateTokenToSy.mulDown(Math.ONE - state.feeRate);
+        uint256 postFeeRateSyToToken = state.rateSyToToken.mulDown(Math.ONE - state.feeRate);
+        if (
+            netTokenIn.mulDown(postFeeRateTokenToSy) > state.totalSy ||
+            netSyIn.mulDown(postFeeRateSyToToken) > state.totalToken
+        ) {
+            return (address(0), 0, 0);
+        }
+
+        // return...
+        totalToken = state.totalToken;
+        totalSy = state.totalSy;
+    }
+
+    function _readBulkSellerState(address bulk) internal view returns (BulkSellerState memory) {
+        return IPBulkSeller(bulk).readState();
+    }
+}

package/contracts/offchain-helpers/router-static/base/ActionStorageStatic.sol

@@ -0,0 +1,76 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+import "./StorageLayout.sol";
+import "../../../interfaces/IPActionStorageStatic.sol";
+import "../../../interfaces/IPMiniDiamond.sol";
+
+contract ActionStorageStatic is StorageLayout, IPActionStorageStatic, IPMiniDiamond {
+    function setDefaultApproxParams(ApproxParams memory params) external onlyOwner {
+        defaultApproxParams = params;
+    }
+
+    function setBulkSellerFactory(address _bulkSellerFactory) external onlyOwner {
+        bulkSellerFactory = IPBulkSellerFactory(_bulkSellerFactory);
+    }
+
+    function getDefaultApproxParams() external view returns (ApproxParams memory) {
+        return defaultApproxParams;
+    }
+
+    function getBulkSellerFactory() external view returns (address) {
+        return address(bulkSellerFactory);
+    }
+
+    function getOwnerAndPendingOwner()
+        external
+        view
+        returns (address _owner, address _pendingOwner)
+    {
+        _owner = owner;
+        _pendingOwner = pendingOwner;
+    }
+
+    function setFacetForSelectors(SelectorsToFacet[] calldata arr) external onlyOwner {
+        for (uint256 i = 0; i < arr.length; ) {
+            SelectorsToFacet memory s = arr[i];
+            for (uint256 j = 0; j < s.selectors.length; ) {
+                selectorToFacet[s.selectors[j]] = s.facet;
+                unchecked {
+                    j++;
+                }
+            }
+            unchecked {
+                i++;
+            }
+        }
+    }
+
+    function facetAddress(bytes4 selector) external view returns (address res) {
+        res = selectorToFacet[selector];
+        require(res != address(0), "selector not found");
+    }
+
+    // Ownable
+    function transferOwnership(address newOwner, bool direct, bool renounce) external onlyOwner {
+        if (direct) {
+            require(newOwner != address(0) || renounce, "Ownable: zero address");
+
+            emit OwnershipTransferred(owner, newOwner);
+            owner = newOwner;
+            pendingOwner = address(0);
+        } else {
+            pendingOwner = newOwner;
+        }
+    }
+
+    function claimOwnership() external {
+        address _pendingOwner = pendingOwner;
+
+        require(msg.sender == _pendingOwner, "Ownable: caller != pending owner");
+
+        emit OwnershipTransferred(owner, _pendingOwner);
+        owner = _pendingOwner;
+        pendingOwner = address(0);
+    }
+}

package/contracts/offchain-helpers/router-static/base/ActionVePendleStatic.sol

@@ -0,0 +1,55 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+import "../../../core/libraries/MiniHelpers.sol";
+import "../../../interfaces/IPRouterStatic.sol";
+import "../../../interfaces/IPVotingEscrowMainchain.sol";
+import "../../../LiquidityMining/libraries/VeBalanceLib.sol";
+
+contract ActionVePendleStatic is IPActionVePendleStatic {
+    using VeBalanceLib for VeBalance;
+    using VeBalanceLib for LockedPosition;
+
+    uint128 private constant MAX_LOCK_TIME = 104 weeks;
+    uint128 private constant MIN_LOCK_TIME = 1 weeks;
+
+    IPVotingEscrowMainchain private immutable vePENDLE;
+
+    constructor(IPVotingEscrowMainchain _vePENDLE) {
+        vePENDLE = _vePENDLE;
+    }
+
+    function increaseLockPositionStatic(
+        address user,
+        uint128 additionalAmountToLock,
+        uint128 newExpiry
+    ) external view returns (uint128 newVeBalance) {
+        if (!WeekMath.isValidWTime(newExpiry)) revert Errors.InvalidWTime(newExpiry);
+        if (MiniHelpers.isTimeInThePast(newExpiry)) revert Errors.ExpiryInThePast(newExpiry);
+
+        if (newExpiry > block.timestamp + MAX_LOCK_TIME) revert Errors.VEExceededMaxLockTime();
+        if (newExpiry < block.timestamp + MIN_LOCK_TIME) revert Errors.VEInsufficientLockTime();
+
+        LockedPosition memory oldPosition;
+
+        {
+            (uint128 amount, uint128 expiry) = vePENDLE.positionData(user);
+            oldPosition = LockedPosition(amount, expiry);
+        }
+
+        if (newExpiry < oldPosition.expiry) revert Errors.VENotAllowedReduceExpiry();
+
+        uint128 newTotalAmountLocked = additionalAmountToLock + oldPosition.amount;
+        if (newTotalAmountLocked == 0) revert Errors.VEZeroAmountLocked();
+
+        uint128 additionalDurationToLock = newExpiry - oldPosition.expiry;
+
+        LockedPosition memory newPosition = LockedPosition(
+            oldPosition.amount + additionalAmountToLock,
+            oldPosition.expiry + additionalDurationToLock
+        );
+
+        VeBalance memory newBalance = newPosition.convertToVeBalance();
+        return newBalance.getCurrentValue();
+    }
+}

package/contracts/offchain-helpers/router-static/base/StorageLayout.sol

@@ -0,0 +1,21 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+import "../../../router/base/MarketApproxLib.sol";
+import "../../../interfaces/IPBulkSellerFactory.sol";
+
+abstract contract StorageLayout {
+    address internal owner;
+    address internal pendingOwner;
+
+    mapping(bytes4 => address) internal selectorToFacet;
+
+    ApproxParams internal defaultApproxParams;
+
+    IPBulkSellerFactory internal bulkSellerFactory;
+
+    modifier onlyOwner() {
+        require(msg.sender == owner, "Ownable: caller is not the owner");
+        _;
+    }
+}

package/contracts/router/ActionAddRemoveLiq.sol

@@ -37,14 +37,7 @@ contract ActionAddRemoveLiq is IPActionAddRemoveLiq, ActionBaseMintRedeem {
         uint256 netSyDesired,
         uint256 netPtDesired,
         uint256 minLpOut
-    )
-        external
-        returns (
-            uint256 netLpOut,
-            uint256 netSyUsed,
-            uint256 netPtUsed
-        )
-    {
+    ) external returns (uint256 netLpOut, uint256 netSyUsed, uint256 netPtUsed) {
         (IStandardizedYield SY, IPPrincipalToken PT, ) = IPMarket(market).readTokens();
 
         // calculate the amount of SY and PT to be used
@@ -87,15 +80,7 @@ contract ActionAddRemoveLiq is IPActionAddRemoveLiq, ActionBaseMintRedeem {
         TokenInput calldata input,
         uint256 netPtDesired,
         uint256 minLpOut
-    )
-        external
-        payable
-        returns (
-            uint256 netLpOut,
-            uint256 netTokenUsed,
-            uint256 netPtUsed
-        )
-    {
+    ) external payable returns (uint256 netLpOut, uint256 netTokenUsed, uint256 netPtUsed) {
         (IStandardizedYield SY, IPPrincipalToken PT, ) = IPMarket(market).readTokens();
 
         uint256 netSyDesired = _mintSyFromToken(market, address(SY), 1, input);

package/contracts/router/ActionSwapYT.sol

@@ -19,9 +19,15 @@ contract ActionSwapYT is ActionBaseCallback, IPActionSwapYT, ActionBaseMintRedee
     using MarketApproxPtOutLib for MarketState;
     using PYIndexLib for IPYieldToken;
 
-    constructor(IAddressProvider provider, uint256 providerId) ActionBaseCallback(_getMarketFactory(provider,providerId)) {}
-
-    function _getMarketFactory(IAddressProvider provider, uint256 providerId) internal view returns (address) {
+    constructor(
+        IAddressProvider provider,
+        uint256 providerId
+    ) ActionBaseCallback(_getMarketFactory(provider, providerId)) {}
+
+    function _getMarketFactory(
+        IAddressProvider provider,
+        uint256 providerId
+    ) internal view returns (address) {
         return provider.get(providerId);
     }
 

package/contracts/router/base/ActionBaseCallback.sol

@@ -58,7 +58,7 @@ abstract contract ActionBaseCallback is IPMarketSwapCallback, CallbackHelper, To
     /// @dev refer to _swapExactSyForYt
     function _callbackSwapExactSyForYt(
         int256 ptToAccount,
-        int256, /*syToAccount*/
+        int256 /*syToAccount*/,
         bytes calldata data
     ) internal {
         (address receiver, uint256 minYtOut, IPYieldToken YT) = _decodeSwapExactSyForYt(data);
@@ -139,7 +139,7 @@ abstract contract ActionBaseCallback is IPMarketSwapCallback, CallbackHelper, To
 
     function _callbackSwapExactPtForYt(
         int256 ptToAccount,
-        int256, /*syToAccount*/
+        int256 /*syToAccount*/,
         bytes calldata data
     ) internal {
         (

package/contracts/router/base/ActionBaseMintRedeem.sol

@@ -193,11 +193,10 @@ abstract contract ActionBaseMintRedeem is TokenHelper {
         if (netSyOut < minSyOut) revert Errors.RouterInsufficientSyOut(netSyOut, minSyOut);
     }
 
-    function _syOrBulk(address SY, TokenOutput calldata output)
-        internal
-        pure
-        returns (address addr)
-    {
+    function _syOrBulk(
+        address SY,
+        TokenOutput calldata output
+    ) internal pure returns (address addr) {
         return output.bulk != address(0) ? output.bulk : SY;
     }
 }

package/contracts/router/base/CallbackHelper.sol

@@ -34,15 +34,9 @@ abstract contract CallbackHelper {
         }
     }
 
-    function _decodeSwapExactSyForYt(bytes calldata data)
-        internal
-        pure
-        returns (
-            address receiver,
-            uint256 minYtOut,
-            IPYieldToken YT
-        )
-    {
+    function _decodeSwapExactSyForYt(
+        bytes calldata data
+    ) internal pure returns (address receiver, uint256 minYtOut, IPYieldToken YT) {
         assembly {
             // first 32 bytes is ActionType
             receiver := calldataload(add(data.offset, 32))
@@ -75,7 +69,9 @@ abstract contract CallbackHelper {
         }
     }
 
-    function _decodeSwapSyForExactYt(bytes calldata data)
+    function _decodeSwapSyForExactYt(
+        bytes calldata data
+    )
         internal
         pure
         returns (
@@ -116,15 +112,9 @@ abstract contract CallbackHelper {
         }
     }
 
-    function _decodeSwapYtForSy(bytes calldata data)
-        internal
-        pure
-        returns (
-            address receiver,
-            uint256 minSyOut,
-            IPYieldToken YT
-        )
-    {
+    function _decodeSwapYtForSy(
+        bytes calldata data
+    ) internal pure returns (address receiver, uint256 minSyOut, IPYieldToken YT) {
         assembly {
             // first 32 bytes is ActionType
             receiver := calldataload(add(data.offset, 32))
@@ -153,7 +143,9 @@ abstract contract CallbackHelper {
         }
     }
 
-    function _decodeSwapExactYtForPt(bytes calldata data)
+    function _decodeSwapExactYtForPt(
+        bytes calldata data
+    )
         internal
         pure
         returns (
@@ -192,15 +184,12 @@ abstract contract CallbackHelper {
         }
     }
 
-    function _decodeSwapExactPtForYt(bytes calldata data)
+    function _decodeSwapExactPtForYt(
+        bytes calldata data
+    )
         internal
         pure
-        returns (
-            address receiver,
-            uint256 exactPtIn,
-            uint256 minYtOut,
-            IPYieldToken YT
-        )
+        returns (address receiver, uint256 exactPtIn, uint256 minYtOut, IPYieldToken YT)
     {
         assembly {
             // first 32 bytes is ActionType

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);
+}