@centurion_project/v3-sdk 3.30.0-ctn.0

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

@@ -0,0 +1,220 @@
+import { Currency, Percent, Price, CurrencyAmount, TradeType } from '@centurion_project/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 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: 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 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 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 token, either Ether or an ERC-20
+     * @template TOutput The output token, 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 token, either Ether or an ERC-20
+     * @template TOutput The output token, 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 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: 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 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: 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 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: 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 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: 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 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: 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 token
+     * to an output token 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/cjs/src/entities/trade.js

@@ -0,0 +1,440 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Trade = exports.tradeComparator = void 0;
+const tslib_1 = require("tslib");
+const sdk_core_1 = require("@centurion_project/sdk-core");
+const tiny_invariant_1 = tslib_1.__importDefault(require("tiny-invariant"));
+const internalConstants_1 = require("../internalConstants");
+const pool_1 = require("./pool");
+const route_1 = require("./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 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
+ */
+function tradeComparator(a, b) {
+    // must have same input and output token for comparison
+    (0, tiny_invariant_1.default)(a.inputAmount.currency.equals(b.inputAmount.currency), 'INPUT_CURRENCY');
+    (0, tiny_invariant_1.default)(a.outputAmount.currency.equals(b.outputAmount.currency), 'OUTPUT_CURRENCY');
+    if (a.outputAmount.equalTo(b.outputAmount)) {
+        if (a.inputAmount.equalTo(b.inputAmount)) {
+            // consider the number of hops since each hop costs gas
+            const aHops = a.swaps.reduce((total, cur) => total + cur.route.tokenPath.length, 0);
+            const bHops = b.swaps.reduce((total, cur) => total + cur.route.tokenPath.length, 0);
+            return aHops - bHops;
+        }
+        // trade A requires less input than trade B, so A should come first
+        if (a.inputAmount.lessThan(b.inputAmount)) {
+            return -1;
+        }
+        else {
+            return 1;
+        }
+    }
+    else {
+        // tradeA has less output than trade B, so should come second
+        if (a.outputAmount.lessThan(b.outputAmount)) {
+            return 1;
+        }
+        else {
+            return -1;
+        }
+    }
+}
+exports.tradeComparator = tradeComparator;
+/**
+ * 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 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
+ */
+class Trade {
+    /**
+     * @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() {
+        (0, tiny_invariant_1.default)(this.swaps.length === 1, 'MULTIPLE_ROUTES');
+        return this.swaps[0].route;
+    }
+    /**
+     * The input amount for the trade assuming no slippage.
+     */
+    get inputAmount() {
+        if (this._inputAmount) {
+            return this._inputAmount;
+        }
+        const inputCurrency = this.swaps[0].inputAmount.currency;
+        const totalInputFromRoutes = this.swaps
+            .map(({ inputAmount }) => inputAmount)
+            .reduce((total, cur) => total.add(cur), sdk_core_1.CurrencyAmount.fromRawAmount(inputCurrency, 0));
+        this._inputAmount = totalInputFromRoutes;
+        return this._inputAmount;
+    }
+    /**
+     * The output amount for the trade assuming no slippage.
+     */
+    get outputAmount() {
+        if (this._outputAmount) {
+            return this._outputAmount;
+        }
+        const outputCurrency = this.swaps[0].outputAmount.currency;
+        const totalOutputFromRoutes = this.swaps
+            .map(({ outputAmount }) => outputAmount)
+            .reduce((total, cur) => total.add(cur), sdk_core_1.CurrencyAmount.fromRawAmount(outputCurrency, 0));
+        this._outputAmount = totalOutputFromRoutes;
+        return this._outputAmount;
+    }
+    /**
+     * The price expressed in terms of output amount/input amount.
+     */
+    get executionPrice() {
+        var _a;
+        return ((_a = this._executionPrice) !== null && _a !== void 0 ? _a : (this._executionPrice = new sdk_core_1.Price(this.inputAmount.currency, this.outputAmount.currency, this.inputAmount.quotient, this.outputAmount.quotient)));
+    }
+    /**
+     * Returns the percent difference between the route's mid price and the price impact
+     */
+    get priceImpact() {
+        if (this._priceImpact) {
+            return this._priceImpact;
+        }
+        let spotOutputAmount = sdk_core_1.CurrencyAmount.fromRawAmount(this.outputAmount.currency, 0);
+        for (const { route, inputAmount } of this.swaps) {
+            const midPrice = route.midPrice;
+            spotOutputAmount = spotOutputAmount.add(midPrice.quote(inputAmount));
+        }
+        const priceImpact = spotOutputAmount.subtract(this.outputAmount).divide(spotOutputAmount);
+        this._priceImpact = new sdk_core_1.Percent(priceImpact.numerator, priceImpact.denominator);
+        return this._priceImpact;
+    }
+    /**
+     * Constructs an exact in trade with the given amount in and route
+     * @template TInput The input token, either Ether or an ERC-20
+     * @template TOutput The output token, 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 async exactIn(route, amountIn) {
+        return Trade.fromRoute(route, amountIn, sdk_core_1.TradeType.EXACT_INPUT);
+    }
+    /**
+     * Constructs an exact out trade with the given amount out and route
+     * @template TInput The input token, either Ether or an ERC-20
+     * @template TOutput The output token, 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 async exactOut(route, amountOut) {
+        return Trade.fromRoute(route, amountOut, sdk_core_1.TradeType.EXACT_OUTPUT);
+    }
+    /**
+     * 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 async fromRoute(route, amount, tradeType) {
+        const amounts = new Array(route.tokenPath.length);
+        let inputAmount;
+        let outputAmount;
+        if (tradeType === sdk_core_1.TradeType.EXACT_INPUT) {
+            (0, tiny_invariant_1.default)(amount.currency.equals(route.input), 'INPUT');
+            amounts[0] = amount.wrapped;
+            for (let i = 0; i < route.tokenPath.length - 1; i++) {
+                const pool = route.pools[i];
+                const [outputAmount] = await pool.getOutputAmount(amounts[i]);
+                amounts[i + 1] = outputAmount;
+            }
+            inputAmount = sdk_core_1.CurrencyAmount.fromFractionalAmount(route.input, amount.numerator, amount.denominator);
+            outputAmount = sdk_core_1.CurrencyAmount.fromFractionalAmount(route.output, amounts[amounts.length - 1].numerator, amounts[amounts.length - 1].denominator);
+        }
+        else {
+            (0, tiny_invariant_1.default)(amount.currency.equals(route.output), 'OUTPUT');
+            amounts[amounts.length - 1] = amount.wrapped;
+            for (let i = route.tokenPath.length - 1; i > 0; i--) {
+                const pool = route.pools[i - 1];
+                const [inputAmount] = await pool.getInputAmount(amounts[i]);
+                amounts[i - 1] = inputAmount;
+            }
+            inputAmount = sdk_core_1.CurrencyAmount.fromFractionalAmount(route.input, amounts[0].numerator, amounts[0].denominator);
+            outputAmount = sdk_core_1.CurrencyAmount.fromFractionalAmount(route.output, amount.numerator, amount.denominator);
+        }
+        return new Trade({
+            routes: [{ inputAmount, outputAmount, route }],
+            tradeType,
+        });
+    }
+    /**
+     * 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 async fromRoutes(routes, tradeType) {
+        const populatedRoutes = [];
+        for (const { route, amount } of routes) {
+            const amounts = new Array(route.tokenPath.length);
+            let inputAmount;
+            let outputAmount;
+            if (tradeType === sdk_core_1.TradeType.EXACT_INPUT) {
+                (0, tiny_invariant_1.default)(amount.currency.equals(route.input), 'INPUT');
+                inputAmount = sdk_core_1.CurrencyAmount.fromFractionalAmount(route.input, amount.numerator, amount.denominator);
+                amounts[0] = sdk_core_1.CurrencyAmount.fromFractionalAmount(route.input.wrapped, amount.numerator, amount.denominator);
+                for (let i = 0; i < route.tokenPath.length - 1; i++) {
+                    const pool = route.pools[i];
+                    const [outputAmount] = await pool.getOutputAmount(amounts[i]);
+                    amounts[i + 1] = outputAmount;
+                }
+                outputAmount = sdk_core_1.CurrencyAmount.fromFractionalAmount(route.output, amounts[amounts.length - 1].numerator, amounts[amounts.length - 1].denominator);
+            }
+            else {
+                (0, tiny_invariant_1.default)(amount.currency.equals(route.output), 'OUTPUT');
+                outputAmount = sdk_core_1.CurrencyAmount.fromFractionalAmount(route.output, amount.numerator, amount.denominator);
+                amounts[amounts.length - 1] = sdk_core_1.CurrencyAmount.fromFractionalAmount(route.output.wrapped, amount.numerator, amount.denominator);
+                for (let i = route.tokenPath.length - 1; i > 0; i--) {
+                    const pool = route.pools[i - 1];
+                    const [inputAmount] = await pool.getInputAmount(amounts[i]);
+                    amounts[i - 1] = inputAmount;
+                }
+                inputAmount = sdk_core_1.CurrencyAmount.fromFractionalAmount(route.input, amounts[0].numerator, amounts[0].denominator);
+            }
+            populatedRoutes.push({ route, inputAmount, outputAmount });
+        }
+        return new Trade({
+            routes: populatedRoutes,
+            tradeType,
+        });
+    }
+    /**
+     * 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(constructorArguments) {
+        return new Trade({
+            ...constructorArguments,
+            routes: [
+                {
+                    inputAmount: constructorArguments.inputAmount,
+                    outputAmount: constructorArguments.outputAmount,
+                    route: constructorArguments.route,
+                },
+            ],
+        });
+    }
+    /**
+     * 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(constructorArguments) {
+        return new Trade(constructorArguments);
+    }
+    /**
+     * 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
+     */
+    constructor({ routes, tradeType, }) {
+        const inputCurrency = routes[0].inputAmount.currency;
+        const outputCurrency = routes[0].outputAmount.currency;
+        (0, tiny_invariant_1.default)(routes.every(({ route }) => inputCurrency.wrapped.equals(route.input.wrapped)), 'INPUT_CURRENCY_MATCH');
+        (0, tiny_invariant_1.default)(routes.every(({ route }) => outputCurrency.wrapped.equals(route.output.wrapped)), 'OUTPUT_CURRENCY_MATCH');
+        const numPools = routes.map(({ route }) => route.pools.length).reduce((total, cur) => total + cur, 0);
+        const poolAddressSet = new Set();
+        for (const { route } of routes) {
+            for (const pool of route.pools) {
+                poolAddressSet.add(pool_1.Pool.getAddress(pool.token0, pool.token1, pool.fee));
+            }
+        }
+        (0, tiny_invariant_1.default)(numPools === poolAddressSet.size, 'POOLS_DUPLICATED');
+        this.swaps = routes;
+        this.tradeType = tradeType;
+    }
+    /**
+     * 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, amountOut = this.outputAmount) {
+        (0, tiny_invariant_1.default)(!slippageTolerance.lessThan(internalConstants_1.ZERO), 'SLIPPAGE_TOLERANCE');
+        if (this.tradeType === sdk_core_1.TradeType.EXACT_OUTPUT) {
+            return amountOut;
+        }
+        else {
+            const slippageAdjustedAmountOut = new sdk_core_1.Fraction(internalConstants_1.ONE)
+                .add(slippageTolerance)
+                .invert()
+                .multiply(amountOut.quotient).quotient;
+            return sdk_core_1.CurrencyAmount.fromRawAmount(amountOut.currency, slippageAdjustedAmountOut);
+        }
+    }
+    /**
+     * 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, amountIn = this.inputAmount) {
+        (0, tiny_invariant_1.default)(!slippageTolerance.lessThan(internalConstants_1.ZERO), 'SLIPPAGE_TOLERANCE');
+        if (this.tradeType === sdk_core_1.TradeType.EXACT_INPUT) {
+            return amountIn;
+        }
+        else {
+            const slippageAdjustedAmountIn = new sdk_core_1.Fraction(internalConstants_1.ONE).add(slippageTolerance).multiply(amountIn.quotient).quotient;
+            return sdk_core_1.CurrencyAmount.fromRawAmount(amountIn.currency, slippageAdjustedAmountIn);
+        }
+    }
+    /**
+     * Return the execution price after accounting for slippage tolerance
+     * @param slippageTolerance the allowed tolerated slippage
+     * @returns The execution price
+     */
+    worstExecutionPrice(slippageTolerance) {
+        return new sdk_core_1.Price(this.inputAmount.currency, this.outputAmount.currency, this.maximumAmountIn(slippageTolerance).quotient, this.minimumAmountOut(slippageTolerance).quotient);
+    }
+    /**
+     * 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 async bestTradeExactIn(pools, currencyAmountIn, currencyOut, { maxNumResults = 3, maxHops = 3 } = {}, 
+    // used in recursion.
+    currentPools = [], nextAmountIn = currencyAmountIn, bestTrades = []) {
+        (0, tiny_invariant_1.default)(pools.length > 0, 'POOLS');
+        (0, tiny_invariant_1.default)(maxHops > 0, 'MAX_HOPS');
+        (0, tiny_invariant_1.default)(currencyAmountIn === nextAmountIn || currentPools.length > 0, 'INVALID_RECURSION');
+        const amountIn = nextAmountIn.wrapped;
+        const tokenOut = currencyOut.wrapped;
+        for (let i = 0; i < pools.length; i++) {
+            const pool = pools[i];
+            // pool irrelevant
+            if (!pool.token0.equals(amountIn.currency) && !pool.token1.equals(amountIn.currency))
+                continue;
+            let amountOut;
+            try {
+                ;
+                [amountOut] = await pool.getOutputAmount(amountIn);
+            }
+            catch (error) {
+                // input too low
+                if (error.isInsufficientInputAmountError) {
+                    continue;
+                }
+                throw error;
+            }
+            // we have arrived at the output token, so this is the final trade of one of the paths
+            if (amountOut.currency.isToken && amountOut.currency.equals(tokenOut)) {
+                (0, sdk_core_1.sortedInsert)(bestTrades, await Trade.fromRoute(new route_1.Route([...currentPools, pool], currencyAmountIn.currency, currencyOut), currencyAmountIn, sdk_core_1.TradeType.EXACT_INPUT), maxNumResults, tradeComparator);
+            }
+            else if (maxHops > 1 && pools.length > 1) {
+                const poolsExcludingThisPool = pools.slice(0, i).concat(pools.slice(i + 1, pools.length));
+                // otherwise, consider all the other paths that lead from this token as long as we have not exceeded maxHops
+                await Trade.bestTradeExactIn(poolsExcludingThisPool, currencyAmountIn, currencyOut, {
+                    maxNumResults,
+                    maxHops: maxHops - 1,
+                }, [...currentPools, pool], amountOut, bestTrades);
+            }
+        }
+        return bestTrades;
+    }
+    /**
+     * 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 token
+     * to an output token 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 async bestTradeExactOut(pools, currencyIn, currencyAmountOut, { maxNumResults = 3, maxHops = 3 } = {}, 
+    // used in recursion.
+    currentPools = [], nextAmountOut = currencyAmountOut, bestTrades = []) {
+        (0, tiny_invariant_1.default)(pools.length > 0, 'POOLS');
+        (0, tiny_invariant_1.default)(maxHops > 0, 'MAX_HOPS');
+        (0, tiny_invariant_1.default)(currencyAmountOut === nextAmountOut || currentPools.length > 0, 'INVALID_RECURSION');
+        const amountOut = nextAmountOut.wrapped;
+        const tokenIn = currencyIn.wrapped;
+        for (let i = 0; i < pools.length; i++) {
+            const pool = pools[i];
+            // pool irrelevant
+            if (!pool.token0.equals(amountOut.currency) && !pool.token1.equals(amountOut.currency))
+                continue;
+            let amountIn;
+            try {
+                ;
+                [amountIn] = await pool.getInputAmount(amountOut);
+            }
+            catch (error) {
+                // not enough liquidity in this pool
+                if (error.isInsufficientReservesError) {
+                    continue;
+                }
+                throw error;
+            }
+            // we have arrived at the input token, so this is the first trade of one of the paths
+            if (amountIn.currency.equals(tokenIn)) {
+                (0, sdk_core_1.sortedInsert)(bestTrades, await Trade.fromRoute(new route_1.Route([pool, ...currentPools], currencyIn, currencyAmountOut.currency), currencyAmountOut, sdk_core_1.TradeType.EXACT_OUTPUT), maxNumResults, tradeComparator);
+            }
+            else if (maxHops > 1 && pools.length > 1) {
+                const poolsExcludingThisPool = pools.slice(0, i).concat(pools.slice(i + 1, pools.length));
+                // otherwise, consider all the other paths that arrive at this token as long as we have not exceeded maxHops
+                await Trade.bestTradeExactOut(poolsExcludingThisPool, currencyIn, currencyAmountOut, {
+                    maxNumResults,
+                    maxHops: maxHops - 1,
+                }, [pool, ...currentPools], amountIn, bestTrades);
+            }
+        }
+        return bestTrades;
+    }
+}
+exports.Trade = Trade;
+//# sourceMappingURL=trade.js.map