@pioneer-platform/uniswap-client 0.0.21 → 0.0.24

package/lib/routing/types.js

@@ -0,0 +1,424 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.URAQuoteType = exports.SwapRouterNativeAssets = exports.PoolType = exports.QuoteState = exports.LimitOrderTrade = exports.PreviewTrade = exports.DutchOrderTrade = exports.OFFCHAIN_ORDER_TYPE_TO_SIGNATURE_TYPE = exports.OffchainOrderType = exports.ClassicTrade = exports.TradeFillType = exports.isClassicQuoteResponse = exports.QuoteIntent = exports.RouterPreference = exports.INTERNAL_ROUTER_PREFERENCE_PRICE = exports.QuoteMethod = exports.TradeState = void 0;
+var constants_1 = require("@ethersproject/constants");
+var router_sdk_1 = require("@uniswap/router-sdk");
+var sdk_core_1 = require("@uniswap/sdk-core");
+var uniswapx_sdk_1 = require("@uniswap/uniswapx-sdk");
+var misc_1 = require("../constants/misc");
+var ethers_1 = require("ethers/lib/ethers");
+var SignatureType;
+(function (SignatureType) {
+    SignatureType["SIGN_UNISWAPX_ORDER"] = "signUniswapXOrder";
+    SignatureType["SIGN_UNISWAPX_V2_ORDER"] = "signUniswapXV2Order";
+    SignatureType["SIGN_LIMIT"] = "signLimit";
+})(SignatureType || (SignatureType = {}));
+var TradeState;
+(function (TradeState) {
+    TradeState["LOADING"] = "loading";
+    TradeState["INVALID"] = "invalid";
+    TradeState["STALE"] = "stale";
+    TradeState["NO_ROUTE_FOUND"] = "no_route_found";
+    TradeState["VALID"] = "valid";
+})(TradeState || (exports.TradeState = TradeState = {}));
+var QuoteMethod;
+(function (QuoteMethod) {
+    QuoteMethod["ROUTING_API"] = "ROUTING_API";
+    QuoteMethod["QUICK_ROUTE"] = "QUICK_ROUTE";
+    QuoteMethod["CLIENT_SIDE_FALLBACK"] = "CLIENT_SIDE_FALLBACK";
+})(QuoteMethod || (exports.QuoteMethod = QuoteMethod = {}));
+// This is excluded from `RouterPreference` enum because it's only used
+// internally for token -> USDC trades to get a USD value.
+exports.INTERNAL_ROUTER_PREFERENCE_PRICE = 'price';
+var RouterPreference;
+(function (RouterPreference) {
+    RouterPreference["X"] = "uniswapx";
+    RouterPreference["API"] = "api";
+})(RouterPreference || (exports.RouterPreference = RouterPreference = {}));
+// TODO(limits): add Limit market price intent
+var QuoteIntent;
+(function (QuoteIntent) {
+    QuoteIntent["Pricing"] = "pricing";
+    QuoteIntent["Quote"] = "quote";
+})(QuoteIntent || (exports.QuoteIntent = QuoteIntent = {}));
+function isClassicQuoteResponse(data) {
+    return data.routing === URAQuoteType.CLASSIC;
+}
+exports.isClassicQuoteResponse = isClassicQuoteResponse;
+var TradeFillType;
+(function (TradeFillType) {
+    TradeFillType["Classic"] = "classic";
+    TradeFillType["UniswapX"] = "uniswap_x";
+    TradeFillType["None"] = "none";
+})(TradeFillType || (exports.TradeFillType = TradeFillType = {}));
+var ClassicTrade = /** @class */ (function (_super) {
+    __extends(ClassicTrade, _super);
+    function ClassicTrade(_a) {
+        var _this = this;
+        var gasUseEstimate = _a.gasUseEstimate, gasUseEstimateUSD = _a.gasUseEstimateUSD, blockNumber = _a.blockNumber, requestId = _a.requestId, quoteMethod = _a.quoteMethod, approveInfo = _a.approveInfo, swapFee = _a.swapFee, routes = __rest(_a, ["gasUseEstimate", "gasUseEstimateUSD", "blockNumber", "requestId", "quoteMethod", "approveInfo", "swapFee"]);
+        _this = _super.call(this, routes) || this;
+        _this.fillType = TradeFillType.Classic;
+        _this.blockNumber = blockNumber;
+        _this.gasUseEstimateUSD = gasUseEstimateUSD;
+        _this.requestId = requestId;
+        _this.quoteMethod = quoteMethod;
+        _this.approveInfo = approveInfo;
+        _this.swapFee = swapFee;
+        _this.gasUseEstimate = gasUseEstimate;
+        return _this;
+    }
+    Object.defineProperty(ClassicTrade.prototype, "executionPrice", {
+        get: function () {
+            if (this.tradeType === sdk_core_1.TradeType.EXACT_INPUT || !this.swapFee) { // @ts-ignore
+                return _super.prototype.executionPrice;
+            }
+            // Fix inaccurate price calculation for exact output trades
+            return new sdk_core_1.Price({ baseAmount: this.inputAmount, quoteAmount: this.postSwapFeeOutputAmount });
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ClassicTrade.prototype, "postSwapFeeOutputAmount", {
+        get: function () {
+            var _a, _b;
+            // Routing api already applies the swap fee to the output amount for exact-in
+            if (this.tradeType === sdk_core_1.TradeType.EXACT_INPUT)
+                return this.outputAmount;
+            var swapFeeAmount = sdk_core_1.CurrencyAmount.fromRawAmount(this.outputAmount.currency, (_b = (_a = this.swapFee) === null || _a === void 0 ? void 0 : _a.amount) !== null && _b !== void 0 ? _b : 0);
+            return this.outputAmount.subtract(swapFeeAmount);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ClassicTrade.prototype, "totalGasUseEstimateUSD", {
+        // gas estimate for maybe approve + swap
+        get: function () {
+            if (this.approveInfo.needsApprove && this.gasUseEstimateUSD) {
+                return this.approveInfo.approveGasEstimateUSD + this.gasUseEstimateUSD;
+            }
+            return this.gasUseEstimateUSD;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return ClassicTrade;
+}(router_sdk_1.Trade));
+exports.ClassicTrade = ClassicTrade;
+var OffchainOrderType;
+(function (OffchainOrderType) {
+    OffchainOrderType["DUTCH_AUCTION"] = "Dutch";
+    OffchainOrderType["DUTCH_V2_AUCTION"] = "Dutch_V2";
+    OffchainOrderType["LIMIT_ORDER"] = "Limit";
+})(OffchainOrderType || (exports.OffchainOrderType = OffchainOrderType = {}));
+exports.OFFCHAIN_ORDER_TYPE_TO_SIGNATURE_TYPE = (_a = {},
+    _a[OffchainOrderType.DUTCH_AUCTION] = SignatureType.SIGN_UNISWAPX_ORDER,
+    _a[OffchainOrderType.DUTCH_V2_AUCTION] = SignatureType.SIGN_UNISWAPX_V2_ORDER,
+    _a[OffchainOrderType.LIMIT_ORDER] = SignatureType.SIGN_LIMIT,
+    _a);
+var DutchOrderTrade = /** @class */ (function (_super) {
+    __extends(DutchOrderTrade, _super);
+    function DutchOrderTrade(_a) {
+        var currencyIn = _a.currencyIn, currenciesOut = _a.currenciesOut, orderInfo = _a.orderInfo, tradeType = _a.tradeType, quoteId = _a.quoteId, requestId = _a.requestId, wrapInfo = _a.wrapInfo, approveInfo = _a.approveInfo, classicGasUseEstimateUSD = _a.classicGasUseEstimateUSD, auctionPeriodSecs = _a.auctionPeriodSecs, startTimeBufferSecs = _a.startTimeBufferSecs, deadlineBufferSecs = _a.deadlineBufferSecs, slippageTolerance = _a.slippageTolerance, swapFee = _a.swapFee;
+        var _this = _super.call(this, { currencyIn: currencyIn, currenciesOut: currenciesOut, orderInfo: orderInfo, tradeType: tradeType }) || this;
+        _this.fillType = TradeFillType.UniswapX;
+        _this.offchainOrderType = OffchainOrderType.DUTCH_AUCTION;
+        _this.inputTax = misc_1.ZERO_PERCENT;
+        _this.outputTax = misc_1.ZERO_PERCENT;
+        _this.quoteId = quoteId;
+        _this.requestId = requestId;
+        _this.approveInfo = approveInfo;
+        _this.wrapInfo = wrapInfo;
+        _this.classicGasUseEstimateUSD = classicGasUseEstimateUSD;
+        _this.auctionPeriodSecs = auctionPeriodSecs;
+        _this.deadlineBufferSecs = deadlineBufferSecs;
+        _this.slippageTolerance = slippageTolerance;
+        _this.startTimeBufferSecs = startTimeBufferSecs;
+        _this.swapFee = swapFee;
+        return _this;
+    }
+    Object.defineProperty(DutchOrderTrade.prototype, "totalGasUseEstimateUSD", {
+        get: function () {
+            if (this.wrapInfo.needsWrap && this.approveInfo.needsApprove) {
+                return this.wrapInfo.wrapGasEstimateUSD + this.approveInfo.approveGasEstimateUSD;
+            }
+            if (this.wrapInfo.needsWrap)
+                return this.wrapInfo.wrapGasEstimateUSD;
+            if (this.approveInfo.needsApprove)
+                return this.approveInfo.approveGasEstimateUSD;
+            return 0;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    DutchOrderTrade.prototype.asDutchOrderTrade = function () {
+        return this;
+    };
+    return DutchOrderTrade;
+}(uniswapx_sdk_1.DutchOrderTrade));
+exports.DutchOrderTrade = DutchOrderTrade;
+var PreviewTrade = /** @class */ (function () {
+    function PreviewTrade(_a) {
+        var inputAmount = _a.inputAmount, outputAmount = _a.outputAmount, tradeType = _a.tradeType;
+        this.fillType = TradeFillType.None;
+        this.quoteMethod = QuoteMethod.QUICK_ROUTE;
+        this.inputAmount = inputAmount;
+        this.outputAmount = outputAmount;
+        this.tradeType = tradeType;
+    }
+    // below methods are copied from router-sdk
+    // Trade https://github.com/Uniswap/router-sdk/blob/main/src/entities/trade.ts#L10
+    PreviewTrade.prototype.minimumAmountOut = function (slippageTolerance, amountOut) {
+        if (amountOut === void 0) { amountOut = this.outputAmount; }
+        if (this.tradeType === sdk_core_1.TradeType.EXACT_OUTPUT) {
+            return amountOut;
+        }
+        else {
+            var slippageAdjustedAmountOut = new sdk_core_1.Fraction(router_sdk_1.ONE)
+                .add(slippageTolerance)
+                .invert()
+                .multiply(amountOut.quotient).quotient;
+            return sdk_core_1.CurrencyAmount.fromRawAmount(amountOut.currency, slippageAdjustedAmountOut);
+        }
+    };
+    PreviewTrade.prototype.maximumAmountIn = function (slippageTolerance, amountIn) {
+        if (amountIn === void 0) { amountIn = this.inputAmount; }
+        if (this.tradeType === sdk_core_1.TradeType.EXACT_INPUT) {
+            return amountIn;
+        }
+        else {
+            var slippageAdjustedAmountIn = new sdk_core_1.Fraction(router_sdk_1.ONE).add(slippageTolerance).multiply(amountIn.quotient).quotient;
+            return sdk_core_1.CurrencyAmount.fromRawAmount(amountIn.currency, slippageAdjustedAmountIn);
+        }
+    };
+    Object.defineProperty(PreviewTrade.prototype, "inputTax", {
+        /**
+         * Returns the sell tax of the input token
+         */
+        get: function () {
+            var inputCurrency = this.inputAmount.currency;
+            if (inputCurrency.isNative || !inputCurrency.wrapped.sellFeeBps)
+                return misc_1.ZERO_PERCENT;
+            return new sdk_core_1.Percent(inputCurrency.wrapped.sellFeeBps.toNumber(), 10000);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(PreviewTrade.prototype, "outputTax", {
+        /**
+         * Returns the buy tax of the output token
+         */
+        get: function () {
+            var outputCurrency = this.outputAmount.currency;
+            if (outputCurrency.isNative || !outputCurrency.wrapped.buyFeeBps)
+                return misc_1.ZERO_PERCENT;
+            return new sdk_core_1.Percent(outputCurrency.wrapped.buyFeeBps.toNumber(), 10000);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(PreviewTrade.prototype, "executionPrice", {
+        /**
+         * The price expressed in terms of output amount/input amount.
+         */
+        get: function () {
+            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)));
+        },
+        enumerable: false,
+        configurable: true
+    });
+    PreviewTrade.prototype.worstExecutionPrice = function (slippageTolerance) {
+        return new sdk_core_1.Price(this.inputAmount.currency, this.outputAmount.currency, this.maximumAmountIn(slippageTolerance).quotient, this.minimumAmountOut(slippageTolerance).quotient);
+    };
+    return PreviewTrade;
+}());
+exports.PreviewTrade = PreviewTrade;
+// TODO(limits): get this from uniswapx-sdk
+var UNISWAPX_REACTOR = '0x6000da47483062a0d734ba3dc7576ce6a0b645c4';
+var LimitOrderTrade = /** @class */ (function () {
+    function LimitOrderTrade(_a) {
+        var tradeType = _a.tradeType, amountIn = _a.amountIn, amountOut = _a.amountOut, deadlineBufferSecs = _a.deadlineBufferSecs, swapFee = _a.swapFee, wrapInfo = _a.wrapInfo, approveInfo = _a.approveInfo, swapper = _a.swapper;
+        this.fillType = TradeFillType.UniswapX;
+        this.offchainOrderType = OffchainOrderType.LIMIT_ORDER;
+        // Placeholder values that aren't used in a limit trade
+        this.inputTax = misc_1.ZERO_PERCENT;
+        this.outputTax = misc_1.ZERO_PERCENT;
+        this.slippageTolerance = misc_1.ZERO_PERCENT;
+        this.quoteId = undefined;
+        this.requestId = undefined;
+        this.deadlineBufferSecs = deadlineBufferSecs;
+        this.swapFee = swapFee;
+        this.wrapInfo = wrapInfo;
+        this.approveInfo = approveInfo;
+        this.amountIn = amountIn;
+        this.amountOut = amountOut;
+        this.tradeType = tradeType;
+        this.swapper = swapper;
+        // deadline is shown in the review modal, but updated on submission
+        var nowSecs = Math.floor(Date.now() / 1000);
+        this.deadline = (nowSecs + deadlineBufferSecs) * 1000;
+    }
+    LimitOrderTrade.prototype.asDutchOrderTrade = function (options) {
+        var _a, _b, _c;
+        var swapperOutput = {
+            token: this.amountOut.currency.isNative ? constants_1.AddressZero : this.amountOut.currency.address,
+            recipient: (_a = options === null || options === void 0 ? void 0 : options.swapper) !== null && _a !== void 0 ? _a : this.swapper,
+            startAmount: ethers_1.BigNumber.from(this.amountOut.quotient.toString()),
+            endAmount: ethers_1.BigNumber.from(this.amountOut.quotient.toString()),
+        };
+        var swapFee = this.swapFee && {
+            token: this.amountOut.currency.isNative ? constants_1.AddressZero : this.amountOut.currency.address,
+            recipient: this.swapFee.recipient,
+            startAmount: ethers_1.BigNumber.from(this.amountOut.multiply(this.swapFee.percent).quotient.toString()),
+            endAmount: ethers_1.BigNumber.from(this.amountOut.multiply(this.swapFee.percent).quotient.toString()),
+        };
+        var outputs = swapFee ? [swapperOutput, swapFee] : [swapperOutput];
+        var nowSecs = Math.floor(Date.now() / 1000);
+        return new uniswapx_sdk_1.DutchOrderTrade({
+            currencyIn: this.amountIn.currency,
+            currenciesOut: [this.amountOut.currency],
+            orderInfo: {
+                reactor: UNISWAPX_REACTOR,
+                swapper: (_b = options === null || options === void 0 ? void 0 : options.swapper) !== null && _b !== void 0 ? _b : this.swapper,
+                deadline: (nowSecs + this.deadlineBufferSecs) * 1000,
+                additionalValidationContract: constants_1.AddressZero,
+                additionalValidationData: '0x',
+                nonce: (_c = options === null || options === void 0 ? void 0 : options.nonce) !== null && _c !== void 0 ? _c : ethers_1.BigNumber.from(0),
+                // decay timings dont matter at all
+                decayStartTime: nowSecs,
+                decayEndTime: nowSecs,
+                exclusiveFiller: constants_1.AddressZero,
+                exclusivityOverrideBps: ethers_1.BigNumber.from(0),
+                input: {
+                    token: this.amountIn.currency.isNative ? constants_1.AddressZero : this.amountIn.currency.address,
+                    startAmount: ethers_1.BigNumber.from(this.amountIn.quotient.toString()),
+                    endAmount: ethers_1.BigNumber.from(this.amountIn.quotient.toString()),
+                },
+                outputs: outputs,
+            },
+            tradeType: this.tradeType,
+        });
+    };
+    Object.defineProperty(LimitOrderTrade.prototype, "inputAmount", {
+        get: function () {
+            return this.amountIn;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(LimitOrderTrade.prototype, "outputAmount", {
+        get: function () {
+            return this.amountOut;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(LimitOrderTrade.prototype, "postTaxOutputAmount", {
+        /** For UniswapX, handling token taxes in the output amount is outsourced to quoters */
+        get: function () {
+            return this.outputAmount;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(LimitOrderTrade.prototype, "totalGasUseEstimateUSD", {
+        get: function () {
+            return this.wrapInfo.needsWrap ? this.wrapInfo.wrapGasEstimateUSD : 0;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(LimitOrderTrade.prototype, "classicGasUseEstimateUSD", {
+        get: function () {
+            return 0;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(LimitOrderTrade.prototype, "startTimeBufferSecs", {
+        // no decay for limit orders
+        get: function () {
+            return 0;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(LimitOrderTrade.prototype, "auctionPeriodSecs", {
+        // no decay auction for limit orders
+        get: function () {
+            return 0;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(LimitOrderTrade.prototype, "executionPrice", {
+        get: function () {
+            return new sdk_core_1.Price(this.amountIn.currency, this.amountOut.currency, this.amountIn.quotient, this.amountOut.quotient);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    LimitOrderTrade.prototype.worstExecutionPrice = function () {
+        return this.executionPrice;
+    };
+    LimitOrderTrade.prototype.maximumAmountIn = function () {
+        return this.inputAmount;
+    };
+    LimitOrderTrade.prototype.minimumAmountOut = function () {
+        return this.outputAmount;
+    };
+    return LimitOrderTrade;
+}());
+exports.LimitOrderTrade = LimitOrderTrade;
+var QuoteState;
+(function (QuoteState) {
+    QuoteState["SUCCESS"] = "Success";
+    QuoteState["NOT_FOUND"] = "Not found";
+})(QuoteState || (exports.QuoteState = QuoteState = {}));
+var PoolType;
+(function (PoolType) {
+    PoolType["V2Pool"] = "v2-pool";
+    PoolType["V3Pool"] = "v3-pool";
+})(PoolType || (exports.PoolType = PoolType = {}));
+// swap router API special cases these strings to represent native currencies
+// all chains except for bnb chain and polygon
+// have "ETH" as native currency symbol
+var SwapRouterNativeAssets;
+(function (SwapRouterNativeAssets) {
+    SwapRouterNativeAssets["MATIC"] = "MATIC";
+    SwapRouterNativeAssets["BNB"] = "BNB";
+    SwapRouterNativeAssets["AVAX"] = "AVAX";
+    SwapRouterNativeAssets["ETH"] = "ETH";
+})(SwapRouterNativeAssets || (exports.SwapRouterNativeAssets = SwapRouterNativeAssets = {}));
+var URAQuoteType;
+(function (URAQuoteType) {
+    URAQuoteType["CLASSIC"] = "CLASSIC";
+    URAQuoteType["DUTCH_LIMIT"] = "DUTCH_LIMIT";
+})(URAQuoteType || (exports.URAQuoteType = URAQuoteType = {}));

package/lib/routing/utils.d.ts

@@ -0,0 +1,28 @@
+import { MixedRouteSDK } from '@uniswap/router-sdk';
+import { Currency, CurrencyAmount, TradeType } from '@uniswap/sdk-core';
+import { Route as V2Route } from '@uniswap/v2-sdk';
+import { Route as V3Route } from '@uniswap/v3-sdk';
+import { ClassicQuoteData, ClassicTrade, DutchOrderTrade, GetQuickQuoteArgs, GetQuoteArgs, InterfaceTrade, LimitOrderTrade, PreviewTrade, QuickRouteResponse, QuoteMethod, SubmittableTrade, TradeResult, URAQuoteResponse } from './types';
+interface RouteResult {
+    routev3: V3Route<Currency, Currency> | null;
+    routev2: V2Route<Currency, Currency> | null;
+    mixedRoute: MixedRouteSDK<Currency, Currency> | null;
+    inputAmount: CurrencyAmount<Currency>;
+    outputAmount: CurrencyAmount<Currency>;
+}
+/**
+ * Transforms a Routing API quote into an array of routes that can be used to
+ * create a `Trade`.
+ */
+export declare function computeRoutes(args: GetQuoteArgs, routes: ClassicQuoteData['route']): RouteResult[] | undefined;
+export declare function transformQuickRouteToTrade(args: GetQuickQuoteArgs, data: QuickRouteResponse): PreviewTrade;
+export declare function getUSDCostPerGas(gasUseEstimateUSD?: number, gasUseEstimate?: number): number | undefined;
+export declare function transformQuoteToTrade(args: GetQuoteArgs, data: URAQuoteResponse, quoteMethod: QuoteMethod): Promise<TradeResult>;
+export declare function isExactInput(tradeType: TradeType): boolean;
+export declare function currencyAddressForSwapQuote(currency: Currency): string;
+export declare function isClassicTrade(trade?: InterfaceTrade): trade is ClassicTrade;
+export declare function isPreviewTrade(trade?: InterfaceTrade): trade is PreviewTrade;
+export declare function isSubmittableTrade(trade?: InterfaceTrade): trade is SubmittableTrade;
+export declare function isUniswapXTrade(trade?: InterfaceTrade): trade is DutchOrderTrade | LimitOrderTrade;
+export declare function isLimitTrade(trade?: InterfaceTrade): trade is LimitOrderTrade;
+export {};