@juiceswapxyz/v4-sdk 3.0.0 → 3.0.1

package/dist/PositionManager.d.ts

@@ -0,0 +1,169 @@
+import { BigintIsh, Percent, NativeCurrency } from '@juiceswapxyz/sdk-core';
+import { TypedDataDomain, TypedDataField } from '@ethersproject/abstract-signer';
+import { Position } from './entities/position';
+import { MethodParameters } from './utils/calldata';
+import { Interface } from '@ethersproject/abi';
+import { PoolKey } from './entities';
+export interface CommonOptions {
+    /**
+     * How much the pool price is allowed to move from the specified action.
+     */
+    slippageTolerance: Percent;
+    /**
+     * Optional data to pass to hooks
+     */
+    hookData?: string;
+    /**
+     * When the transaction expires, in epoch seconds.
+     */
+    deadline: BigintIsh;
+}
+export interface ModifyPositionSpecificOptions {
+    /**
+     * Indicates the ID of the position to increase liquidity for.
+     */
+    tokenId: BigintIsh;
+}
+export interface MintSpecificOptions {
+    /**
+     * The account that should receive the minted NFT.
+     */
+    recipient: string;
+    /**
+     * Creates pool if not initialized before mint.
+     */
+    createPool?: boolean;
+    /**
+     * Initial price to set on the pool if creating
+     */
+    sqrtPriceX96?: BigintIsh;
+    /**
+     * Whether the mint is part of a migration from V3 to V4.
+     */
+    migrate?: boolean;
+}
+/**
+ * Options for producing the calldata to add liquidity.
+ */
+export interface CommonAddLiquidityOptions {
+    /**
+     * Whether to spend ether. If true, one of the currencies must be the NATIVE currency.
+     */
+    useNative?: NativeCurrency;
+    /**
+     * The optional permit2 batch permit parameters for spending token0 and token1
+     */
+    batchPermit?: BatchPermitOptions;
+}
+/**
+ * Options for producing the calldata to exit a position.
+ */
+export interface RemoveLiquiditySpecificOptions {
+    /**
+     * The percentage of position liquidity to exit.
+     */
+    liquidityPercentage: Percent;
+    /**
+     * Whether the NFT should be burned if the entire position is being exited, by default false.
+     */
+    burnToken?: boolean;
+    /**
+     * The optional permit of the token ID being exited, in case the exit transaction is being sent by an account that does not own the NFT
+     */
+    permit?: NFTPermitOptions;
+}
+export interface CollectSpecificOptions {
+    /**
+     * Indicates the ID of the position to collect for.
+     */
+    tokenId: BigintIsh;
+    /**
+     * The account that should receive the tokens.
+     */
+    recipient: string;
+}
+export interface TransferOptions {
+    /**
+     * The account sending the NFT.
+     */
+    sender: string;
+    /**
+     * The account that should receive the NFT.
+     */
+    recipient: string;
+    /**
+     * The id of the token being sent.
+     */
+    tokenId: BigintIsh;
+}
+export interface PermitDetails {
+    token: string;
+    amount: BigintIsh;
+    expiration: BigintIsh;
+    nonce: BigintIsh;
+}
+export interface AllowanceTransferPermitSingle {
+    details: PermitDetails;
+    spender: string;
+    sigDeadline: BigintIsh;
+}
+export interface AllowanceTransferPermitBatch {
+    details: PermitDetails[];
+    spender: string;
+    sigDeadline: BigintIsh;
+}
+export interface BatchPermitOptions {
+    owner: string;
+    permitBatch: AllowanceTransferPermitBatch;
+    signature: string;
+}
+export interface NFTPermitValues {
+    spender: string;
+    tokenId: BigintIsh;
+    deadline: BigintIsh;
+    nonce: BigintIsh;
+}
+export interface NFTPermitOptions extends NFTPermitValues {
+    signature: string;
+}
+export interface NFTPermitData {
+    domain: TypedDataDomain;
+    types: Record<string, TypedDataField[]>;
+    values: NFTPermitValues;
+}
+export declare type MintOptions = CommonOptions & CommonAddLiquidityOptions & MintSpecificOptions;
+export declare type IncreaseLiquidityOptions = CommonOptions & CommonAddLiquidityOptions & ModifyPositionSpecificOptions;
+export declare type AddLiquidityOptions = MintOptions | IncreaseLiquidityOptions;
+export declare type RemoveLiquidityOptions = CommonOptions & RemoveLiquiditySpecificOptions & ModifyPositionSpecificOptions;
+export declare type CollectOptions = CommonOptions & CollectSpecificOptions;
+export declare abstract class V4PositionManager {
+    static INTERFACE: Interface;
+    /**
+     * Cannot be constructed.
+     */
+    private constructor();
+    /**
+     * Public methods to encode method parameters for different actions on the PositionManager contract
+     */
+    static createCallParameters(poolKey: PoolKey, sqrtPriceX96: BigintIsh): MethodParameters;
+    static addCallParameters(position: Position, options: AddLiquidityOptions): MethodParameters;
+    /**
+     * Produces the calldata for completely or partially exiting a position
+     * @param position The position to exit
+     * @param options Additional information necessary for generating the calldata
+     * @returns The call parameters
+     */
+    static removeCallParameters(position: Position, options: RemoveLiquidityOptions): MethodParameters;
+    /**
+     * Produces the calldata for collecting fees from a position
+     * @param position The position to collect fees from
+     * @param options Additional information necessary for generating the calldata
+     * @returns The call parameters
+     */
+    static collectCallParameters(position: Position, options: CollectOptions): MethodParameters;
+    private static encodeInitializePool;
+    static encodeModifyLiquidities(unlockData: string, deadline: BigintIsh): string;
+    static encodePermitBatch(owner: string, permitBatch: AllowanceTransferPermitBatch, signature: string): string;
+    static encodeERC721Permit(spender: string, tokenId: BigintIsh, deadline: BigintIsh, nonce: BigintIsh, signature: string): string;
+    static getPermitData(permit: NFTPermitValues, positionManagerAddress: string, chainId: number): NFTPermitData;
+}

package/dist/actionConstants.d.ts

@@ -0,0 +1 @@
+export declare const MSG_SENDER = "0x0000000000000000000000000000000000000001";

package/dist/entities/index.d.ts

@@ -0,0 +1,4 @@
+export * from './pool';
+export * from './route';
+export * from './trade';
+export * from './position';

package/dist/entities/pool.d.ts

@@ -0,0 +1,103 @@
+import { BigintIsh, Currency, CurrencyAmount, Price } from '@juiceswapxyz/sdk-core';
+import { Tick, TickConstructorArgs, TickDataProvider } from '@juiceswapxyz/v3-sdk';
+import JSBI from 'jsbi';
+export declare const DYNAMIC_FEE_FLAG = 8388608;
+export declare type PoolKey = {
+    currency0: string;
+    currency1: string;
+    fee: number;
+    tickSpacing: number;
+    hooks: string;
+};
+/**
+ * Represents a V4 pool
+ */
+export declare class Pool {
+    readonly currency0: Currency;
+    readonly currency1: Currency;
+    readonly fee: number;
+    readonly tickSpacing: number;
+    readonly sqrtRatioX96: JSBI;
+    readonly hooks: string;
+    readonly liquidity: JSBI;
+    readonly tickCurrent: number;
+    readonly tickDataProvider: TickDataProvider;
+    readonly poolKey: PoolKey;
+    readonly poolId: string;
+    private _currency0Price?;
+    private _currency1Price?;
+    static getPoolKey(currencyA: Currency, currencyB: Currency, fee: number, tickSpacing: number, hooks: string): PoolKey;
+    static getPoolId(currencyA: Currency, currencyB: Currency, fee: number, tickSpacing: number, hooks: string): string;
+    /**
+     * Construct a pool
+     * @param currencyA One of the currencys in the pool
+     * @param currencyB The other currency in the pool
+     * @param fee The fee in hundredths of a bips of the input amount of every swap that is collected by the pool
+     * @param tickSpacing The tickSpacing of the pool
+     * @param hooks The address of the hook contract
+     * @param sqrtRatioX96 The sqrt of the current ratio of amounts of currency1 to currency0
+     * @param liquidity The current value of in range liquidity
+     * @param tickCurrent The current tick of the pool
+     */
+    constructor(currencyA: Currency, currencyB: Currency, fee: number, tickSpacing: number, hooks: string, sqrtRatioX96: BigintIsh, liquidity: BigintIsh, tickCurrent: number, ticks?: TickDataProvider | (Tick | TickConstructorArgs)[]);
+    /** backwards compatibility with v2/3 sdks */
+    get token0(): Currency;
+    get token1(): Currency;
+    /**
+     * Returns true if the currency is either currency0 or currency1
+     * @param currency The currency to check
+     * @returns True if currency is either currency0 or currency1
+     */
+    involvesCurrency(currency: Currency): boolean;
+    /** backwards compatibility with v2/3 sdks */
+    involvesToken(currency: Currency): boolean;
+    /**
+     * v4-only involvesToken convenience method, used for mixed route ETH <-> WETH connection only
+     * @param currency
+     */
+    v4InvolvesToken(currency: Currency): boolean;
+    /**
+     * Returns the current mid price of the pool in terms of currency0, i.e. the ratio of currency1 over currency0
+     */
+    get currency0Price(): Price<Currency, Currency>;
+    /** backwards compatibility with v2/3 sdks */
+    get token0Price(): Price<Currency, Currency>;
+    /**
+     * Returns the current mid price of the pool in terms of currency1, i.e. the ratio of currency0 over currency1
+     */
+    get currency1Price(): Price<Currency, Currency>;
+    /** backwards compatibility with v2/3 sdks */
+    get token1Price(): Price<Currency, Currency>;
+    /**
+     * Return the price of the given currency in terms of the other currency in the pool.
+     * @param currency The currency to return price of
+     * @returns The price of the given currency, in terms of the other.
+     */
+    priceOf(currency: Currency): Price<Currency, Currency>;
+    /**
+     * Returns the chain ID of the currencies in the pool.
+     */
+    get chainId(): number;
+    /** Works only for vanilla hookless v3 pools, otherwise throws an error */
+    getOutputAmount(inputAmount: CurrencyAmount<Currency>, sqrtPriceLimitX96?: JSBI): Promise<[CurrencyAmount<Currency>, Pool]>;
+    /**
+     * Given a desired output amount of a currency, return the computed input amount and a pool with state updated after the trade
+     * Works only for vanilla hookless v3 pools, otherwise throws an error
+     * @param outputAmount the output amount for which to quote the input amount
+     * @param sqrtPriceLimitX96 The Q64.96 sqrt price limit. If zero for one, the price cannot be less than this value after the swap. If one for zero, the price cannot be greater than this value after the swap
+     * @returns The input amount and the pool with updated state
+     */
+    getInputAmount(outputAmount: CurrencyAmount<Currency>, sqrtPriceLimitX96?: JSBI): Promise<[CurrencyAmount<Currency>, Pool]>;
+    /**
+     * Executes a swap
+     * @param zeroForOne Whether the amount in is token0 or token1
+     * @param amountSpecified The amount of the swap, which implicitly configures the swap as exact input (positive), or exact output (negative)
+     * @param sqrtPriceLimitX96 The Q64.96 sqrt price limit. If zero for one, the price cannot be less than this value after the swap. If one for zero, the price cannot be greater than this value after the swap
+     * @returns amountCalculated
+     * @returns sqrtRatioX96
+     * @returns liquidity
+     * @returns tickCurrent
+     */
+    private swap;
+    private hookImpactsSwap;
+}

package/dist/entities/position.d.ts

@@ -0,0 +1,144 @@
+import { BigintIsh, Percent, Price, CurrencyAmount, Currency } from '@juiceswapxyz/sdk-core';
+import JSBI from 'jsbi';
+import { Pool } from './pool';
+import { AllowanceTransferPermitBatch } from '../PositionManager';
+interface PositionConstructorArgs {
+    pool: Pool;
+    liquidity: BigintIsh;
+    tickLower: number;
+    tickUpper: number;
+}
+/**
+ * Represents a position on a Uniswap V4 Pool
+ * @dev Similar to the V3 implementation
+ * - using Currency instead of Token
+ * - keep in mind that Pool and liquidity must be fetched from the pool manager
+ */
+export declare class Position {
+    readonly pool: Pool;
+    readonly tickLower: number;
+    readonly tickUpper: number;
+    readonly liquidity: JSBI;
+    private _token0Amount;
+    private _token1Amount;
+    private _mintAmounts;
+    /**
+     * Constructs a position for a given pool with the given liquidity
+     * @param pool For which pool the liquidity is assigned
+     * @param liquidity The amount of liquidity that is in the position
+     * @param tickLower The lower tick of the position
+     * @param tickUpper The upper tick of the position
+     */
+    constructor({ pool, liquidity, tickLower, tickUpper }: PositionConstructorArgs);
+    /**
+     * Returns the price of token0 at the lower tick
+     */
+    get token0PriceLower(): Price<Currency, Currency>;
+    /**
+     * Returns the price of token0 at the upper tick
+     */
+    get token0PriceUpper(): Price<Currency, Currency>;
+    /**
+     * Returns the amount of token0 that this position's liquidity could be burned for at the current pool price
+     */
+    get amount0(): CurrencyAmount<Currency>;
+    /**
+     * Returns the amount of token1 that this position's liquidity could be burned for at the current pool price
+     */
+    get amount1(): CurrencyAmount<Currency>;
+    /**
+     * Returns the lower and upper sqrt ratios if the price 'slips' up to slippage tolerance percentage
+     * @param slippageTolerance The amount by which the price can 'slip' before the transaction will revert
+     * @returns The sqrt ratios after slippage
+     */
+    private ratiosAfterSlippage;
+    /**
+     * Returns the maximum amount of token0 and token1 that must be sent in order to safely mint the amount of liquidity held by the position
+     * with the given slippage tolerance
+     * @param slippageTolerance Tolerance of unfavorable slippage from the current price
+     * @returns The amounts, with slippage
+     * @dev In v4, minting and increasing is protected by maximum amounts of token0 and token1.
+     */
+    mintAmountsWithSlippage(slippageTolerance: Percent): Readonly<{
+        amount0: JSBI;
+        amount1: JSBI;
+    }>;
+    /**
+     * Returns the minimum amounts that should be requested in order to safely burn the amount of liquidity held by the
+     * position with the given slippage tolerance
+     * @param slippageTolerance tolerance of unfavorable slippage from the current price
+     * @returns The amounts, with slippage
+     */
+    burnAmountsWithSlippage(slippageTolerance: Percent): Readonly<{
+        amount0: JSBI;
+        amount1: JSBI;
+    }>;
+    /**
+     * Returns the minimum amounts that must be sent in order to mint the amount of liquidity held by the position at
+     * the current price for the pool
+     */
+    get mintAmounts(): Readonly<{
+        amount0: JSBI;
+        amount1: JSBI;
+    }>;
+    /**
+     * Returns the AllowanceTransferPermitBatch for adding liquidity to a position
+     * @param slippageTolerance The amount by which the price can 'slip' before the transaction will revert
+     * @param spender The spender of the permit (should usually be the PositionManager)
+     * @param nonce A valid permit2 nonce
+     * @param deadline The deadline for the permit
+     */
+    permitBatchData(slippageTolerance: Percent, spender: string, nonce: BigintIsh, deadline: BigintIsh): AllowanceTransferPermitBatch;
+    /**
+     * Computes the maximum amount of liquidity received for a given amount of token0, token1,
+     * and the prices at the tick boundaries.
+     * @param pool The pool for which the position should be created
+     * @param tickLower The lower tick of the position
+     * @param tickUpper The upper tick of the position
+     * @param amount0 token0 amountzw
+     * @param amount1 token1 amount
+     * @param useFullPrecision If false, liquidity will be maximized according to what the router can calculate,
+     * not what core can theoretically support
+     * @returns The amount of liquidity for the position
+     */
+    static fromAmounts({ pool, tickLower, tickUpper, amount0, amount1, useFullPrecision, }: {
+        pool: Pool;
+        tickLower: number;
+        tickUpper: number;
+        amount0: BigintIsh;
+        amount1: BigintIsh;
+        useFullPrecision: boolean;
+    }): Position;
+    /**
+     * Computes a position with the maximum amount of liquidity received for a given amount of token0, assuming an unlimited amount of token1
+     * @param pool The pool for which the position is created
+     * @param tickLower The lower tick
+     * @param tickUpper The upper tick
+     * @param amount0 The desired amount of token0
+     * @param useFullPrecision If true, liquidity will be maximized according to what the router can calculate,
+     * not what core can theoretically support
+     * @returns The position
+     */
+    static fromAmount0({ pool, tickLower, tickUpper, amount0, useFullPrecision, }: {
+        pool: Pool;
+        tickLower: number;
+        tickUpper: number;
+        amount0: BigintIsh;
+        useFullPrecision: boolean;
+    }): Position;
+    /**
+     * Computes a position with the maximum amount of liquidity received for a given amount of token1, assuming an unlimited amount of token0
+     * @param pool The pool for which the position is created
+     * @param tickLower The lower tick
+     * @param tickUpper The upper tick
+     * @param amount1 The desired amount of token1
+     * @returns The position
+     */
+    static fromAmount1({ pool, tickLower, tickUpper, amount1, }: {
+        pool: Pool;
+        tickLower: number;
+        tickUpper: number;
+        amount1: BigintIsh;
+    }): Position;
+}
+export {};

package/dist/entities/route.d.ts

@@ -0,0 +1,28 @@
+import { Currency, Price } from '@juiceswapxyz/sdk-core';
+import { Pool } from './pool';
+/**
+ * Represents a list of pools through which a swap can occur
+ * @template TInput The input currency
+ * @template TOutput The output currency
+ */
+export declare class Route<TInput extends Currency, TOutput extends Currency> {
+    readonly pools: Pool[];
+    readonly currencyPath: 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 `Pool` objects, ordered by the route the swap will take
+     * @param input The input currency
+     * @param output The output currency
+     */
+    constructor(pools: Pool[], input: TInput, output: TOutput);
+    get chainId(): number;
+    /**
+     * Returns the mid price of the route
+     */
+    get midPrice(): Price<TInput, TOutput>;
+}

package/dist/entities/trade.d.ts

@@ -0,0 +1,220 @@
+import { Currency, Percent, Price, CurrencyAmount, TradeType } from '@juiceswapxyz/sdk-core';
+import { Pool } from './pool';
+import { Route } from './route';
+/**
+ * Trades comparator, an extension of the input output comparator that also considers other dimensions of the trade in ranking them
+ * @template TInput The input currency, either Ether or an ERC-20
+ * @template TOutput The output currency, 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: Trade<TInput, TOutput, TTradeType>, b: Trade<TInput, TOutput, TTradeType>): number;
+export interface BestTradeOptions {
+    maxNumResults?: number;
+    maxHops?: 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.
+ * @template TInput The input currency, either Ether or an ERC-20
+ * @template TOutput The output currency, either Ether or an ERC-20
+ * @template TTradeType The trade type, either exact input or exact output
+ */
+export declare class Trade<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(): Route<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: Route<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 an exact in trade with the given amount in and route
+     * @template TInput The input currency, either Ether or an ERC-20
+     * @template TOutput The output currency, either Ether or an ERC-20
+     * @param route The route of the exact in trade
+     * @param amountIn The amount being passed in
+     * @returns The exact in trade
+     */
+    static exactIn<TInput extends Currency, TOutput extends Currency>(route: Route<TInput, TOutput>, amountIn: CurrencyAmount<TInput>): Promise<Trade<TInput, TOutput, TradeType.EXACT_INPUT>>;
+    /**
+     * Constructs an exact out trade with the given amount out and route
+     * @template TInput The input currency, either Ether or an ERC-20
+     * @template TOutput The output currency, either Ether or an ERC-20
+     * @param route The route of the exact out trade
+     * @param amountOut The amount returned by the trade
+     * @returns The exact out trade
+     */
+    static exactOut<TInput extends Currency, TOutput extends Currency>(route: Route<TInput, TOutput>, amountOut: CurrencyAmount<TOutput>): Promise<Trade<TInput, TOutput, TradeType.EXACT_OUTPUT>>;
+    /**
+     * Constructs a trade by simulating swaps through the given route
+     * @template TInput The input currency, either Ether or an ERC-20.
+     * @template TOutput The output currency, 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: Route<TInput, TOutput>, amount: TTradeType extends TradeType.EXACT_INPUT ? CurrencyAmount<TInput> : CurrencyAmount<TOutput>, tradeType: TTradeType): Promise<Trade<TInput, TOutput, TTradeType>>;
+    /**
+     * Constructs a trade from routes by simulating swaps
+     *
+     * @template TInput The input currency, either Ether or an ERC-20.
+     * @template TOutput The output currency, 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: Route<TInput, TOutput>;
+    }[], tradeType: TTradeType): Promise<Trade<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 currency, either Ether or an ERC-20
+     * @template TOutput The output currency, 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: Route<TInput, TOutput>;
+        inputAmount: CurrencyAmount<TInput>;
+        outputAmount: CurrencyAmount<TOutput>;
+        tradeType: TTradeType;
+    }): Trade<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 currency, either Ether or an ERC-20
+     * @template TOutput The output currency, 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: Route<TInput, TOutput>;
+            inputAmount: CurrencyAmount<TInput>;
+            outputAmount: CurrencyAmount<TOutput>;
+        }[];
+        tradeType: TTradeType;
+    }): Trade<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 currency
+     * amount to an output currency, 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: Pool[], currencyAmountIn: CurrencyAmount<TInput>, currencyOut: TOutput, { maxNumResults, maxHops }?: BestTradeOptions, currentPools?: Pool[], nextAmountIn?: CurrencyAmount<Currency>, bestTrades?: Trade<TInput, TOutput, TradeType.EXACT_INPUT>[]): Promise<Trade<TInput, TOutput, TradeType.EXACT_INPUT>[]>;
+    /**
+     * similar to the above method but instead targets a fixed output amount
+     * given a list of pools, and a fixed amount out, returns the top `maxNumResults` trades that go from an input currency
+     * to an output currency amount, 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 currencyIn the currency to spend
+     * @param currencyAmountOut the desired currency amount out
+     * @param nextAmountOut the exact amount of 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 bestTrades used in recursion; the current list of best trades
+     * @returns The exact out trade
+     */
+    static bestTradeExactOut<TInput extends Currency, TOutput extends Currency>(pools: Pool[], currencyIn: TInput, currencyAmountOut: CurrencyAmount<TOutput>, { maxNumResults, maxHops }?: BestTradeOptions, currentPools?: Pool[], nextAmountOut?: CurrencyAmount<Currency>, bestTrades?: Trade<TInput, TOutput, TradeType.EXACT_OUTPUT>[]): Promise<Trade<TInput, TOutput, TradeType.EXACT_OUTPUT>[]>;
+}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export * from './entities';
+export * from './utils';
+export * from './PositionManager';