@uniswap/router-sdk 2.7.2 → 2.8.0

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

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

package/dist/cjs/src/entities/trade.js

@@ -0,0 +1,370 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Trade = void 0;
+const tslib_1 = require("tslib");
+const sdk_core_1 = require("@uniswap/sdk-core");
+const v2_sdk_1 = require("@uniswap/v2-sdk");
+const v3_sdk_1 = require("@uniswap/v3-sdk");
+const v4_sdk_1 = require("@uniswap/v4-sdk");
+const tiny_invariant_1 = tslib_1.__importDefault(require("tiny-invariant"));
+const constants_1 = require("../constants");
+const route_1 = require("./mixedRoute/route");
+const trade_1 = require("./mixedRoute/trade");
+const route_2 = require("./route");
+class Trade {
+    //  construct a trade across v2 and v3 routes from pre-computed amounts
+    constructor({ v2Routes = [], v3Routes = [], v4Routes = [], mixedRoutes = [], tradeType, }) {
+        this.swaps = [];
+        this.routes = [];
+        // wrap v2 routes
+        for (const { routev2, inputAmount, outputAmount, maxHopSlippage } of v2Routes) {
+            const route = new route_2.RouteV2(routev2);
+            this.routes.push(route);
+            this.swaps.push({
+                route,
+                inputAmount,
+                outputAmount,
+                maxHopSlippage,
+            });
+        }
+        // wrap v3 routes
+        for (const { routev3, inputAmount, outputAmount, maxHopSlippage } of v3Routes) {
+            const route = new route_2.RouteV3(routev3);
+            this.routes.push(route);
+            this.swaps.push({
+                route,
+                inputAmount,
+                outputAmount,
+                maxHopSlippage,
+            });
+        }
+        // wrap v4 routes
+        for (const { routev4, inputAmount, outputAmount, maxHopSlippage } of v4Routes) {
+            const route = new route_2.RouteV4(routev4);
+            this.routes.push(route);
+            this.swaps.push({
+                route,
+                inputAmount,
+                outputAmount,
+                maxHopSlippage,
+            });
+        }
+        for (const { mixedRoute, inputAmount, outputAmount, maxHopSlippage } of mixedRoutes) {
+            const route = new route_2.MixedRoute(mixedRoute);
+            this.routes.push(route);
+            this.swaps.push({
+                route,
+                inputAmount,
+                outputAmount,
+                maxHopSlippage,
+            });
+        }
+        if (this.swaps.length === 0) {
+            throw new Error('No routes provided when calling Trade constructor');
+        }
+        this.tradeType = tradeType;
+        // each route must have the same input and output currency
+        const inputCurrency = this.swaps[0].inputAmount.currency;
+        const outputCurrency = this.swaps[0].outputAmount.currency;
+        (0, tiny_invariant_1.default)(this.swaps.every(({ route }) => inputCurrency.wrapped.equals(route.input.wrapped)), 'INPUT_CURRENCY_MATCH');
+        (0, tiny_invariant_1.default)(this.swaps.every(({ route }) => outputCurrency.wrapped.equals(route.output.wrapped)), 'OUTPUT_CURRENCY_MATCH');
+        // pools must be unique inter protocols
+        const numPools = this.swaps.map(({ route }) => route.pools.length).reduce((total, cur) => total + cur, 0);
+        const poolIdentifierSet = new Set();
+        for (const { route } of this.swaps) {
+            for (const pool of route.pools) {
+                if (pool instanceof v4_sdk_1.Pool) {
+                    poolIdentifierSet.add(pool.poolId);
+                }
+                else if (pool instanceof v3_sdk_1.Pool) {
+                    poolIdentifierSet.add(v3_sdk_1.Pool.getAddress(pool.token0, pool.token1, pool.fee));
+                }
+                else if (pool instanceof v2_sdk_1.Pair) {
+                    const pair = pool;
+                    poolIdentifierSet.add(v2_sdk_1.Pair.getAddress(pair.token0, pair.token1));
+                }
+                else {
+                    throw new Error('Unexpected pool type in route when constructing trade object');
+                }
+            }
+        }
+        (0, tiny_invariant_1.default)(numPools === poolIdentifierSet.size, 'POOLS_DUPLICATED');
+    }
+    get inputAmount() {
+        if (this._inputAmount) {
+            return this._inputAmount;
+        }
+        const inputAmountCurrency = this.swaps[0].inputAmount.currency;
+        const totalInputFromRoutes = this.swaps
+            .map(({ inputAmount: routeInputAmount }) => routeInputAmount)
+            .reduce((total, cur) => total.add(cur), sdk_core_1.CurrencyAmount.fromRawAmount(inputAmountCurrency, 0));
+        this._inputAmount = totalInputFromRoutes;
+        return this._inputAmount;
+    }
+    get outputAmount() {
+        if (this._outputAmount) {
+            return this._outputAmount;
+        }
+        const outputCurrency = this.swaps[0].outputAmount.currency;
+        const totalOutputFromRoutes = this.swaps
+            .map(({ outputAmount: routeOutputAmount }) => routeOutputAmount)
+            .reduce((total, cur) => total.add(cur), sdk_core_1.CurrencyAmount.fromRawAmount(outputCurrency, 0));
+        this._outputAmount = totalOutputFromRoutes;
+        return this._outputAmount;
+    }
+    /**
+     * Returns the sum of all swaps within the trade
+     * @returns
+     * inputAmount: total input amount
+     * inputAmountNative: total amount of native currency required for ETH input paths
+     *  - 0 if inputAmount is native but no native input paths
+     *  - undefined if inputAmount is not native
+     * outputAmount: total output amount
+     * outputAmountNative: total amount of native currency returned from ETH output paths
+     *  - 0 if outputAmount is native but no native output paths
+     *  - undefined if outputAmount is not native
+     */
+    get amounts() {
+        var _a, _b;
+        // Find native currencies for reduce below
+        const inputNativeCurrency = (_a = this.swaps.find(({ inputAmount }) => inputAmount.currency.isNative)) === null || _a === void 0 ? void 0 : _a.inputAmount.currency;
+        const outputNativeCurrency = (_b = this.swaps.find(({ outputAmount }) => outputAmount.currency.isNative)) === null || _b === void 0 ? void 0 : _b.outputAmount.currency;
+        return {
+            inputAmount: this.inputAmount,
+            inputAmountNative: inputNativeCurrency
+                ? this.swaps.reduce((total, swap) => {
+                    return swap.route.pathInput.isNative ? total.add(swap.inputAmount) : total;
+                }, sdk_core_1.CurrencyAmount.fromRawAmount(inputNativeCurrency, 0))
+                : undefined,
+            outputAmount: this.outputAmount,
+            outputAmountNative: outputNativeCurrency
+                ? this.swaps.reduce((total, swap) => {
+                    return swap.route.pathOutput.isNative ? total.add(swap.outputAmount) : total;
+                }, sdk_core_1.CurrencyAmount.fromRawAmount(outputNativeCurrency, 0))
+                : undefined,
+        };
+    }
+    get numberOfInputWraps() {
+        // if the trade's input is eth it may require a wrap
+        if (this.inputAmount.currency.isNative) {
+            return this.wethInputRoutes.length;
+        }
+        else
+            return 0;
+    }
+    get numberOfInputUnwraps() {
+        // if the trade's input is weth, it may require an unwrap
+        if (this.isWrappedNative(this.inputAmount.currency)) {
+            return this.nativeInputRoutes.length;
+        }
+        else
+            return 0;
+    }
+    get nativeInputRoutes() {
+        if (this._nativeInputRoutes) {
+            return this._nativeInputRoutes;
+        }
+        this._nativeInputRoutes = this.routes.filter((route) => route.pathInput.isNative);
+        return this._nativeInputRoutes;
+    }
+    get wethInputRoutes() {
+        if (this._wethInputRoutes) {
+            return this._wethInputRoutes;
+        }
+        this._wethInputRoutes = this.routes.filter((route) => this.isWrappedNative(route.pathInput));
+        return this._wethInputRoutes;
+    }
+    /**
+     * 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 sell tax of the input token
+     */
+    get inputTax() {
+        const inputCurrency = this.inputAmount.currency;
+        if (inputCurrency.isNative || !inputCurrency.wrapped.sellFeeBps)
+            return constants_1.ZERO_PERCENT;
+        return new sdk_core_1.Percent(inputCurrency.wrapped.sellFeeBps.toNumber(), 10000);
+    }
+    /**
+     * Returns the buy tax of the output token
+     */
+    get outputTax() {
+        const outputCurrency = this.outputAmount.currency;
+        if (outputCurrency.isNative || !outputCurrency.wrapped.buyFeeBps)
+            return constants_1.ZERO_PERCENT;
+        return new sdk_core_1.Percent(outputCurrency.wrapped.buyFeeBps.toNumber(), 10000);
+    }
+    isWrappedNative(currency) {
+        const chainId = currency.chainId;
+        return currency.equals(sdk_core_1.Ether.onChain(chainId).wrapped);
+    }
+    /**
+     * Returns the percent difference between the route's mid price and the expected execution price
+     * In order to exclude token taxes from the price impact calculation, the spot price is calculated
+     * using a ratio of values that go into the pools, which are the post-tax input amount and pre-tax output amount.
+     */
+    get priceImpact() {
+        if (this._priceImpact) {
+            return this._priceImpact;
+        }
+        // returns 0% price impact even though this may be inaccurate as a swap may have occured.
+        // because we're unable to derive the pre-buy-tax amount, use 0% as a placeholder.
+        if (this.outputTax.equalTo(constants_1.ONE_HUNDRED_PERCENT))
+            return constants_1.ZERO_PERCENT;
+        let spotOutputAmount = sdk_core_1.CurrencyAmount.fromRawAmount(this.outputAmount.currency, 0);
+        for (const { route, inputAmount } of this.swaps) {
+            const midPrice = route.midPrice;
+            const postTaxInputAmount = inputAmount.multiply(new sdk_core_1.Fraction(constants_1.ONE).subtract(this.inputTax));
+            spotOutputAmount = spotOutputAmount.add(midPrice.quote(postTaxInputAmount));
+        }
+        // if the total output of this trade is 0, then most likely the post-tax input was also 0, and therefore this swap
+        // does not move the pools' market price
+        if (spotOutputAmount.equalTo(constants_1.ZERO))
+            return constants_1.ZERO_PERCENT;
+        const preTaxOutputAmount = this.outputAmount.divide(new sdk_core_1.Fraction(constants_1.ONE).subtract(this.outputTax));
+        const priceImpact = spotOutputAmount.subtract(preTaxOutputAmount).divide(spotOutputAmount);
+        this._priceImpact = new sdk_core_1.Percent(priceImpact.numerator, priceImpact.denominator);
+        return this._priceImpact;
+    }
+    /**
+     * 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(constants_1.ZERO), 'SLIPPAGE_TOLERANCE');
+        if (this.tradeType === sdk_core_1.TradeType.EXACT_OUTPUT) {
+            return amountOut;
+        }
+        else {
+            const slippageAdjustedAmountOut = new sdk_core_1.Fraction(constants_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(constants_1.ZERO), 'SLIPPAGE_TOLERANCE');
+        if (this.tradeType === sdk_core_1.TradeType.EXACT_INPUT) {
+            return amountIn;
+        }
+        else {
+            const slippageAdjustedAmountIn = new sdk_core_1.Fraction(constants_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);
+    }
+    static async fromRoutes(v2Routes, v3Routes, tradeType, mixedRoutes, v4Routes) {
+        const populatedV2Routes = [];
+        const populatedV3Routes = [];
+        const populatedV4Routes = [];
+        const populatedMixedRoutes = [];
+        for (const { routev2, amount, maxHopSlippage } of v2Routes) {
+            const v2Trade = new v2_sdk_1.Trade(routev2, amount, tradeType);
+            const { inputAmount, outputAmount } = v2Trade;
+            populatedV2Routes.push({
+                routev2,
+                inputAmount,
+                outputAmount,
+                maxHopSlippage,
+            });
+        }
+        for (const { routev3, amount, maxHopSlippage } of v3Routes) {
+            const v3Trade = await v3_sdk_1.Trade.fromRoute(routev3, amount, tradeType);
+            const { inputAmount, outputAmount } = v3Trade;
+            populatedV3Routes.push({
+                routev3,
+                inputAmount,
+                outputAmount,
+                maxHopSlippage,
+            });
+        }
+        if (v4Routes) {
+            for (const { routev4, amount, maxHopSlippage } of v4Routes) {
+                const v4Trade = await v4_sdk_1.Trade.fromRoute(routev4, amount, tradeType);
+                const { inputAmount, outputAmount } = v4Trade;
+                populatedV4Routes.push({
+                    routev4,
+                    inputAmount,
+                    outputAmount,
+                    maxHopSlippage,
+                });
+            }
+        }
+        if (mixedRoutes) {
+            for (const { mixedRoute, amount, maxHopSlippage } of mixedRoutes) {
+                const mixedRouteTrade = await trade_1.MixedRouteTrade.fromRoute(mixedRoute, amount, tradeType);
+                const { inputAmount, outputAmount } = mixedRouteTrade;
+                populatedMixedRoutes.push({
+                    mixedRoute,
+                    inputAmount,
+                    outputAmount,
+                    maxHopSlippage,
+                });
+            }
+        }
+        return new Trade({
+            v2Routes: populatedV2Routes,
+            v3Routes: populatedV3Routes,
+            v4Routes: populatedV4Routes,
+            mixedRoutes: populatedMixedRoutes,
+            tradeType,
+        });
+    }
+    static async fromRoute(route, amount, tradeType) {
+        let v2Routes = [];
+        let v3Routes = [];
+        let v4Routes = [];
+        let mixedRoutes = [];
+        if (route instanceof v2_sdk_1.Route) {
+            const v2Trade = new v2_sdk_1.Trade(route, amount, tradeType);
+            const { inputAmount, outputAmount } = v2Trade;
+            v2Routes = [{ routev2: route, inputAmount, outputAmount }];
+        }
+        else if (route instanceof v3_sdk_1.Route) {
+            const v3Trade = await v3_sdk_1.Trade.fromRoute(route, amount, tradeType);
+            const { inputAmount, outputAmount } = v3Trade;
+            v3Routes = [{ routev3: route, inputAmount, outputAmount }];
+        }
+        else if (route instanceof v4_sdk_1.Route) {
+            const v4Trade = await v4_sdk_1.Trade.fromRoute(route, amount, tradeType);
+            const { inputAmount, outputAmount } = v4Trade;
+            v4Routes = [{ routev4: route, inputAmount, outputAmount }];
+        }
+        else if (route instanceof route_1.MixedRouteSDK) {
+            const mixedRouteTrade = await trade_1.MixedRouteTrade.fromRoute(route, amount, tradeType);
+            const { inputAmount, outputAmount } = mixedRouteTrade;
+            mixedRoutes = [{ mixedRoute: route, inputAmount, outputAmount }];
+        }
+        else {
+            throw new Error('Invalid route type');
+        }
+        return new Trade({
+            v2Routes,
+            v3Routes,
+            v4Routes,
+            mixedRoutes,
+            tradeType,
+        });
+    }
+}
+exports.Trade = Trade;
+//# sourceMappingURL=trade.js.map