@uniswap/router-sdk 1.23.0 → 2.0.0

package/dist/types/src/entities/mixedRoute/route.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/src/entities/mixedRoute/trade.d.ts

@@ -0,0 +1,183 @@
+import { Currency, Percent, Price, CurrencyAmount, TradeType } from '@uniswap/sdk-core';
+import { BestTradeOptions } from '@uniswap/v3-sdk';
+import { MixedRouteSDK } from './route';
+import { TPool } from '../../utils/TPool';
+/**
+ * Trades comparator, an extension of the input output comparator that also considers other dimensions of the trade in ranking them
+ * @template TInput The input token, either Ether or an ERC-20
+ * @template TOutput The output token, either Ether or an ERC-20
+ * @template TTradeType The trade type, either exact input or exact output
+ * @param a The first trade to compare
+ * @param b The second trade to compare
+ * @returns A sorted ordering for two neighboring elements in a trade array
+ */
+export declare function tradeComparator<TInput extends Currency, TOutput extends Currency, TTradeType extends TradeType>(a: MixedRouteTrade<TInput, TOutput, TTradeType>, b: MixedRouteTrade<TInput, TOutput, TTradeType>): number;
+/**
+ * Represents a trade executed against a set of routes where some percentage of the input is
+ * split across each route.
+ *
+ * Each route has its own set of pools. Pools can not be re-used across routes.
+ *
+ * Does not account for slippage, i.e., changes in price environment that can occur between
+ * the time the trade is submitted and when it is executed.
+ * @notice This class is functionally the same as the `Trade` class in the `@uniswap/v3-sdk` package, aside from typing and some input validation.
+ * @template TInput The input token, either Ether or an ERC-20
+ * @template TOutput The output token, either Ether or an ERC-20
+ * @template TTradeType The trade type, either exact input or exact output
+ */
+export declare class MixedRouteTrade<TInput extends Currency, TOutput extends Currency, TTradeType extends TradeType> {
+    /**
+     * @deprecated Deprecated in favor of 'swaps' property. If the trade consists of multiple routes
+     * this will return an error.
+     *
+     * When the trade consists of just a single route, this returns the route of the trade,
+     * i.e. which pools the trade goes through.
+     */
+    get route(): MixedRouteSDK<TInput, TOutput>;
+    /**
+     * The swaps of the trade, i.e. which routes and how much is swapped in each that
+     * make up the trade.
+     */
+    readonly swaps: {
+        route: MixedRouteSDK<TInput, TOutput>;
+        inputAmount: CurrencyAmount<TInput>;
+        outputAmount: CurrencyAmount<TOutput>;
+    }[];
+    /**
+     * The type of the trade, either exact in or exact out.
+     */
+    readonly tradeType: TTradeType;
+    /**
+     * The cached result of the input amount computation
+     * @private
+     */
+    private _inputAmount;
+    /**
+     * The input amount for the trade assuming no slippage.
+     */
+    get inputAmount(): CurrencyAmount<TInput>;
+    /**
+     * The cached result of the output amount computation
+     * @private
+     */
+    private _outputAmount;
+    /**
+     * The output amount for the trade assuming no slippage.
+     */
+    get outputAmount(): CurrencyAmount<TOutput>;
+    /**
+     * The cached result of the computed execution price
+     * @private
+     */
+    private _executionPrice;
+    /**
+     * The price expressed in terms of output amount/input amount.
+     */
+    get executionPrice(): Price<TInput, TOutput>;
+    /**
+     * The cached result of the price impact computation
+     * @private
+     */
+    private _priceImpact;
+    /**
+     * Returns the percent difference between the route's mid price and the price impact
+     */
+    get priceImpact(): Percent;
+    /**
+     * Constructs a trade by simulating swaps through the given route
+     * @template TInput The input token, either Ether or an ERC-20.
+     * @template TOutput The output token, either Ether or an ERC-20.
+     * @template TTradeType The type of the trade, either exact in or exact out.
+     * @param route route to swap through
+     * @param amount the amount specified, either input or output, depending on tradeType
+     * @param tradeType whether the trade is an exact input or exact output swap
+     * @returns The route
+     */
+    static fromRoute<TInput extends Currency, TOutput extends Currency, TTradeType extends TradeType>(route: MixedRouteSDK<TInput, TOutput>, amount: TTradeType extends TradeType.EXACT_INPUT ? CurrencyAmount<TInput> : CurrencyAmount<TOutput>, tradeType: TTradeType): Promise<MixedRouteTrade<TInput, TOutput, TTradeType>>;
+    /**
+     * Constructs a trade from routes by simulating swaps
+     *
+     * @template TInput The input token, either Ether or an ERC-20.
+     * @template TOutput The output token, either Ether or an ERC-20.
+     * @template TTradeType The type of the trade, either exact in or exact out.
+     * @param routes the routes to swap through and how much of the amount should be routed through each
+     * @param tradeType whether the trade is an exact input or exact output swap
+     * @returns The trade
+     */
+    static fromRoutes<TInput extends Currency, TOutput extends Currency, TTradeType extends TradeType>(routes: {
+        amount: TTradeType extends TradeType.EXACT_INPUT ? CurrencyAmount<TInput> : CurrencyAmount<TOutput>;
+        route: MixedRouteSDK<TInput, TOutput>;
+    }[], tradeType: TTradeType): Promise<MixedRouteTrade<TInput, TOutput, TTradeType>>;
+    /**
+     * Creates a trade without computing the result of swapping through the route. Useful when you have simulated the trade
+     * elsewhere and do not have any tick data
+     * @template TInput The input token, either Ether or an ERC-20
+     * @template TOutput The output token, either Ether or an ERC-20
+     * @template TTradeType The type of the trade, either exact in or exact out
+     * @param constructorArguments The arguments passed to the trade constructor
+     * @returns The unchecked trade
+     */
+    static createUncheckedTrade<TInput extends Currency, TOutput extends Currency, TTradeType extends TradeType>(constructorArguments: {
+        route: MixedRouteSDK<TInput, TOutput>;
+        inputAmount: CurrencyAmount<TInput>;
+        outputAmount: CurrencyAmount<TOutput>;
+        tradeType: TTradeType;
+    }): MixedRouteTrade<TInput, TOutput, TTradeType>;
+    /**
+     * Creates a trade without computing the result of swapping through the routes. Useful when you have simulated the trade
+     * elsewhere and do not have any tick data
+     * @template TInput The input token, either Ether or an ERC-20
+     * @template TOutput The output token, either Ether or an ERC-20
+     * @template TTradeType The type of the trade, either exact in or exact out
+     * @param constructorArguments The arguments passed to the trade constructor
+     * @returns The unchecked trade
+     */
+    static createUncheckedTradeWithMultipleRoutes<TInput extends Currency, TOutput extends Currency, TTradeType extends TradeType>(constructorArguments: {
+        routes: {
+            route: MixedRouteSDK<TInput, TOutput>;
+            inputAmount: CurrencyAmount<TInput>;
+            outputAmount: CurrencyAmount<TOutput>;
+        }[];
+        tradeType: TTradeType;
+    }): MixedRouteTrade<TInput, TOutput, TTradeType>;
+    /**
+     * Construct a trade by passing in the pre-computed property values
+     * @param routes The routes through which the trade occurs
+     * @param tradeType The type of trade, exact input or exact output
+     */
+    private constructor();
+    /**
+     * Get the minimum amount that must be received from this trade for the given slippage tolerance
+     * @param slippageTolerance The tolerance of unfavorable slippage from the execution price of this trade
+     * @returns The amount out
+     */
+    minimumAmountOut(slippageTolerance: Percent, amountOut?: CurrencyAmount<TOutput>): CurrencyAmount<TOutput>;
+    /**
+     * Get the maximum amount in that can be spent via this trade for the given slippage tolerance
+     * @param slippageTolerance The tolerance of unfavorable slippage from the execution price of this trade
+     * @returns The amount in
+     */
+    maximumAmountIn(slippageTolerance: Percent, amountIn?: CurrencyAmount<TInput>): CurrencyAmount<TInput>;
+    /**
+     * Return the execution price after accounting for slippage tolerance
+     * @param slippageTolerance the allowed tolerated slippage
+     * @returns The execution price
+     */
+    worstExecutionPrice(slippageTolerance: Percent): Price<TInput, TOutput>;
+    /**
+     * Given a list of pools, and a fixed amount in, returns the top `maxNumResults` trades that go from an input token
+     * amount to an output token, making at most `maxHops` hops.
+     * Note this does not consider aggregation, as routes are linear. It's possible a better route exists by splitting
+     * the amount in among multiple routes.
+     * @param pools the pools to consider in finding the best trade
+     * @param nextAmountIn exact amount of input currency to spend
+     * @param currencyOut the desired currency out
+     * @param maxNumResults maximum number of results to return
+     * @param maxHops maximum number of hops a returned trade can make, e.g. 1 hop goes through a single pool
+     * @param currentPools used in recursion; the current list of pools
+     * @param currencyAmountIn used in recursion; the original value of the currencyAmountIn parameter
+     * @param bestTrades used in recursion; the current list of best trades
+     * @returns The exact in trade
+     */
+    static bestTradeExactIn<TInput extends Currency, TOutput extends Currency>(pools: TPool[], currencyAmountIn: CurrencyAmount<TInput>, currencyOut: TOutput, { maxNumResults, maxHops }?: BestTradeOptions, currentPools?: TPool[], nextAmountIn?: CurrencyAmount<Currency>, bestTrades?: MixedRouteTrade<TInput, TOutput, TradeType.EXACT_INPUT>[]): Promise<MixedRouteTrade<TInput, TOutput, TradeType.EXACT_INPUT>[]>;
+}

package/dist/types/src/entities/mixedRoute/trade.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/src/entities/protocol.d.ts

@@ -0,0 +1,6 @@
+export declare enum Protocol {
+    V2 = "V2",
+    V3 = "V3",
+    V4 = "V4",
+    MIXED = "MIXED"
+}

package/dist/types/src/entities/route.d.ts

@@ -0,0 +1,40 @@
+import { Route as V2RouteSDK, Pair } from '@uniswap/v2-sdk';
+import { Route as V3RouteSDK, Pool as V3Pool } from '@uniswap/v3-sdk';
+import { Route as V4RouteSDK, Pool as V4Pool } from '@uniswap/v4-sdk';
+import { Protocol } from './protocol';
+import { Currency, Price, Token } from '@uniswap/sdk-core';
+import { MixedRouteSDK } from './mixedRoute/route';
+export declare function getPathToken(currency: Currency, pool: Pair | V3Pool): Token;
+export interface IRoute<TInput extends Currency, TOutput extends Currency, TPool extends Pair | V3Pool | V4Pool> {
+    protocol: Protocol;
+    pools: TPool[];
+    path: Currency[];
+    midPrice: Price<TInput, TOutput>;
+    input: TInput;
+    output: TOutput;
+    pathInput: Currency;
+    pathOutput: Currency;
+}
+export declare class RouteV2<TInput extends Currency, TOutput extends Currency> extends V2RouteSDK<TInput, TOutput> implements IRoute<TInput, TOutput, Pair> {
+    readonly protocol: Protocol;
+    readonly pools: Pair[];
+    pathInput: Currency;
+    pathOutput: Currency;
+    constructor(v2Route: V2RouteSDK<TInput, TOutput>);
+}
+export declare class RouteV3<TInput extends Currency, TOutput extends Currency> extends V3RouteSDK<TInput, TOutput> implements IRoute<TInput, TOutput, V3Pool> {
+    readonly protocol: Protocol;
+    readonly path: Token[];
+    pathInput: Currency;
+    pathOutput: Currency;
+    constructor(v3Route: V3RouteSDK<TInput, TOutput>);
+}
+export declare class RouteV4<TInput extends Currency, TOutput extends Currency> extends V4RouteSDK<TInput, TOutput> implements IRoute<TInput, TOutput, V4Pool> {
+    readonly protocol: Protocol;
+    readonly path: Currency[];
+    constructor(v4Route: V4RouteSDK<TInput, TOutput>);
+}
+export declare class MixedRoute<TInput extends Currency, TOutput extends Currency> extends MixedRouteSDK<TInput, TOutput> implements IRoute<TInput, TOutput, Pair | V3Pool | V4Pool> {
+    readonly protocol: Protocol;
+    constructor(mixedRoute: MixedRouteSDK<TInput, TOutput>);
+}

package/dist/types/src/entities/route.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/src/entities/trade.d.ts

@@ -0,0 +1,127 @@
+import { Currency, CurrencyAmount, Percent, Price, TradeType } from '@uniswap/sdk-core';
+import { Pair, Route as V2RouteSDK } from '@uniswap/v2-sdk';
+import { Pool as V3Pool, Route as V3RouteSDK } from '@uniswap/v3-sdk';
+import { Pool as V4Pool, Route as V4RouteSDK } from '@uniswap/v4-sdk';
+import { MixedRouteSDK } from './mixedRoute/route';
+import { IRoute } from './route';
+export declare class Trade<TInput extends Currency, TOutput extends Currency, TTradeType extends TradeType> {
+    readonly routes: IRoute<TInput, TOutput, Pair | V3Pool | V4Pool>[];
+    readonly tradeType: TTradeType;
+    private _outputAmount;
+    private _inputAmount;
+    private _nativeInputRoutes;
+    private _wethInputRoutes;
+    /**
+     * The swaps of the trade, i.e. which routes and how much is swapped in each that
+     * make up the trade. May consist of swaps in v2 or v3.
+     */
+    readonly swaps: {
+        route: IRoute<TInput, TOutput, Pair | V3Pool | V4Pool>;
+        inputAmount: CurrencyAmount<TInput>;
+        outputAmount: CurrencyAmount<TOutput>;
+    }[];
+    constructor({ v2Routes, v3Routes, v4Routes, mixedRoutes, tradeType, }: {
+        v2Routes?: {
+            routev2: V2RouteSDK<TInput, TOutput>;
+            inputAmount: CurrencyAmount<TInput>;
+            outputAmount: CurrencyAmount<TOutput>;
+        }[];
+        v3Routes?: {
+            routev3: V3RouteSDK<TInput, TOutput>;
+            inputAmount: CurrencyAmount<TInput>;
+            outputAmount: CurrencyAmount<TOutput>;
+        }[];
+        v4Routes?: {
+            routev4: V4RouteSDK<TInput, TOutput>;
+            inputAmount: CurrencyAmount<TInput>;
+            outputAmount: CurrencyAmount<TOutput>;
+        }[];
+        mixedRoutes?: {
+            mixedRoute: MixedRouteSDK<TInput, TOutput>;
+            inputAmount: CurrencyAmount<TInput>;
+            outputAmount: CurrencyAmount<TOutput>;
+        }[];
+        tradeType: TTradeType;
+    });
+    get inputAmount(): CurrencyAmount<TInput>;
+    get outputAmount(): CurrencyAmount<TOutput>;
+    /**
+     * Returns the sum of all swaps within the trade
+     * @returns
+     * inputAmount: total input amount
+     * inputAmountNative: total amount of native currency required for ETH input paths
+     *  - 0 if inputAmount is native but no native input paths
+     *  - undefined if inputAmount is not native
+     * outputAmount: total output amount
+     * outputAmountNative: total amount of native currency returned from ETH output paths
+     *  - 0 if outputAmount is native but no native output paths
+     *  - undefined if outputAmount is not native
+     */
+    get amounts(): {
+        inputAmount: CurrencyAmount<TInput>;
+        inputAmountNative: CurrencyAmount<TInput> | undefined;
+        outputAmount: CurrencyAmount<TOutput>;
+        outputAmountNative: CurrencyAmount<TOutput> | undefined;
+    };
+    get numberOfInputWraps(): number;
+    get numberOfInputUnwraps(): number;
+    get nativeInputRoutes(): IRoute<TInput, TOutput, Pair | V3Pool | V4Pool>[];
+    get wethInputRoutes(): IRoute<TInput, TOutput, Pair | V3Pool | V4Pool>[];
+    private _executionPrice;
+    /**
+     * The price expressed in terms of output amount/input amount.
+     */
+    get executionPrice(): Price<TInput, TOutput>;
+    /**
+     * Returns the sell tax of the input token
+     */
+    get inputTax(): Percent;
+    /**
+     * Returns the buy tax of the output token
+     */
+    get outputTax(): Percent;
+    private isWrappedNative;
+    /**
+     * The cached result of the price impact computation
+     * @private
+     */
+    private _priceImpact;
+    /**
+     * Returns the percent difference between the route's mid price and the expected execution price
+     * In order to exclude token taxes from the price impact calculation, the spot price is calculated
+     * using a ratio of values that go into the pools, which are the post-tax input amount and pre-tax output amount.
+     */
+    get priceImpact(): Percent;
+    /**
+     * Get the minimum amount that must be received from this trade for the given slippage tolerance
+     * @param slippageTolerance The tolerance of unfavorable slippage from the execution price of this trade
+     * @returns The amount out
+     */
+    minimumAmountOut(slippageTolerance: Percent, amountOut?: CurrencyAmount<TOutput>): CurrencyAmount<TOutput>;
+    /**
+     * Get the maximum amount in that can be spent via this trade for the given slippage tolerance
+     * @param slippageTolerance The tolerance of unfavorable slippage from the execution price of this trade
+     * @returns The amount in
+     */
+    maximumAmountIn(slippageTolerance: Percent, amountIn?: CurrencyAmount<TInput>): CurrencyAmount<TInput>;
+    /**
+     * Return the execution price after accounting for slippage tolerance
+     * @param slippageTolerance the allowed tolerated slippage
+     * @returns The execution price
+     */
+    worstExecutionPrice(slippageTolerance: Percent): Price<TInput, TOutput>;
+    static fromRoutes<TInput extends Currency, TOutput extends Currency, TTradeType extends TradeType>(v2Routes: {
+        routev2: V2RouteSDK<TInput, TOutput>;
+        amount: TTradeType extends TradeType.EXACT_INPUT ? CurrencyAmount<TInput> : CurrencyAmount<TOutput>;
+    }[], v3Routes: {
+        routev3: V3RouteSDK<TInput, TOutput>;
+        amount: TTradeType extends TradeType.EXACT_INPUT ? CurrencyAmount<TInput> : CurrencyAmount<TOutput>;
+    }[], tradeType: TTradeType, mixedRoutes?: {
+        mixedRoute: MixedRouteSDK<TInput, TOutput>;
+        amount: TTradeType extends TradeType.EXACT_INPUT ? CurrencyAmount<TInput> : CurrencyAmount<TOutput>;
+    }[], v4Routes?: {
+        routev4: V4RouteSDK<TInput, TOutput>;
+        amount: TTradeType extends TradeType.EXACT_INPUT ? CurrencyAmount<TInput> : CurrencyAmount<TOutput>;
+    }[]): Promise<Trade<TInput, TOutput, TTradeType>>;
+    static fromRoute<TInput extends Currency, TOutput extends Currency, TTradeType extends TradeType>(route: V2RouteSDK<TInput, TOutput> | V3RouteSDK<TInput, TOutput> | V4RouteSDK<TInput, TOutput> | MixedRouteSDK<TInput, TOutput>, amount: TTradeType extends TradeType.EXACT_INPUT ? CurrencyAmount<TInput> : CurrencyAmount<TOutput>, tradeType: TTradeType): Promise<Trade<TInput, TOutput, TTradeType>>;
+}

package/dist/types/src/entities/trade.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/src/index.d.ts

@@ -0,0 +1,14 @@
+export * from './constants';
+export * from './approveAndCall';
+export * from './multicallExtended';
+export * from './paymentsExtended';
+export * from './swapRouter';
+export * from './entities/trade';
+export * from './entities/protocol';
+export * from './entities/route';
+export * from './entities/mixedRoute/route';
+export * from './entities/mixedRoute/trade';
+export * from './utils/encodeMixedRouteToPath';
+export * from './utils/TPool';
+export * from './utils/pathCurrency';
+export * from './utils';

package/dist/types/src/multicallExtended.d.ts

@@ -0,0 +1,11 @@
+import { Interface } from '@ethersproject/abi';
+import { BigintIsh } from '@uniswap/sdk-core';
+export type Validation = BigintIsh | string;
+export declare abstract class MulticallExtended {
+    static INTERFACE: Interface;
+    /**
+     * Cannot be constructed.
+     */
+    private constructor();
+    static encodeMulticall(calldatas: string | string[], validation?: Validation): string;
+}

package/dist/types/src/multicallExtended.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/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/types/src/paymentsExtended.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/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/types/src/swapRouter.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/src/utils/TPool.d.ts

@@ -0,0 +1,4 @@
+import { Pool as V4Pool } from '@uniswap/v4-sdk';
+import { Pair } from '@uniswap/v2-sdk';
+import { Pool as V3Pool } from '@uniswap/v3-sdk';
+export type TPool = Pair | V3Pool | V4Pool;

package/dist/types/src/utils/encodeMixedRouteToPath.d.ts

@@ -0,0 +1,9 @@
+import { Currency } from '@uniswap/sdk-core';
+import { MixedRouteSDK } from '../entities/mixedRoute/route';
+/**
+ * Converts a route to a hex encoded path
+ * @notice only supports exactIn route encodings
+ * @param route the mixed path to convert to an encoded path
+ * @returns the exactIn encoded path
+ */
+export declare function encodeMixedRouteToPath(route: MixedRouteSDK<Currency, Currency>): string;

package/dist/types/src/utils/encodeMixedRouteToPath.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/src/utils/index.d.ts

@@ -0,0 +1,16 @@
+import { Currency } from '@uniswap/sdk-core';
+import { MixedRouteSDK } from '../entities/mixedRoute/route';
+import { TPool } from './TPool';
+/**
+ * Utility function to return each consecutive section of Pools or Pairs in a MixedRoute
+ * @param route
+ * @returns a nested array of Pools or Pairs in the order of the route
+ */
+export declare const partitionMixedRouteByProtocol: (route: MixedRouteSDK<Currency, Currency>) => TPool[][];
+/**
+ * Simple utility function to get the output of an array of Pools or Pairs
+ * @param pools
+ * @param firstInputToken
+ * @returns the output token of the last pool in the array
+ */
+export declare const getOutputOfPools: (pools: TPool[], firstInputToken: Currency) => Currency;

package/dist/types/src/utils/pathCurrency.d.ts

@@ -0,0 +1,4 @@
+import { Currency, CurrencyAmount } from '@uniswap/sdk-core';
+import { TPool } from './TPool';
+export declare function amountWithPathCurrency(amount: CurrencyAmount<Currency>, pool: TPool): CurrencyAmount<Currency>;
+export declare function getPathCurrency(currency: Currency, pool: TPool): Currency;

package/dist/types/src/utils/pathCurrency.test.d.ts

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -7,17 +7,22 @@
     "ethereum"
   ],
   "license": "MIT",
-  "main": "dist/index.js",
-  "typings": "dist/index.d.ts",
+  "main": "./dist/cjs/src/index.js",
+  "module": "./dist/esm/src/index.js",
+  "types": "./dist/types/src/index.d.ts",
   "files": [
     "dist"
   ],
   "scripts": {
-    "build": "tsdx build",
-    "lint": "tsdx lint src",
-    "release": "semantic-release",
-    "start": "tsdx watch",
-    "test": "tsdx test"
+    "clean": "rm -rf dist",
+    "build": "yarn clean && yarn build:cjs && yarn build:esm && yarn build:types",
+    "build:cjs": "tsc -p tsconfig.cjs.json",
+    "build:esm": "tsc -p tsconfig.esm.json",
+    "build:types": "tsc -p tsconfig.types.json",
+    "lint": "eslint src --ext .ts",
+    "lint:fix": "eslint src --ext .ts --fix",
+    "test": "jest",
+    "release": "semantic-release"
   },
   "dependencies": {
     "@ethersproject/abi": "^5.5.0",
@@ -29,18 +34,28 @@
   },
   "devDependencies": {
     "@types/jest": "^24.0.25",
+    "@typescript-eslint/eslint-plugin": "^5.62",
+    "@typescript-eslint/parser": "^5.62",
+    "eslint": "^7.8.0",
+    "eslint-config-prettier": "^6.11.0",
+    "eslint-plugin-eslint-comments": "^3.2.0",
+    "eslint-plugin-functional": "^3.0.2",
+    "eslint-plugin-import": "^2.22.0",
+    "jest": "25.5.0",
     "prettier": "^2.4.1",
-    "tsdx": "^0.14.1"
-  },
-  "prettier": {
-    "printWidth": 120,
-    "semi": false,
-    "singleQuote": true
+    "typescript": "^4.3.3"
   },
   "publishConfig": {
     "access": "public",
     "provenance": true
   },
+  "exports": {
+    ".": {
+      "types": "./dist/types/src/index.d.ts",
+      "import": "./dist/esm/src/index.js",
+      "require": "./dist/cjs/src/index.js"
+    }
+  },
   "release": {
     "extends": "semantic-release-monorepo",
     "branches": [
@@ -70,5 +85,5 @@
       ]
     ]
   },
-  "version": "1.23.0"
+  "version": "2.0.0"
 }

package/dist/index.js

@@ -1,8 +0,0 @@
-
-'use strict'
-
-if (process.env.NODE_ENV === 'production') {
-  module.exports = require('./router-sdk.cjs.production.min.js')
-} else {
-  module.exports = require('./router-sdk.cjs.development.js')
-}