@uniswap/router-sdk 2.7.3 → 2.9.0

package/dist/esm/src/multicallExtended.js

@@ -0,0 +1,39 @@
+import { Interface } from '@ethersproject/abi';
+import IMulticallExtended from '@uniswap/swap-router-contracts/artifacts/contracts/interfaces/IMulticallExtended.sol/IMulticallExtended.json';
+import { Multicall, toHex } from '@uniswap/v3-sdk';
+function validateAndParseBytes32(bytes32) {
+    if (!bytes32.match(/^0x[0-9a-fA-F]{64}$/)) {
+        throw new Error(`${bytes32} is not valid bytes32.`);
+    }
+    return bytes32.toLowerCase();
+}
+export class MulticallExtended {
+    /**
+     * Cannot be constructed.
+     */
+    constructor() { }
+    static encodeMulticall(calldatas, validation) {
+        // if there's no validation, we can just fall back to regular multicall
+        if (typeof validation === 'undefined') {
+            return Multicall.encodeMulticall(calldatas);
+        }
+        // if there is validation, we have to normalize calldatas
+        if (!Array.isArray(calldatas)) {
+            calldatas = [calldatas];
+        }
+        // this means the validation value should be a previousBlockhash
+        if (typeof validation === 'string' && validation.startsWith('0x')) {
+            const previousBlockhash = validateAndParseBytes32(validation);
+            return MulticallExtended.INTERFACE.encodeFunctionData('multicall(bytes32,bytes[])', [
+                previousBlockhash,
+                calldatas,
+            ]);
+        }
+        else {
+            const deadline = toHex(validation);
+            return MulticallExtended.INTERFACE.encodeFunctionData('multicall(uint256,bytes[])', [deadline, calldatas]);
+        }
+    }
+}
+MulticallExtended.INTERFACE = new Interface(IMulticallExtended.abi);
+//# sourceMappingURL=multicallExtended.js.map

package/dist/esm/src/multicallExtended.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"multicallExtended.js","sourceRoot":"","sources":["../../../src/multicallExtended.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAA;AAE9C,OAAO,kBAAkB,MAAM,8GAA8G,CAAA;AAC7I,OAAO,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAA;AAKlD,SAAS,uBAAuB,CAAC,OAAe;IAC9C,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,qBAAqB,CAAC,EAAE;QACzC,MAAM,IAAI,KAAK,CAAC,GAAG,OAAO,wBAAwB,CAAC,CAAA;KACpD;IAED,OAAO,OAAO,CAAC,WAAW,EAAE,CAAA;AAC9B,CAAC;AAED,MAAM,OAAgB,iBAAiB;IAGrC;;OAEG;IACH,gBAAuB,CAAC;IAEjB,MAAM,CAAC,eAAe,CAAC,SAA4B,EAAE,UAAuB;QACjF,uEAAuE;QACvE,IAAI,OAAO,UAAU,KAAK,WAAW,EAAE;YACrC,OAAO,SAAS,CAAC,eAAe,CAAC,SAAS,CAAC,CAAA;SAC5C;QAED,yDAAyD;QACzD,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,SAAS,CAAC,EAAE;YAC7B,SAAS,GAAG,CAAC,SAAS,CAAC,CAAA;SACxB;QAED,gEAAgE;QAChE,IAAI,OAAO,UAAU,KAAK,QAAQ,IAAI,UAAU,CAAC,UAAU,CAAC,IAAI,CAAC,EAAE;YACjE,MAAM,iBAAiB,GAAG,uBAAuB,CAAC,UAAU,CAAC,CAAA;YAC7D,OAAO,iBAAiB,CAAC,SAAS,CAAC,kBAAkB,CAAC,4BAA4B,EAAE;gBAClF,iBAAiB;gBACjB,SAAS;aACV,CAAC,CAAA;SACH;aAAM;YACL,MAAM,QAAQ,GAAG,KAAK,CAAC,UAAU,CAAC,CAAA;YAClC,OAAO,iBAAiB,CAAC,SAAS,CAAC,kBAAkB,CAAC,4BAA4B,EAAE,CAAC,QAAQ,EAAE,SAAS,CAAC,CAAC,CAAA;SAC3G;IACH,CAAC;;AA7Ba,2BAAS,GAAc,IAAI,SAAS,CAAC,kBAAkB,CAAC,GAAG,CAAC,CAAA"}

package/dist/esm/src/paymentsExtended.d.ts

@@ -0,0 +1,15 @@
+import { Interface } from '@ethersproject/abi';
+import { Token } from '@uniswap/sdk-core';
+import { FeeOptions } from '@uniswap/v3-sdk';
+import JSBI from 'jsbi';
+export declare abstract class PaymentsExtended {
+    static INTERFACE: Interface;
+    /**
+     * Cannot be constructed.
+     */
+    private constructor();
+    static encodeUnwrapWETH9(amountMinimum: JSBI, recipient?: string, feeOptions?: FeeOptions): string;
+    static encodeSweepToken(token: Token, amountMinimum: JSBI, recipient?: string, feeOptions?: FeeOptions): string;
+    static encodePull(token: Token, amount: JSBI): string;
+    static encodeWrapETH(amount: JSBI): string;
+}

package/dist/esm/src/paymentsExtended.js

@@ -0,0 +1,61 @@
+import { Interface } from '@ethersproject/abi';
+import { validateAndParseAddress } from '@uniswap/sdk-core';
+import IPeripheryPaymentsWithFeeExtended from '@uniswap/swap-router-contracts/artifacts/contracts/interfaces/IPeripheryPaymentsWithFeeExtended.sol/IPeripheryPaymentsWithFeeExtended.json';
+import { Payments, toHex } from '@uniswap/v3-sdk';
+function encodeFeeBips(fee) {
+    return toHex(fee.multiply(10000).quotient);
+}
+export class PaymentsExtended {
+    /**
+     * Cannot be constructed.
+     */
+    constructor() { }
+    static encodeUnwrapWETH9(amountMinimum, recipient, feeOptions) {
+        // if there's a recipient, just pass it along
+        if (typeof recipient === 'string') {
+            return Payments.encodeUnwrapWETH9(amountMinimum, recipient, feeOptions);
+        }
+        if (!!feeOptions) {
+            const feeBips = encodeFeeBips(feeOptions.fee);
+            const feeRecipient = validateAndParseAddress(feeOptions.recipient);
+            return PaymentsExtended.INTERFACE.encodeFunctionData('unwrapWETH9WithFee(uint256,uint256,address)', [
+                toHex(amountMinimum),
+                feeBips,
+                feeRecipient,
+            ]);
+        }
+        else {
+            return PaymentsExtended.INTERFACE.encodeFunctionData('unwrapWETH9(uint256)', [toHex(amountMinimum)]);
+        }
+    }
+    static encodeSweepToken(token, amountMinimum, recipient, feeOptions) {
+        // if there's a recipient, just pass it along
+        if (typeof recipient === 'string') {
+            return Payments.encodeSweepToken(token, amountMinimum, recipient, feeOptions);
+        }
+        if (!!feeOptions) {
+            const feeBips = encodeFeeBips(feeOptions.fee);
+            const feeRecipient = validateAndParseAddress(feeOptions.recipient);
+            return PaymentsExtended.INTERFACE.encodeFunctionData('sweepTokenWithFee(address,uint256,uint256,address)', [
+                token.address,
+                toHex(amountMinimum),
+                feeBips,
+                feeRecipient,
+            ]);
+        }
+        else {
+            return PaymentsExtended.INTERFACE.encodeFunctionData('sweepToken(address,uint256)', [
+                token.address,
+                toHex(amountMinimum),
+            ]);
+        }
+    }
+    static encodePull(token, amount) {
+        return PaymentsExtended.INTERFACE.encodeFunctionData('pull', [token.address, toHex(amount)]);
+    }
+    static encodeWrapETH(amount) {
+        return PaymentsExtended.INTERFACE.encodeFunctionData('wrapETH', [toHex(amount)]);
+    }
+}
+PaymentsExtended.INTERFACE = new Interface(IPeripheryPaymentsWithFeeExtended.abi);
+//# sourceMappingURL=paymentsExtended.js.map

package/dist/esm/src/paymentsExtended.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"paymentsExtended.js","sourceRoot":"","sources":["../../../src/paymentsExtended.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAA;AAC9C,OAAO,EAAkB,uBAAuB,EAAE,MAAM,mBAAmB,CAAA;AAC3E,OAAO,iCAAiC,MAAM,4IAA4I,CAAA;AAC1L,OAAO,EAAc,QAAQ,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAA;AAG7D,SAAS,aAAa,CAAC,GAAY;IACjC,OAAO,KAAK,CAAC,GAAG,CAAC,QAAQ,CAAC,KAAM,CAAC,CAAC,QAAQ,CAAC,CAAA;AAC7C,CAAC;AAED,MAAM,OAAgB,gBAAgB;IAGpC;;OAEG;IACH,gBAAuB,CAAC;IAEjB,MAAM,CAAC,iBAAiB,CAAC,aAAmB,EAAE,SAAkB,EAAE,UAAuB;QAC9F,6CAA6C;QAC7C,IAAI,OAAO,SAAS,KAAK,QAAQ,EAAE;YACjC,OAAO,QAAQ,CAAC,iBAAiB,CAAC,aAAa,EAAE,SAAS,EAAE,UAAU,CAAC,CAAA;SACxE;QAED,IAAI,CAAC,CAAC,UAAU,EAAE;YAChB,MAAM,OAAO,GAAG,aAAa,CAAC,UAAU,CAAC,GAAG,CAAC,CAAA;YAC7C,MAAM,YAAY,GAAG,uBAAuB,CAAC,UAAU,CAAC,SAAS,CAAC,CAAA;YAElE,OAAO,gBAAgB,CAAC,SAAS,CAAC,kBAAkB,CAAC,6CAA6C,EAAE;gBAClG,KAAK,CAAC,aAAa,CAAC;gBACpB,OAAO;gBACP,YAAY;aACb,CAAC,CAAA;SACH;aAAM;YACL,OAAO,gBAAgB,CAAC,SAAS,CAAC,kBAAkB,CAAC,sBAAsB,EAAE,CAAC,KAAK,CAAC,aAAa,CAAC,CAAC,CAAC,CAAA;SACrG;IACH,CAAC;IAEM,MAAM,CAAC,gBAAgB,CAC5B,KAAY,EACZ,aAAmB,EACnB,SAAkB,EAClB,UAAuB;QAEvB,6CAA6C;QAC7C,IAAI,OAAO,SAAS,KAAK,QAAQ,EAAE;YACjC,OAAO,QAAQ,CAAC,gBAAgB,CAAC,KAAK,EAAE,aAAa,EAAE,SAAS,EAAE,UAAU,CAAC,CAAA;SAC9E;QAED,IAAI,CAAC,CAAC,UAAU,EAAE;YAChB,MAAM,OAAO,GAAG,aAAa,CAAC,UAAU,CAAC,GAAG,CAAC,CAAA;YAC7C,MAAM,YAAY,GAAG,uBAAuB,CAAC,UAAU,CAAC,SAAS,CAAC,CAAA;YAElE,OAAO,gBAAgB,CAAC,SAAS,CAAC,kBAAkB,CAAC,oDAAoD,EAAE;gBACzG,KAAK,CAAC,OAAO;gBACb,KAAK,CAAC,aAAa,CAAC;gBACpB,OAAO;gBACP,YAAY;aACb,CAAC,CAAA;SACH;aAAM;YACL,OAAO,gBAAgB,CAAC,SAAS,CAAC,kBAAkB,CAAC,6BAA6B,EAAE;gBAClF,KAAK,CAAC,OAAO;gBACb,KAAK,CAAC,aAAa,CAAC;aACrB,CAAC,CAAA;SACH;IACH,CAAC;IAEM,MAAM,CAAC,UAAU,CAAC,KAAY,EAAE,MAAY;QACjD,OAAO,gBAAgB,CAAC,SAAS,CAAC,kBAAkB,CAAC,MAAM,EAAE,CAAC,KAAK,CAAC,OAAO,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,CAAA;IAC9F,CAAC;IAEM,MAAM,CAAC,aAAa,CAAC,MAAY;QACtC,OAAO,gBAAgB,CAAC,SAAS,CAAC,kBAAkB,CAAC,SAAS,EAAE,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,CAAA;IAClF,CAAC;;AA9Da,0BAAS,GAAc,IAAI,SAAS,CAAC,iCAAiC,CAAC,GAAG,CAAC,CAAA"}

package/dist/esm/src/swapRouter.d.ts

@@ -0,0 +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;
+}
+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/esm/src/swapRouter.js

@@ -0,0 +1,434 @@
+import { Interface } from '@ethersproject/abi';
+import { CurrencyAmount, Percent, TradeType, validateAndParseAddress, WETH9 } from '@uniswap/sdk-core';
+import ISwapRouter02 from '@uniswap/swap-router-contracts/artifacts/contracts/interfaces/ISwapRouter02.sol/ISwapRouter02.json';
+import { Trade as V2Trade } from '@uniswap/v2-sdk';
+import { encodeRouteToPath, Payments, Pool as V3Pool, Position, SelfPermit, toHex, Trade as V3Trade, } from '@uniswap/v3-sdk';
+import { Pool as V4Pool } from '@uniswap/v4-sdk';
+import invariant from 'tiny-invariant';
+import JSBI from 'jsbi';
+import { ADDRESS_THIS, MSG_SENDER } from './constants';
+import { ApproveAndCall, ApprovalTypes } from './approveAndCall';
+import { Trade } from './entities/trade';
+import { Protocol } from './entities/protocol';
+import { MixedRoute } from './entities/route';
+import { MulticallExtended } from './multicallExtended';
+import { PaymentsExtended } from './paymentsExtended';
+import { MixedRouteTrade } from './entities/mixedRoute/trade';
+import { encodeMixedRouteToPath } from './utils/encodeMixedRouteToPath';
+import { MixedRouteSDK } from './entities/mixedRoute/route';
+import { partitionMixedRouteByProtocol, getOutputOfPools } from './utils';
+const ZERO = JSBI.BigInt(0);
+const REFUND_ETH_PRICE_IMPACT_THRESHOLD = new Percent(JSBI.BigInt(50), JSBI.BigInt(100));
+/**
+ * Represents the Uniswap V2 + V3 SwapRouter02, and has static methods for helping execute trades.
+ */
+export 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 = toHex(trade.maximumAmountIn(options.slippageTolerance).quotient);
+        const amountOut = toHex(trade.minimumAmountOut(options.slippageTolerance).quotient);
+        const path = trade.route.path.map((token) => token.address);
+        const recipient = routerMustCustody
+            ? ADDRESS_THIS
+            : typeof options.recipient === 'undefined'
+                ? MSG_SENDER
+                : validateAndParseAddress(options.recipient);
+        if (trade.tradeType === 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 = toHex(trade.maximumAmountIn(options.slippageTolerance, inputAmount).quotient);
+            const amountOut = 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
+                ? ADDRESS_THIS
+                : typeof options.recipient === 'undefined'
+                    ? MSG_SENDER
+                    : validateAndParseAddress(options.recipient);
+            if (singleHop) {
+                if (trade.tradeType === 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 = encodeRouteToPath(route, trade.tradeType === TradeType.EXACT_OUTPUT);
+                if (trade.tradeType === 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 = [];
+        invariant(trade.tradeType === TradeType.EXACT_INPUT, 'TRADE_TYPE');
+        for (const { route, inputAmount, outputAmount } of trade.swaps) {
+            if (route.pools.some((pool) => pool instanceof V4Pool))
+                throw new Error('Encoding mixed routes with V4 not supported');
+            const amountIn = toHex(trade.maximumAmountIn(options.slippageTolerance, inputAmount).quotient);
+            const amountOut = 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
+                ? ADDRESS_THIS
+                : typeof options.recipient === 'undefined'
+                    ? MSG_SENDER
+                    : validateAndParseAddress(options.recipient);
+            const mixedRouteIsAllV3 = (route) => {
+                return route.pools.every((pool) => pool instanceof V3Pool);
+            };
+            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 = 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 = getOutputOfPools(section, inputToken);
+                    const newRouteOriginal = new MixedRouteSDK([...section], section[0].token0.equals(inputToken) ? section[0].token0 : section[0].token1, outputToken);
+                    const newRoute = new MixedRoute(newRouteOriginal);
+                    /// Previous output is now input
+                    inputToken = outputToken.wrapped;
+                    if (mixedRouteIsAllV3(newRoute)) {
+                        const path = 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 : 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 : 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) {
+            invariant(trades.swaps.every((swap) => swap.route.protocol === Protocol.V3 ||
+                swap.route.protocol === Protocol.V2 ||
+                swap.route.protocol === Protocol.MIXED), 'UNSUPPORTED_PROTOCOL (encoding routes with v4 not supported)');
+            let individualTrades = [];
+            for (const { route, inputAmount, outputAmount } of trades.swaps) {
+                if (route.protocol === Protocol.V2) {
+                    individualTrades.push(new V2Trade(route, trades.tradeType === TradeType.EXACT_INPUT ? inputAmount : outputAmount, trades.tradeType));
+                }
+                else if (route.protocol === Protocol.V3) {
+                    individualTrades.push(V3Trade.createUncheckedTrade({
+                        route: route,
+                        inputAmount,
+                        outputAmount,
+                        tradeType: trades.tradeType,
+                    }));
+                }
+                else if (route.protocol === Protocol.MIXED) {
+                    individualTrades.push(
+                    /// we can change the naming of this function on MixedRouteTrade if needed
+                    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 V3Trade || trade instanceof MixedRouteTrade ? trade.swaps.length : 1), 0);
+        const sampleTrade = trades[0];
+        // All trades should have the same starting/ending currency and trade type
+        invariant(trades.every((trade) => trade.inputAmount.currency.equals(sampleTrade.inputAmount.currency)), 'TOKEN_IN_DIFF');
+        invariant(trades.every((trade) => trade.outputAmount.currency.equals(sampleTrade.outputAmount.currency)), 'TOKEN_OUT_DIFF');
+        invariant(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 === 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) {
+            invariant(sampleTrade.inputAmount.currency.isToken, 'NON_TOKEN_PERMIT');
+            calldatas.push(SelfPermit.encodePermit(sampleTrade.inputAmount.currency, options.inputTokenPermit));
+        }
+        for (const trade of trades) {
+            if (trade instanceof V2Trade) {
+                calldatas.push(SwapRouter.encodeV2Swap(trade, options, routerMustCustody, performAggregatedSlippageCheck));
+            }
+            else if (trade instanceof V3Trade) {
+                for (const calldata of SwapRouter.encodeV3Swap(trade, options, routerMustCustody, performAggregatedSlippageCheck)) {
+                    calldatas.push(calldata);
+                }
+            }
+            else if (trade instanceof MixedRouteTrade) {
+                for (const calldata of SwapRouter.encodeMixedRouteSwap(trade, options, routerMustCustody, performAggregatedSlippageCheck)) {
+                    calldatas.push(calldata);
+                }
+            }
+            else {
+                throw new Error('Unsupported trade object');
+            }
+        }
+        const ZERO_IN = CurrencyAmount.fromRawAmount(sampleTrade.inputAmount.currency, 0);
+        const ZERO_OUT = 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.encodeUnwrapWETH9(minimumAmountOut.quotient, options.recipient, options.fee));
+            }
+            else {
+                calldatas.push(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 === TradeType.EXACT_OUTPUT || SwapRouter.riskOfPartialFill(trades))) {
+            calldatas.push(Payments.encodeRefundETH());
+        }
+        return {
+            calldata: MulticallExtended.encodeMulticall(calldatas, options.deadlineOrPreviousBlockhash),
+            value: 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) {
+            invariant(quoteAmountOut.currency.isToken, 'NON_TOKEN_PERMIT_OUTPUT');
+            calldatas.push(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 ? WETH9[chainId] : positionAmountIn.currency.wrapped;
+        const tokenOut = outputIsNative ? 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(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.encodeWrapETH(amountOutRemaining.quotient))
+                : calldatas.push(PaymentsExtended.encodePull(tokenOut, amountOutRemaining.quotient));
+        }
+        // if input is native, convert to WETH9, else pull ERC20 token
+        inputIsNative
+            ? calldatas.push(PaymentsExtended.encodeWrapETH(positionAmountIn.quotient))
+            : calldatas.push(PaymentsExtended.encodePull(tokenIn, positionAmountIn.quotient));
+        // approve token balances to NFTManager
+        if (tokenInApprovalType !== ApprovalTypes.NOT_REQUIRED)
+            calldatas.push(ApproveAndCall.encodeApprove(tokenIn, tokenInApprovalType));
+        if (tokenOutApprovalType !== ApprovalTypes.NOT_REQUIRED)
+            calldatas.push(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 = 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.encodeAddLiquidity(position, minimalPosition, addLiquidityOptions, options.slippageTolerance));
+        // sweep remaining tokens
+        inputIsNative
+            ? calldatas.push(PaymentsExtended.encodeUnwrapWETH9(ZERO))
+            : calldatas.push(PaymentsExtended.encodeSweepToken(tokenIn, ZERO));
+        outputIsNative
+            ? calldatas.push(PaymentsExtended.encodeUnwrapWETH9(ZERO))
+            : calldatas.push(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.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 V2Trade) && trade.priceImpact.greaterThan(REFUND_ETH_PRICE_IMPACT_THRESHOLD);
+    }
+    static getPositionAmounts(position, zeroForOne) {
+        const { amount0, amount1 } = position.mintAmounts;
+        const currencyAmount0 = CurrencyAmount.fromRawAmount(position.pool.token0, amount0);
+        const currencyAmount1 = CurrencyAmount.fromRawAmount(position.pool.token1, amount1);
+        const [positionAmountIn, positionAmountOut] = zeroForOne
+            ? [currencyAmount0, currencyAmount1]
+            : [currencyAmount1, currencyAmount0];
+        return { positionAmountIn, positionAmountOut };
+    }
+}
+SwapRouter.INTERFACE = new Interface(ISwapRouter02.abi);
+//# sourceMappingURL=swapRouter.js.map