@uniswap/router-sdk 2.0.0 → 2.0.2

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

@@ -1,33 +1,33 @@
-import { Interface } from '@ethersproject/abi';
-import { Currency, Percent, Token } from '@uniswap/sdk-core';
-import { MintSpecificOptions, IncreaseSpecificOptions, Position } from '@uniswap/v3-sdk';
-export type CondensedAddLiquidityOptions = Omit<MintSpecificOptions, 'createPool'> | IncreaseSpecificOptions;
-export declare enum ApprovalTypes {
-    NOT_REQUIRED = 0,
-    MAX = 1,
-    MAX_MINUS_ONE = 2,
-    ZERO_THEN_MAX = 3,
-    ZERO_THEN_MAX_MINUS_ONE = 4
-}
-export declare function isMint(options: CondensedAddLiquidityOptions): options is Omit<MintSpecificOptions, 'createPool'>;
-export declare abstract class ApproveAndCall {
-    static INTERFACE: Interface;
-    /**
-     * Cannot be constructed.
-     */
-    private constructor();
-    static encodeApproveMax(token: Token): string;
-    static encodeApproveMaxMinusOne(token: Token): string;
-    static encodeApproveZeroThenMax(token: Token): string;
-    static encodeApproveZeroThenMaxMinusOne(token: Token): string;
-    static encodeCallPositionManager(calldatas: string[]): string;
-    /**
-     * Encode adding liquidity to a position in the nft manager contract
-     * @param position Forcasted position with expected amount out from swap
-     * @param minimalPosition Forcasted position with custom minimal token amounts
-     * @param addLiquidityOptions Options for adding liquidity
-     * @param slippageTolerance Defines maximum slippage
-     */
-    static encodeAddLiquidity(position: Position, minimalPosition: Position, addLiquidityOptions: CondensedAddLiquidityOptions, slippageTolerance: Percent): string;
-    static encodeApprove(token: Currency, approvalType: ApprovalTypes): string;
-}
+import { Interface } from '@ethersproject/abi';
+import { Currency, Percent, Token } from '@uniswap/sdk-core';
+import { MintSpecificOptions, IncreaseSpecificOptions, Position } from '@uniswap/v3-sdk';
+export declare type CondensedAddLiquidityOptions = Omit<MintSpecificOptions, 'createPool'> | IncreaseSpecificOptions;
+export declare enum ApprovalTypes {
+    NOT_REQUIRED = 0,
+    MAX = 1,
+    MAX_MINUS_ONE = 2,
+    ZERO_THEN_MAX = 3,
+    ZERO_THEN_MAX_MINUS_ONE = 4
+}
+export declare function isMint(options: CondensedAddLiquidityOptions): options is Omit<MintSpecificOptions, 'createPool'>;
+export declare abstract class ApproveAndCall {
+    static INTERFACE: Interface;
+    /**
+     * Cannot be constructed.
+     */
+    private constructor();
+    static encodeApproveMax(token: Token): string;
+    static encodeApproveMaxMinusOne(token: Token): string;
+    static encodeApproveZeroThenMax(token: Token): string;
+    static encodeApproveZeroThenMaxMinusOne(token: Token): string;
+    static encodeCallPositionManager(calldatas: string[]): string;
+    /**
+     * Encode adding liquidity to a position in the nft manager contract
+     * @param position Forcasted position with expected amount out from swap
+     * @param minimalPosition Forcasted position with custom minimal token amounts
+     * @param addLiquidityOptions Options for adding liquidity
+     * @param slippageTolerance Defines maximum slippage
+     */
+    static encodeAddLiquidity(position: Position, minimalPosition: Position, addLiquidityOptions: CondensedAddLiquidityOptions, slippageTolerance: Percent): string;
+    static encodeApprove(token: Currency, approvalType: ApprovalTypes): string;
+}

package/dist/{types/src/constants.d.ts → constants.d.ts}

@@ -1,13 +1,13 @@
-import { Percent } from '@uniswap/sdk-core';
-import JSBI from 'jsbi';
-export declare const ADDRESS_ZERO = "0x0000000000000000000000000000000000000000";
-export declare const MSG_SENDER = "0x0000000000000000000000000000000000000001";
-export declare const ADDRESS_THIS = "0x0000000000000000000000000000000000000002";
-export declare const ZERO: JSBI;
-export declare const ONE: JSBI;
-export declare const MIXED_QUOTER_V1_V2_FEE_PATH_PLACEHOLDER: number;
-export declare const MIXED_QUOTER_V2_V2_FEE_PATH_PLACEHOLDER: number;
-export declare const MIXED_QUOTER_V2_V3_FEE_PATH_PLACEHOLDER: number;
-export declare const MIXED_QUOTER_V2_V4_FEE_PATH_PLACEHOLDER: number;
-export declare const ZERO_PERCENT: Percent;
-export declare const ONE_HUNDRED_PERCENT: Percent;
+import { Percent } from '@uniswap/sdk-core';
+import JSBI from 'jsbi';
+export declare const ADDRESS_ZERO = "0x0000000000000000000000000000000000000000";
+export declare const MSG_SENDER = "0x0000000000000000000000000000000000000001";
+export declare const ADDRESS_THIS = "0x0000000000000000000000000000000000000002";
+export declare const ZERO: JSBI;
+export declare const ONE: JSBI;
+export declare const MIXED_QUOTER_V1_V2_FEE_PATH_PLACEHOLDER: number;
+export declare const MIXED_QUOTER_V2_V2_FEE_PATH_PLACEHOLDER: number;
+export declare const MIXED_QUOTER_V2_V3_FEE_PATH_PLACEHOLDER: number;
+export declare const MIXED_QUOTER_V2_V4_FEE_PATH_PLACEHOLDER: number;
+export declare const ZERO_PERCENT: Percent;
+export declare const ONE_HUNDRED_PERCENT: Percent;

package/dist/{types/src/entities → entities}/mixedRoute/route.d.ts

@@ -1,29 +1,29 @@
-import { Currency, Price } from '@uniswap/sdk-core';
-import { TPool } from '../../utils/TPool';
-/**
- * Represents a list of pools or pairs through which a swap can occur
- * @template TInput The input token
- * @template TOutput The output token
- */
-export declare class MixedRouteSDK<TInput extends Currency, TOutput extends Currency> {
-    readonly pools: TPool[];
-    readonly path: Currency[];
-    readonly input: TInput;
-    readonly output: TOutput;
-    readonly pathInput: Currency;
-    readonly pathOutput: Currency;
-    private _midPrice;
-    /**
-     * Creates an instance of route.
-     * @param pools An array of `TPool` objects (pools or pairs), ordered by the route the swap will take
-     * @param input The input token
-     * @param output The output token
-     * @param retainsFakePool Set to true to filter out a pool that has a fake eth-weth pool
-     */
-    constructor(pools: TPool[], input: TInput, output: TOutput, retainFakePools?: boolean);
-    get chainId(): number;
-    /**
-     * Returns the mid price of the route
-     */
-    get midPrice(): Price<TInput, TOutput>;
-}
+import { Currency, Price } from '@uniswap/sdk-core';
+import { TPool } from '../../utils/TPool';
+/**
+ * Represents a list of pools or pairs through which a swap can occur
+ * @template TInput The input token
+ * @template TOutput The output token
+ */
+export declare class MixedRouteSDK<TInput extends Currency, TOutput extends Currency> {
+    readonly pools: TPool[];
+    readonly path: Currency[];
+    readonly input: TInput;
+    readonly output: TOutput;
+    readonly pathInput: Currency;
+    readonly pathOutput: Currency;
+    private _midPrice;
+    /**
+     * Creates an instance of route.
+     * @param pools An array of `TPool` objects (pools or pairs), ordered by the route the swap will take
+     * @param input The input token
+     * @param output The output token
+     * @param retainsFakePool Set to true to filter out a pool that has a fake eth-weth pool
+     */
+    constructor(pools: TPool[], input: TInput, output: TOutput, retainFakePools?: boolean);
+    get chainId(): number;
+    /**
+     * Returns the mid price of the route
+     */
+    get midPrice(): Price<TInput, TOutput>;
+}

package/dist/{esm/src/entities → entities}/mixedRoute/trade.d.ts

@@ -1,183 +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>[]>;
-}
+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/{cjs/src/entities → entities}/protocol.d.ts

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

package/dist/{esm/src/entities → entities}/route.d.ts

@@ -1,40 +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>);
-}
+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>);
+}