@uniswap/router-sdk 1.22.3 → 2.0.0

package/dist/{swapRouter.d.ts → cjs/src/swapRouter.d.ts}

@@ -1,95 +1,95 @@
-import { Interface } from '@ethersproject/abi';
-import { Currency, Percent, TradeType } from '@uniswap/sdk-core';
-import { Trade as V2Trade } from '@uniswap/v2-sdk';
-import { FeeOptions, MethodParameters, PermitOptions, Position, Trade as V3Trade } from '@uniswap/v3-sdk';
-import { ApprovalTypes, CondensedAddLiquidityOptions } from './approveAndCall';
-import { Trade } from './entities/trade';
-import { Validation } from './multicallExtended';
-import { MixedRouteTrade } from './entities/mixedRoute/trade';
-/**
- * Options for producing the arguments to send calls to the router.
- */
-export interface SwapOptions {
-    /**
-     * How much the execution price is allowed to move unfavorably from the trade execution price.
-     */
-    slippageTolerance: Percent;
-    /**
-     * The account that should receive the output. If omitted, output is sent to msg.sender.
-     */
-    recipient?: string;
-    /**
-     * Either deadline (when the transaction expires, in epoch seconds), or previousBlockhash.
-     */
-    deadlineOrPreviousBlockhash?: Validation;
-    /**
-     * The optional permit parameters for spending the input.
-     */
-    inputTokenPermit?: PermitOptions;
-    /**
-     * Optional information for taking a fee on output.
-     */
-    fee?: FeeOptions;
-}
-export interface SwapAndAddOptions extends SwapOptions {
-    /**
-     * The optional permit parameters for pulling in remaining output token.
-     */
-    outputTokenPermit?: PermitOptions;
-}
-declare type AnyTradeType = Trade<Currency, Currency, TradeType> | V2Trade<Currency, Currency, TradeType> | V3Trade<Currency, Currency, TradeType> | MixedRouteTrade<Currency, Currency, TradeType> | (V2Trade<Currency, Currency, TradeType> | V3Trade<Currency, Currency, TradeType> | MixedRouteTrade<Currency, Currency, TradeType>)[];
-/**
- * Represents the Uniswap V2 + V3 SwapRouter02, and has static methods for helping execute trades.
- */
-export declare abstract class SwapRouter {
-    static INTERFACE: Interface;
-    /**
-     * Cannot be constructed.
-     */
-    private constructor();
-    /**
-     * @notice Generates the calldata for a Swap with a V2 Route.
-     * @param trade The V2Trade to encode.
-     * @param options SwapOptions to use for the trade.
-     * @param routerMustCustody Flag for whether funds should be sent to the router
-     * @param performAggregatedSlippageCheck Flag for whether we want to perform an aggregated slippage check
-     * @returns A string array of calldatas for the trade.
-     */
-    private static encodeV2Swap;
-    /**
-     * @notice Generates the calldata for a Swap with a V3 Route.
-     * @param trade The V3Trade to encode.
-     * @param options SwapOptions to use for the trade.
-     * @param routerMustCustody Flag for whether funds should be sent to the router
-     * @param performAggregatedSlippageCheck Flag for whether we want to perform an aggregated slippage check
-     * @returns A string array of calldatas for the trade.
-     */
-    private static encodeV3Swap;
-    /**
-     * @notice Generates the calldata for a MixedRouteSwap. Since single hop routes are not MixedRoutes, we will instead generate
-     *         them via the existing encodeV3Swap and encodeV2Swap methods.
-     * @param trade The MixedRouteTrade to encode.
-     * @param options SwapOptions to use for the trade.
-     * @param routerMustCustody Flag for whether funds should be sent to the router
-     * @param performAggregatedSlippageCheck Flag for whether we want to perform an aggregated slippage check
-     * @returns A string array of calldatas for the trade.
-     */
-    private static encodeMixedRouteSwap;
-    private static encodeSwaps;
-    /**
-     * Produces the on-chain method name to call and the hex encoded parameters to pass as arguments for a given trade.
-     * @param trades to produce call parameters for
-     * @param options options for the call parameters
-     */
-    static swapCallParameters(trades: Trade<Currency, Currency, TradeType> | V2Trade<Currency, Currency, TradeType> | V3Trade<Currency, Currency, TradeType> | MixedRouteTrade<Currency, Currency, TradeType> | (V2Trade<Currency, Currency, TradeType> | V3Trade<Currency, Currency, TradeType> | MixedRouteTrade<Currency, Currency, TradeType>)[], options: SwapOptions): MethodParameters;
-    /**
-     * Produces the on-chain method name to call and the hex encoded parameters to pass as arguments for a given trade.
-     * @param trades to produce call parameters for
-     * @param options options for the call parameters
-     */
-    static swapAndAddCallParameters(trades: AnyTradeType, options: SwapAndAddOptions, position: Position, addLiquidityOptions: CondensedAddLiquidityOptions, tokenInApprovalType: ApprovalTypes, tokenOutApprovalType: ApprovalTypes): MethodParameters;
-    private static riskOfPartialFill;
-    private static v3TradeWithHighPriceImpact;
-    private static getPositionAmounts;
-}
-export {};
+import { Interface } from '@ethersproject/abi';
+import { Currency, Percent, TradeType } from '@uniswap/sdk-core';
+import { Trade as V2Trade } from '@uniswap/v2-sdk';
+import { FeeOptions, MethodParameters, PermitOptions, Position, Trade as V3Trade } from '@uniswap/v3-sdk';
+import { ApprovalTypes, CondensedAddLiquidityOptions } from './approveAndCall';
+import { Trade } from './entities/trade';
+import { Validation } from './multicallExtended';
+import { MixedRouteTrade } from './entities/mixedRoute/trade';
+/**
+ * Options for producing the arguments to send calls to the router.
+ */
+export interface SwapOptions {
+    /**
+     * How much the execution price is allowed to move unfavorably from the trade execution price.
+     */
+    slippageTolerance: Percent;
+    /**
+     * The account that should receive the output. If omitted, output is sent to msg.sender.
+     */
+    recipient?: string;
+    /**
+     * Either deadline (when the transaction expires, in epoch seconds), or previousBlockhash.
+     */
+    deadlineOrPreviousBlockhash?: Validation;
+    /**
+     * The optional permit parameters for spending the input.
+     */
+    inputTokenPermit?: PermitOptions;
+    /**
+     * Optional information for taking a fee on output.
+     */
+    fee?: FeeOptions;
+}
+export interface SwapAndAddOptions extends SwapOptions {
+    /**
+     * The optional permit parameters for pulling in remaining output token.
+     */
+    outputTokenPermit?: PermitOptions;
+}
+type AnyTradeType = Trade<Currency, Currency, TradeType> | V2Trade<Currency, Currency, TradeType> | V3Trade<Currency, Currency, TradeType> | MixedRouteTrade<Currency, Currency, TradeType> | (V2Trade<Currency, Currency, TradeType> | V3Trade<Currency, Currency, TradeType> | MixedRouteTrade<Currency, Currency, TradeType>)[];
+/**
+ * Represents the Uniswap V2 + V3 SwapRouter02, and has static methods for helping execute trades.
+ */
+export declare abstract class SwapRouter {
+    static INTERFACE: Interface;
+    /**
+     * Cannot be constructed.
+     */
+    private constructor();
+    /**
+     * @notice Generates the calldata for a Swap with a V2 Route.
+     * @param trade The V2Trade to encode.
+     * @param options SwapOptions to use for the trade.
+     * @param routerMustCustody Flag for whether funds should be sent to the router
+     * @param performAggregatedSlippageCheck Flag for whether we want to perform an aggregated slippage check
+     * @returns A string array of calldatas for the trade.
+     */
+    private static encodeV2Swap;
+    /**
+     * @notice Generates the calldata for a Swap with a V3 Route.
+     * @param trade The V3Trade to encode.
+     * @param options SwapOptions to use for the trade.
+     * @param routerMustCustody Flag for whether funds should be sent to the router
+     * @param performAggregatedSlippageCheck Flag for whether we want to perform an aggregated slippage check
+     * @returns A string array of calldatas for the trade.
+     */
+    private static encodeV3Swap;
+    /**
+     * @notice Generates the calldata for a MixedRouteSwap. Since single hop routes are not MixedRoutes, we will instead generate
+     *         them via the existing encodeV3Swap and encodeV2Swap methods.
+     * @param trade The MixedRouteTrade to encode.
+     * @param options SwapOptions to use for the trade.
+     * @param routerMustCustody Flag for whether funds should be sent to the router
+     * @param performAggregatedSlippageCheck Flag for whether we want to perform an aggregated slippage check
+     * @returns A string array of calldatas for the trade.
+     */
+    private static encodeMixedRouteSwap;
+    private static encodeSwaps;
+    /**
+     * Produces the on-chain method name to call and the hex encoded parameters to pass as arguments for a given trade.
+     * @param trades to produce call parameters for
+     * @param options options for the call parameters
+     */
+    static swapCallParameters(trades: Trade<Currency, Currency, TradeType> | V2Trade<Currency, Currency, TradeType> | V3Trade<Currency, Currency, TradeType> | MixedRouteTrade<Currency, Currency, TradeType> | (V2Trade<Currency, Currency, TradeType> | V3Trade<Currency, Currency, TradeType> | MixedRouteTrade<Currency, Currency, TradeType>)[], options: SwapOptions): MethodParameters;
+    /**
+     * Produces the on-chain method name to call and the hex encoded parameters to pass as arguments for a given trade.
+     * @param trades to produce call parameters for
+     * @param options options for the call parameters
+     */
+    static swapAndAddCallParameters(trades: AnyTradeType, options: SwapAndAddOptions, position: Position, addLiquidityOptions: CondensedAddLiquidityOptions, tokenInApprovalType: ApprovalTypes, tokenOutApprovalType: ApprovalTypes): MethodParameters;
+    private static riskOfPartialFill;
+    private static v3TradeWithHighPriceImpact;
+    private static getPositionAmounts;
+}
+export {};

package/dist/cjs/src/swapRouter.js

@@ -0,0 +1,439 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SwapRouter = void 0;
+const tslib_1 = require("tslib");
+const abi_1 = require("@ethersproject/abi");
+const sdk_core_1 = require("@uniswap/sdk-core");
+const ISwapRouter02_json_1 = require("@uniswap/swap-router-contracts/artifacts/contracts/interfaces/ISwapRouter02.sol/ISwapRouter02.json");
+const v2_sdk_1 = require("@uniswap/v2-sdk");
+const v3_sdk_1 = require("@uniswap/v3-sdk");
+const v4_sdk_1 = require("@uniswap/v4-sdk");
+const tiny_invariant_1 = tslib_1.__importDefault(require("tiny-invariant"));
+const jsbi_1 = tslib_1.__importDefault(require("jsbi"));
+const constants_1 = require("./constants");
+const approveAndCall_1 = require("./approveAndCall");
+const trade_1 = require("./entities/trade");
+const protocol_1 = require("./entities/protocol");
+const route_1 = require("./entities/route");
+const multicallExtended_1 = require("./multicallExtended");
+const paymentsExtended_1 = require("./paymentsExtended");
+const trade_2 = require("./entities/mixedRoute/trade");
+const encodeMixedRouteToPath_1 = require("./utils/encodeMixedRouteToPath");
+const route_2 = require("./entities/mixedRoute/route");
+const utils_1 = require("./utils");
+const ZERO = jsbi_1.default.BigInt(0);
+const REFUND_ETH_PRICE_IMPACT_THRESHOLD = new sdk_core_1.Percent(jsbi_1.default.BigInt(50), jsbi_1.default.BigInt(100));
+/**
+ * Represents the Uniswap V2 + V3 SwapRouter02, and has static methods for helping execute trades.
+ */
+class SwapRouter {
+    /**
+     * Cannot be constructed.
+     */
+    constructor() { }
+    /**
+     * @notice Generates the calldata for a Swap with a V2 Route.
+     * @param trade The V2Trade to encode.
+     * @param options SwapOptions to use for the trade.
+     * @param routerMustCustody Flag for whether funds should be sent to the router
+     * @param performAggregatedSlippageCheck Flag for whether we want to perform an aggregated slippage check
+     * @returns A string array of calldatas for the trade.
+     */
+    static encodeV2Swap(trade, options, routerMustCustody, performAggregatedSlippageCheck) {
+        const amountIn = (0, v3_sdk_1.toHex)(trade.maximumAmountIn(options.slippageTolerance).quotient);
+        const amountOut = (0, v3_sdk_1.toHex)(trade.minimumAmountOut(options.slippageTolerance).quotient);
+        const path = trade.route.path.map((token) => token.address);
+        const recipient = routerMustCustody
+            ? constants_1.ADDRESS_THIS
+            : typeof options.recipient === 'undefined'
+                ? constants_1.MSG_SENDER
+                : (0, sdk_core_1.validateAndParseAddress)(options.recipient);
+        if (trade.tradeType === sdk_core_1.TradeType.EXACT_INPUT) {
+            const exactInputParams = [amountIn, performAggregatedSlippageCheck ? 0 : amountOut, path, recipient];
+            return SwapRouter.INTERFACE.encodeFunctionData('swapExactTokensForTokens', exactInputParams);
+        }
+        else {
+            const exactOutputParams = [amountOut, amountIn, path, recipient];
+            return SwapRouter.INTERFACE.encodeFunctionData('swapTokensForExactTokens', exactOutputParams);
+        }
+    }
+    /**
+     * @notice Generates the calldata for a Swap with a V3 Route.
+     * @param trade The V3Trade to encode.
+     * @param options SwapOptions to use for the trade.
+     * @param routerMustCustody Flag for whether funds should be sent to the router
+     * @param performAggregatedSlippageCheck Flag for whether we want to perform an aggregated slippage check
+     * @returns A string array of calldatas for the trade.
+     */
+    static encodeV3Swap(trade, options, routerMustCustody, performAggregatedSlippageCheck) {
+        const calldatas = [];
+        for (const { route, inputAmount, outputAmount } of trade.swaps) {
+            const amountIn = (0, v3_sdk_1.toHex)(trade.maximumAmountIn(options.slippageTolerance, inputAmount).quotient);
+            const amountOut = (0, v3_sdk_1.toHex)(trade.minimumAmountOut(options.slippageTolerance, outputAmount).quotient);
+            // flag for whether the trade is single hop or not
+            const singleHop = route.pools.length === 1;
+            const recipient = routerMustCustody
+                ? constants_1.ADDRESS_THIS
+                : typeof options.recipient === 'undefined'
+                    ? constants_1.MSG_SENDER
+                    : (0, sdk_core_1.validateAndParseAddress)(options.recipient);
+            if (singleHop) {
+                if (trade.tradeType === sdk_core_1.TradeType.EXACT_INPUT) {
+                    const exactInputSingleParams = {
+                        tokenIn: route.tokenPath[0].address,
+                        tokenOut: route.tokenPath[1].address,
+                        fee: route.pools[0].fee,
+                        recipient,
+                        amountIn,
+                        amountOutMinimum: performAggregatedSlippageCheck ? 0 : amountOut,
+                        sqrtPriceLimitX96: 0,
+                    };
+                    calldatas.push(SwapRouter.INTERFACE.encodeFunctionData('exactInputSingle', [exactInputSingleParams]));
+                }
+                else {
+                    const exactOutputSingleParams = {
+                        tokenIn: route.tokenPath[0].address,
+                        tokenOut: route.tokenPath[1].address,
+                        fee: route.pools[0].fee,
+                        recipient,
+                        amountOut,
+                        amountInMaximum: amountIn,
+                        sqrtPriceLimitX96: 0,
+                    };
+                    calldatas.push(SwapRouter.INTERFACE.encodeFunctionData('exactOutputSingle', [exactOutputSingleParams]));
+                }
+            }
+            else {
+                const path = (0, v3_sdk_1.encodeRouteToPath)(route, trade.tradeType === sdk_core_1.TradeType.EXACT_OUTPUT);
+                if (trade.tradeType === sdk_core_1.TradeType.EXACT_INPUT) {
+                    const exactInputParams = {
+                        path,
+                        recipient,
+                        amountIn,
+                        amountOutMinimum: performAggregatedSlippageCheck ? 0 : amountOut,
+                    };
+                    calldatas.push(SwapRouter.INTERFACE.encodeFunctionData('exactInput', [exactInputParams]));
+                }
+                else {
+                    const exactOutputParams = {
+                        path,
+                        recipient,
+                        amountOut,
+                        amountInMaximum: amountIn,
+                    };
+                    calldatas.push(SwapRouter.INTERFACE.encodeFunctionData('exactOutput', [exactOutputParams]));
+                }
+            }
+        }
+        return calldatas;
+    }
+    /**
+     * @notice Generates the calldata for a MixedRouteSwap. Since single hop routes are not MixedRoutes, we will instead generate
+     *         them via the existing encodeV3Swap and encodeV2Swap methods.
+     * @param trade The MixedRouteTrade to encode.
+     * @param options SwapOptions to use for the trade.
+     * @param routerMustCustody Flag for whether funds should be sent to the router
+     * @param performAggregatedSlippageCheck Flag for whether we want to perform an aggregated slippage check
+     * @returns A string array of calldatas for the trade.
+     */
+    static encodeMixedRouteSwap(trade, options, routerMustCustody, performAggregatedSlippageCheck) {
+        const calldatas = [];
+        (0, tiny_invariant_1.default)(trade.tradeType === sdk_core_1.TradeType.EXACT_INPUT, 'TRADE_TYPE');
+        for (const { route, inputAmount, outputAmount } of trade.swaps) {
+            if (route.pools.some((pool) => pool instanceof v4_sdk_1.Pool))
+                throw 'Encoding mixed routes with V4 not supported';
+            const amountIn = (0, v3_sdk_1.toHex)(trade.maximumAmountIn(options.slippageTolerance, inputAmount).quotient);
+            const amountOut = (0, v3_sdk_1.toHex)(trade.minimumAmountOut(options.slippageTolerance, outputAmount).quotient);
+            // flag for whether the trade is single hop or not
+            const singleHop = route.pools.length === 1;
+            const recipient = routerMustCustody
+                ? constants_1.ADDRESS_THIS
+                : typeof options.recipient === 'undefined'
+                    ? constants_1.MSG_SENDER
+                    : (0, sdk_core_1.validateAndParseAddress)(options.recipient);
+            const mixedRouteIsAllV3 = (route) => {
+                return route.pools.every((pool) => pool instanceof v3_sdk_1.Pool);
+            };
+            if (singleHop) {
+                /// For single hop, since it isn't really a mixedRoute, we'll just mimic behavior of V3 or V2
+                /// We don't use encodeV3Swap() or encodeV2Swap() because casting the trade to a V3Trade or V2Trade is overcomplex
+                if (mixedRouteIsAllV3(route)) {
+                    const exactInputSingleParams = {
+                        tokenIn: route.path[0].wrapped.address,
+                        tokenOut: route.path[1].wrapped.address,
+                        fee: route.pools[0].fee,
+                        recipient,
+                        amountIn,
+                        amountOutMinimum: performAggregatedSlippageCheck ? 0 : amountOut,
+                        sqrtPriceLimitX96: 0,
+                    };
+                    calldatas.push(SwapRouter.INTERFACE.encodeFunctionData('exactInputSingle', [exactInputSingleParams]));
+                }
+                else {
+                    const path = route.path.map((token) => token.wrapped.address);
+                    const exactInputParams = [amountIn, performAggregatedSlippageCheck ? 0 : amountOut, path, recipient];
+                    calldatas.push(SwapRouter.INTERFACE.encodeFunctionData('swapExactTokensForTokens', exactInputParams));
+                }
+            }
+            else {
+                const sections = (0, utils_1.partitionMixedRouteByProtocol)(route);
+                const isLastSectionInRoute = (i) => {
+                    return i === sections.length - 1;
+                };
+                let outputToken;
+                let inputToken = route.input.wrapped;
+                for (let i = 0; i < sections.length; i++) {
+                    const section = sections[i];
+                    /// Now, we get output of this section
+                    outputToken = (0, utils_1.getOutputOfPools)(section, inputToken);
+                    const newRouteOriginal = new route_2.MixedRouteSDK([...section], section[0].token0.equals(inputToken) ? section[0].token0 : section[0].token1, outputToken);
+                    const newRoute = new route_1.MixedRoute(newRouteOriginal);
+                    /// Previous output is now input
+                    inputToken = outputToken.wrapped;
+                    if (mixedRouteIsAllV3(newRoute)) {
+                        const path = (0, encodeMixedRouteToPath_1.encodeMixedRouteToPath)(newRoute);
+                        const exactInputParams = {
+                            path,
+                            // By default router holds funds until the last swap, then it is sent to the recipient
+                            // special case exists where we are unwrapping WETH output, in which case `routerMustCustody` is set to true
+                            // and router still holds the funds. That logic bundled into how the value of `recipient` is calculated
+                            recipient: isLastSectionInRoute(i) ? recipient : constants_1.ADDRESS_THIS,
+                            amountIn: i === 0 ? amountIn : 0,
+                            amountOutMinimum: !isLastSectionInRoute(i) ? 0 : amountOut,
+                        };
+                        calldatas.push(SwapRouter.INTERFACE.encodeFunctionData('exactInput', [exactInputParams]));
+                    }
+                    else {
+                        const exactInputParams = [
+                            i === 0 ? amountIn : 0,
+                            !isLastSectionInRoute(i) ? 0 : amountOut,
+                            newRoute.path.map((token) => token.wrapped.address),
+                            isLastSectionInRoute(i) ? recipient : constants_1.ADDRESS_THIS, // to
+                        ];
+                        calldatas.push(SwapRouter.INTERFACE.encodeFunctionData('swapExactTokensForTokens', exactInputParams));
+                    }
+                }
+            }
+        }
+        return calldatas;
+    }
+    static encodeSwaps(trades, options, isSwapAndAdd) {
+        // If dealing with an instance of the aggregated Trade object, unbundle it to individual trade objects.
+        if (trades instanceof trade_1.Trade) {
+            (0, tiny_invariant_1.default)(trades.swaps.every((swap) => swap.route.protocol === protocol_1.Protocol.V3 ||
+                swap.route.protocol === protocol_1.Protocol.V2 ||
+                swap.route.protocol === protocol_1.Protocol.MIXED), 'UNSUPPORTED_PROTOCOL (encoding routes with v4 not supported)');
+            let individualTrades = [];
+            for (const { route, inputAmount, outputAmount } of trades.swaps) {
+                if (route.protocol === protocol_1.Protocol.V2) {
+                    individualTrades.push(new v2_sdk_1.Trade(route, trades.tradeType === sdk_core_1.TradeType.EXACT_INPUT ? inputAmount : outputAmount, trades.tradeType));
+                }
+                else if (route.protocol === protocol_1.Protocol.V3) {
+                    individualTrades.push(v3_sdk_1.Trade.createUncheckedTrade({
+                        route: route,
+                        inputAmount,
+                        outputAmount,
+                        tradeType: trades.tradeType,
+                    }));
+                }
+                else if (route.protocol === protocol_1.Protocol.MIXED) {
+                    individualTrades.push(
+                    /// we can change the naming of this function on MixedRouteTrade if needed
+                    trade_2.MixedRouteTrade.createUncheckedTrade({
+                        route: route,
+                        inputAmount,
+                        outputAmount,
+                        tradeType: trades.tradeType,
+                    }));
+                }
+                else {
+                    throw new Error('UNSUPPORTED_TRADE_PROTOCOL');
+                }
+            }
+            trades = individualTrades;
+        }
+        if (!Array.isArray(trades)) {
+            trades = [trades];
+        }
+        const numberOfTrades = trades.reduce((numberOfTrades, trade) => numberOfTrades + (trade instanceof v3_sdk_1.Trade || trade instanceof trade_2.MixedRouteTrade ? trade.swaps.length : 1), 0);
+        const sampleTrade = trades[0];
+        // All trades should have the same starting/ending currency and trade type
+        (0, tiny_invariant_1.default)(trades.every((trade) => trade.inputAmount.currency.equals(sampleTrade.inputAmount.currency)), 'TOKEN_IN_DIFF');
+        (0, tiny_invariant_1.default)(trades.every((trade) => trade.outputAmount.currency.equals(sampleTrade.outputAmount.currency)), 'TOKEN_OUT_DIFF');
+        (0, tiny_invariant_1.default)(trades.every((trade) => trade.tradeType === sampleTrade.tradeType), 'TRADE_TYPE_DIFF');
+        const calldatas = [];
+        const inputIsNative = sampleTrade.inputAmount.currency.isNative;
+        const outputIsNative = sampleTrade.outputAmount.currency.isNative;
+        // flag for whether we want to perform an aggregated slippage check
+        //   1. when there are >2 exact input trades. this is only a heuristic,
+        //      as it's still more gas-expensive even in this case, but has benefits
+        //      in that the reversion probability is lower
+        const performAggregatedSlippageCheck = sampleTrade.tradeType === sdk_core_1.TradeType.EXACT_INPUT && numberOfTrades > 2;
+        // flag for whether funds should be send first to the router
+        //   1. when receiving ETH (which much be unwrapped from WETH)
+        //   2. when a fee on the output is being taken
+        //   3. when performing swap and add
+        //   4. when performing an aggregated slippage check
+        const routerMustCustody = outputIsNative || !!options.fee || !!isSwapAndAdd || performAggregatedSlippageCheck;
+        // encode permit if necessary
+        if (options.inputTokenPermit) {
+            (0, tiny_invariant_1.default)(sampleTrade.inputAmount.currency.isToken, 'NON_TOKEN_PERMIT');
+            calldatas.push(v3_sdk_1.SelfPermit.encodePermit(sampleTrade.inputAmount.currency, options.inputTokenPermit));
+        }
+        for (const trade of trades) {
+            if (trade instanceof v2_sdk_1.Trade) {
+                calldatas.push(SwapRouter.encodeV2Swap(trade, options, routerMustCustody, performAggregatedSlippageCheck));
+            }
+            else if (trade instanceof v3_sdk_1.Trade) {
+                for (const calldata of SwapRouter.encodeV3Swap(trade, options, routerMustCustody, performAggregatedSlippageCheck)) {
+                    calldatas.push(calldata);
+                }
+            }
+            else if (trade instanceof trade_2.MixedRouteTrade) {
+                for (const calldata of SwapRouter.encodeMixedRouteSwap(trade, options, routerMustCustody, performAggregatedSlippageCheck)) {
+                    calldatas.push(calldata);
+                }
+            }
+            else {
+                throw new Error('Unsupported trade object');
+            }
+        }
+        const ZERO_IN = sdk_core_1.CurrencyAmount.fromRawAmount(sampleTrade.inputAmount.currency, 0);
+        const ZERO_OUT = sdk_core_1.CurrencyAmount.fromRawAmount(sampleTrade.outputAmount.currency, 0);
+        const minimumAmountOut = trades.reduce((sum, trade) => sum.add(trade.minimumAmountOut(options.slippageTolerance)), ZERO_OUT);
+        const quoteAmountOut = trades.reduce((sum, trade) => sum.add(trade.outputAmount), ZERO_OUT);
+        const totalAmountIn = trades.reduce((sum, trade) => sum.add(trade.maximumAmountIn(options.slippageTolerance)), ZERO_IN);
+        return {
+            calldatas,
+            sampleTrade,
+            routerMustCustody,
+            inputIsNative,
+            outputIsNative,
+            totalAmountIn,
+            minimumAmountOut,
+            quoteAmountOut,
+        };
+    }
+    /**
+     * Produces the on-chain method name to call and the hex encoded parameters to pass as arguments for a given trade.
+     * @param trades to produce call parameters for
+     * @param options options for the call parameters
+     */
+    static swapCallParameters(trades, options) {
+        const { calldatas, sampleTrade, routerMustCustody, inputIsNative, outputIsNative, totalAmountIn, minimumAmountOut, } = SwapRouter.encodeSwaps(trades, options);
+        // unwrap or sweep
+        if (routerMustCustody) {
+            if (outputIsNative) {
+                calldatas.push(paymentsExtended_1.PaymentsExtended.encodeUnwrapWETH9(minimumAmountOut.quotient, options.recipient, options.fee));
+            }
+            else {
+                calldatas.push(paymentsExtended_1.PaymentsExtended.encodeSweepToken(sampleTrade.outputAmount.currency.wrapped, minimumAmountOut.quotient, options.recipient, options.fee));
+            }
+        }
+        // must refund when paying in ETH: either with an uncertain input amount OR if there's a chance of a partial fill.
+        // unlike ERC20's, the full ETH value must be sent in the transaction, so the rest must be refunded.
+        if (inputIsNative && (sampleTrade.tradeType === sdk_core_1.TradeType.EXACT_OUTPUT || SwapRouter.riskOfPartialFill(trades))) {
+            calldatas.push(v3_sdk_1.Payments.encodeRefundETH());
+        }
+        return {
+            calldata: multicallExtended_1.MulticallExtended.encodeMulticall(calldatas, options.deadlineOrPreviousBlockhash),
+            value: (0, v3_sdk_1.toHex)(inputIsNative ? totalAmountIn.quotient : ZERO),
+        };
+    }
+    /**
+     * Produces the on-chain method name to call and the hex encoded parameters to pass as arguments for a given trade.
+     * @param trades to produce call parameters for
+     * @param options options for the call parameters
+     */
+    static swapAndAddCallParameters(trades, options, position, addLiquidityOptions, tokenInApprovalType, tokenOutApprovalType) {
+        const { calldatas, inputIsNative, outputIsNative, sampleTrade, totalAmountIn: totalAmountSwapped, quoteAmountOut, minimumAmountOut, } = SwapRouter.encodeSwaps(trades, options, true);
+        // encode output token permit if necessary
+        if (options.outputTokenPermit) {
+            (0, tiny_invariant_1.default)(quoteAmountOut.currency.isToken, 'NON_TOKEN_PERMIT_OUTPUT');
+            calldatas.push(v3_sdk_1.SelfPermit.encodePermit(quoteAmountOut.currency, options.outputTokenPermit));
+        }
+        const chainId = sampleTrade.route.chainId;
+        const zeroForOne = position.pool.token0.wrapped.address === totalAmountSwapped.currency.wrapped.address;
+        const { positionAmountIn, positionAmountOut } = SwapRouter.getPositionAmounts(position, zeroForOne);
+        // if tokens are native they will be converted to WETH9
+        const tokenIn = inputIsNative ? sdk_core_1.WETH9[chainId] : positionAmountIn.currency.wrapped;
+        const tokenOut = outputIsNative ? sdk_core_1.WETH9[chainId] : positionAmountOut.currency.wrapped;
+        // if swap output does not make up whole outputTokenBalanceDesired, pull in remaining tokens for adding liquidity
+        const amountOutRemaining = positionAmountOut.subtract(quoteAmountOut.wrapped);
+        if (amountOutRemaining.greaterThan(sdk_core_1.CurrencyAmount.fromRawAmount(positionAmountOut.currency, 0))) {
+            // if output is native, this means the remaining portion is included as native value in the transaction
+            // and must be wrapped. Otherwise, pull in remaining ERC20 token.
+            outputIsNative
+                ? calldatas.push(paymentsExtended_1.PaymentsExtended.encodeWrapETH(amountOutRemaining.quotient))
+                : calldatas.push(paymentsExtended_1.PaymentsExtended.encodePull(tokenOut, amountOutRemaining.quotient));
+        }
+        // if input is native, convert to WETH9, else pull ERC20 token
+        inputIsNative
+            ? calldatas.push(paymentsExtended_1.PaymentsExtended.encodeWrapETH(positionAmountIn.quotient))
+            : calldatas.push(paymentsExtended_1.PaymentsExtended.encodePull(tokenIn, positionAmountIn.quotient));
+        // approve token balances to NFTManager
+        if (tokenInApprovalType !== approveAndCall_1.ApprovalTypes.NOT_REQUIRED)
+            calldatas.push(approveAndCall_1.ApproveAndCall.encodeApprove(tokenIn, tokenInApprovalType));
+        if (tokenOutApprovalType !== approveAndCall_1.ApprovalTypes.NOT_REQUIRED)
+            calldatas.push(approveAndCall_1.ApproveAndCall.encodeApprove(tokenOut, tokenOutApprovalType));
+        // represents a position with token amounts resulting from a swap with maximum slippage
+        // hence the minimal amount out possible.
+        const minimalPosition = v3_sdk_1.Position.fromAmounts({
+            pool: position.pool,
+            tickLower: position.tickLower,
+            tickUpper: position.tickUpper,
+            amount0: zeroForOne ? position.amount0.quotient.toString() : minimumAmountOut.quotient.toString(),
+            amount1: zeroForOne ? minimumAmountOut.quotient.toString() : position.amount1.quotient.toString(),
+            useFullPrecision: false,
+        });
+        // encode NFTManager add liquidity
+        calldatas.push(approveAndCall_1.ApproveAndCall.encodeAddLiquidity(position, minimalPosition, addLiquidityOptions, options.slippageTolerance));
+        // sweep remaining tokens
+        inputIsNative
+            ? calldatas.push(paymentsExtended_1.PaymentsExtended.encodeUnwrapWETH9(ZERO))
+            : calldatas.push(paymentsExtended_1.PaymentsExtended.encodeSweepToken(tokenIn, ZERO));
+        outputIsNative
+            ? calldatas.push(paymentsExtended_1.PaymentsExtended.encodeUnwrapWETH9(ZERO))
+            : calldatas.push(paymentsExtended_1.PaymentsExtended.encodeSweepToken(tokenOut, ZERO));
+        let value;
+        if (inputIsNative) {
+            value = totalAmountSwapped.wrapped.add(positionAmountIn.wrapped).quotient;
+        }
+        else if (outputIsNative) {
+            value = amountOutRemaining.quotient;
+        }
+        else {
+            value = ZERO;
+        }
+        return {
+            calldata: multicallExtended_1.MulticallExtended.encodeMulticall(calldatas, options.deadlineOrPreviousBlockhash),
+            value: value.toString(),
+        };
+    }
+    // if price impact is very high, there's a chance of hitting max/min prices resulting in a partial fill of the swap
+    static riskOfPartialFill(trades) {
+        if (Array.isArray(trades)) {
+            return trades.some((trade) => {
+                return SwapRouter.v3TradeWithHighPriceImpact(trade);
+            });
+        }
+        else {
+            return SwapRouter.v3TradeWithHighPriceImpact(trades);
+        }
+    }
+    static v3TradeWithHighPriceImpact(trade) {
+        return !(trade instanceof v2_sdk_1.Trade) && trade.priceImpact.greaterThan(REFUND_ETH_PRICE_IMPACT_THRESHOLD);
+    }
+    static getPositionAmounts(position, zeroForOne) {
+        const { amount0, amount1 } = position.mintAmounts;
+        const currencyAmount0 = sdk_core_1.CurrencyAmount.fromRawAmount(position.pool.token0, amount0);
+        const currencyAmount1 = sdk_core_1.CurrencyAmount.fromRawAmount(position.pool.token1, amount1);
+        const [positionAmountIn, positionAmountOut] = zeroForOne
+            ? [currencyAmount0, currencyAmount1]
+            : [currencyAmount1, currencyAmount0];
+        return { positionAmountIn, positionAmountOut };
+    }
+}
+exports.SwapRouter = SwapRouter;
+SwapRouter.INTERFACE = new abi_1.Interface(ISwapRouter02_json_1.abi);
+//# sourceMappingURL=swapRouter.js.map