@juiceswapxyz/uniswapx-sdk 3.0.0 → 3.0.1

package/dist/types/src/order/RelayOrder.d.ts

@@ -0,0 +1,75 @@
+import { SignatureLike } from "@ethersproject/bytes";
+import { PermitBatchTransferFromData } from "@uniswap/permit2-sdk";
+import { BigNumber } from "ethers";
+import { ResolvedRelayOrder } from "../utils/OrderQuoter";
+import { BlockOverrides, OffChainOrder, OrderInfo, OrderResolutionOptions } from "./types";
+export type RelayInput = {
+    readonly token: string;
+    readonly amount: BigNumber;
+    readonly recipient: string;
+};
+export type RelayFee = {
+    readonly token: string;
+    readonly startAmount: BigNumber;
+    readonly endAmount: BigNumber;
+    readonly startTime: number;
+    readonly endTime: number;
+};
+export type RelayInputJSON = Omit<RelayInput, "amount"> & {
+    amount: string;
+};
+export type RelayFeeJSON = Omit<RelayFee, "startAmount" | "endAmount"> & {
+    startAmount: string;
+    endAmount: string;
+};
+type RelayOrderNestedOrderInfo = Omit<OrderInfo, "additionalValidationContract" | "additionalValidationData">;
+export type RelayOrderInfo = RelayOrderNestedOrderInfo & {
+    input: RelayInput;
+    fee: RelayFee;
+    universalRouterCalldata: string;
+};
+export type RelayOrderInfoJSON = Omit<RelayOrderInfo, "nonce" | "input" | "fee"> & {
+    nonce: string;
+    input: RelayInputJSON;
+    fee: RelayFeeJSON;
+    universalRouterCalldata: string;
+};
+export declare class RelayOrder implements OffChainOrder {
+    readonly info: RelayOrderInfo;
+    readonly chainId: number;
+    readonly _permit2Address?: string | undefined;
+    permit2Address: string;
+    constructor(info: RelayOrderInfo, chainId: number, _permit2Address?: string | undefined);
+    static fromJSON(json: RelayOrderInfoJSON, chainId: number, _permit2Address?: string): RelayOrder;
+    static parse(encoded: string, chainId: number, permit2?: string): RelayOrder;
+    toJSON(): RelayOrderInfoJSON & {
+        permit2Address: string;
+        chainId: number;
+    };
+    /**
+     * @inheritdoc order
+     */
+    get blockOverrides(): BlockOverrides;
+    serialize(): string;
+    /**
+     * @inheritdoc Order
+     */
+    getSigner(signature: SignatureLike): string;
+    /**
+     * @inheritdoc OrderInterface
+     */
+    permitData(): PermitBatchTransferFromData;
+    /**
+     * @inheritdoc OrderInterface
+     */
+    hash(): string;
+    /**
+     * Returns the resolved order with the given options
+     * @return The resolved order
+     */
+    resolve(options: OrderResolutionOptions): ResolvedRelayOrder;
+    private toPermit;
+    private witnessInfo;
+    private witness;
+}
+export {};

package/dist/types/src/order/RelayOrder.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/src/order/V2DutchOrder.d.ts

@@ -0,0 +1,103 @@
+import { SignatureLike } from "@ethersproject/bytes";
+import { PermitTransferFromData } from "@uniswap/permit2-sdk";
+import { ResolvedUniswapXOrder } from "../utils/OrderQuoter";
+import { BlockOverrides, CosignerData, CosignerDataJSON, DutchInput, DutchInputJSON, DutchOutput, DutchOutputJSON, OffChainOrder, OrderInfo, OrderResolutionOptions } from "./types";
+import { CustomOrderValidation } from "./validation";
+export type UnsignedV2DutchOrderInfo = OrderInfo & {
+    cosigner: string;
+    input: DutchInput;
+    outputs: DutchOutput[];
+};
+export type CosignedV2DutchOrderInfo = UnsignedV2DutchOrderInfo & {
+    cosignerData: CosignerData;
+    cosignature: string;
+};
+export type UnsignedV2DutchOrderInfoJSON = Omit<UnsignedV2DutchOrderInfo, "nonce" | "input" | "outputs" | "cosignerData"> & {
+    nonce: string;
+    input: DutchInputJSON;
+    outputs: DutchOutputJSON[];
+};
+export type CosignedV2DutchOrderInfoJSON = UnsignedV2DutchOrderInfoJSON & {
+    cosignerData: CosignerDataJSON;
+    cosignature: string;
+};
+export declare class UnsignedV2DutchOrder implements OffChainOrder {
+    readonly info: UnsignedV2DutchOrderInfo;
+    readonly chainId: number;
+    permit2Address: string;
+    constructor(info: UnsignedV2DutchOrderInfo, chainId: number, _permit2Address?: string);
+    static fromJSON(json: UnsignedV2DutchOrderInfoJSON, chainId: number, _permit2Address?: string): UnsignedV2DutchOrder;
+    static parse(encoded: string, chainId: number, permit2?: string): UnsignedV2DutchOrder;
+    /**
+     * @inheritdoc order
+     */
+    toJSON(): UnsignedV2DutchOrderInfoJSON & {
+        permit2Address: string;
+        chainId: number;
+    };
+    /**
+     * @inheritdoc order
+     */
+    get blockOverrides(): BlockOverrides;
+    /**
+     * @inheritdoc order
+     */
+    serialize(): string;
+    /**
+     * @inheritdoc Order
+     */
+    getSigner(signature: SignatureLike): string;
+    /**
+     * @inheritdoc Order
+     */
+    permitData(): PermitTransferFromData;
+    /**
+     * @inheritdoc Order
+     */
+    hash(): string;
+    /**
+     * Returns the resolved order with the given options
+     * @return The resolved order
+     */
+    resolve(_options: OrderResolutionOptions): ResolvedUniswapXOrder;
+    /**
+     * Returns the parsed validation
+     * @return The parsed validation data for the order
+     */
+    get validation(): CustomOrderValidation;
+    private toPermit;
+    private witnessInfo;
+    private witness;
+    /**
+     * Full order hash that should be signed over by the cosigner
+     */
+    cosignatureHash(cosignerData: CosignerData): string;
+}
+export declare class CosignedV2DutchOrder extends UnsignedV2DutchOrder {
+    readonly info: CosignedV2DutchOrderInfo;
+    readonly chainId: number;
+    static fromUnsignedOrder(order: UnsignedV2DutchOrder, cosignerData: CosignerData, cosignature: string): CosignedV2DutchOrder;
+    static fromJSON(json: CosignedV2DutchOrderInfoJSON, chainId: number, _permit2Address?: string): CosignedV2DutchOrder;
+    static parse(encoded: string, chainId: number, permit2?: string): CosignedV2DutchOrder;
+    constructor(info: CosignedV2DutchOrderInfo, chainId: number, _permit2Address?: string);
+    /**
+     * @inheritdoc order
+     */
+    toJSON(): CosignedV2DutchOrderInfoJSON & {
+        permit2Address: string;
+        chainId: number;
+    };
+    /**
+     * @inheritdoc Order
+     */
+    resolve(options: OrderResolutionOptions): ResolvedUniswapXOrder;
+    /**
+     * @inheritdoc order
+     */
+    serialize(): string;
+    /**
+     *  recovers co-signer address from cosignature and full order hash
+     *  @returns The address which co-signed the order
+     */
+    recoverCosigner(): string;
+}

package/dist/types/src/order/V2DutchOrder.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/src/order/V3DutchOrder.d.ts

@@ -0,0 +1,105 @@
+import { SignatureLike } from "@ethersproject/bytes";
+import { PermitTransferFromData } from "@uniswap/permit2-sdk";
+import { BigNumber } from "ethers";
+import { ResolvedUniswapXOrder } from "../utils";
+import { BlockOverrides, CosignerData, CosignerDataJSON, OffChainOrder, OrderInfo, V3DutchInput, V3DutchInputJSON, V3DutchOutput, V3DutchOutputJSON, V3OrderResolutionOptions } from "./types";
+export type V3CosignerDataJSON = Omit<CosignerDataJSON, "decayStartTime" | "decayEndTime"> & {
+    decayStartBlock: number;
+};
+export type V3CosignerData = Omit<CosignerData, "decayStartTime" | "decayEndTime"> & {
+    decayStartBlock: number;
+};
+export type UnsignedV3DutchOrderInfoJSON = Omit<UnsignedV3DutchOrderInfo, "nonce" | "startingBaseFee" | "input" | "outputs" | "cosignerData"> & {
+    nonce: string;
+    startingBaseFee: string;
+    input: V3DutchInputJSON;
+    outputs: V3DutchOutputJSON[];
+};
+export type UnsignedV3DutchOrderInfo = OrderInfo & {
+    cosigner: string;
+    startingBaseFee: BigNumber;
+    input: V3DutchInput;
+    outputs: V3DutchOutput[];
+};
+export type CosignedV3DutchOrderInfoJSON = UnsignedV3DutchOrderInfoJSON & {
+    cosignerData: V3CosignerDataJSON;
+    cosignature: string;
+};
+export type CosignedV3DutchOrderInfo = UnsignedV3DutchOrderInfo & {
+    cosignerData: V3CosignerData;
+    cosignature: string;
+};
+export declare const V3_DUTCH_ORDER_TYPES: {
+    V3DutchOrder: {
+        name: string;
+        type: string;
+    }[];
+    OrderInfo: {
+        name: string;
+        type: string;
+    }[];
+    V3DutchInput: {
+        name: string;
+        type: string;
+    }[];
+    V3DutchOutput: {
+        name: string;
+        type: string;
+    }[];
+    NonlinearDutchDecay: {
+        name: string;
+        type: string;
+    }[];
+};
+export declare class UnsignedV3DutchOrder implements OffChainOrder {
+    readonly info: UnsignedV3DutchOrderInfo;
+    readonly chainId: number;
+    permit2Address: string;
+    constructor(info: UnsignedV3DutchOrderInfo, chainId: number, _permit2Address?: string);
+    static fromJSON(json: UnsignedV3DutchOrderInfoJSON, chainId: number, _permit2Address?: string): UnsignedV3DutchOrder;
+    /**
+     * @inheritdoc order
+     */
+    get blockOverrides(): BlockOverrides;
+    /**
+     * @inheritdoc order
+     */
+    serialize(): string;
+    /**
+     * @inheritdoc order
+     */
+    toJSON(): UnsignedV3DutchOrderInfoJSON & {
+        permit2Address: string;
+        chainId: number;
+    };
+    permitData(): PermitTransferFromData;
+    private toPermit;
+    private witnessInfo;
+    private witness;
+    getSigner(signature: SignatureLike): string;
+    hash(): string;
+    /**
+     * Full order hash that should be signed over by the cosigner
+     */
+    cosignatureHash(cosignerData: V3CosignerData): string;
+    static parse(encoded: string, chainId: number, permit2?: string): UnsignedV3DutchOrder;
+}
+export declare class CosignedV3DutchOrder extends UnsignedV3DutchOrder {
+    readonly info: CosignedV3DutchOrderInfo;
+    readonly chainId: number;
+    static fromUnsignedOrder(order: UnsignedV3DutchOrder, cosignerData: V3CosignerData, cosignature: string): CosignedV3DutchOrder;
+    static fromJSON(json: CosignedV3DutchOrderInfoJSON, chainId: number, _permit2Address?: string): CosignedV3DutchOrder;
+    constructor(info: CosignedV3DutchOrderInfo, chainId: number, _permit2Address?: string);
+    /**
+     * @inheritdoc order
+     */
+    toJSON(): CosignedV3DutchOrderInfoJSON & {
+        permit2Address: string;
+        chainId: number;
+    };
+    static parse(encoded: string, chainId: number, permit2?: string): CosignedV3DutchOrder;
+    serialize(): string;
+    recoverCosigner(): string;
+    resolve(options: V3OrderResolutionOptions): ResolvedUniswapXOrder;
+}
+export declare function encodeRelativeBlocks(relativeBlocks: number[]): BigNumber;

package/dist/types/src/order/V3DutchOrder.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/src/order/index.d.ts

@@ -0,0 +1,14 @@
+import { DutchOrder } from "./DutchOrder";
+import { CosignedPriorityOrder, UnsignedPriorityOrder } from "./PriorityOrder";
+import { RelayOrder } from "./RelayOrder";
+import { CosignedV2DutchOrder, UnsignedV2DutchOrder } from "./V2DutchOrder";
+import { CosignedV3DutchOrder, UnsignedV3DutchOrder } from "./V3DutchOrder";
+export * from "./DutchOrder";
+export * from "./PriorityOrder";
+export * from "./RelayOrder";
+export * from "./types";
+export * from "./validation";
+export * from "./V2DutchOrder";
+export * from "./V3DutchOrder";
+export type UniswapXOrder = DutchOrder | UnsignedV2DutchOrder | CosignedV2DutchOrder | UnsignedV3DutchOrder | CosignedV3DutchOrder | UnsignedPriorityOrder | CosignedPriorityOrder;
+export type Order = UniswapXOrder | RelayOrder;

package/dist/types/src/order/types.d.ts

@@ -0,0 +1,158 @@
+import { SignatureLike } from "@ethersproject/bytes";
+import { PermitBatchTransferFromData, PermitTransferFromData } from "@uniswap/permit2-sdk";
+import { BigNumber } from "ethers";
+export type BlockOverrides = {
+    number?: string;
+} | undefined;
+export interface OffChainOrder {
+    chainId: number;
+    /**
+     * Returns the abi encoded order
+     * @return The abi encoded serialized order which can be submitted on-chain
+     */
+    serialize(): string;
+    /**
+     * Recovers the given signature, returning the address which created it
+     *  * @param signature The signature to recover
+     *  * @returns address The address which created the signature
+     */
+    getSigner(signature: SignatureLike): string;
+    /**
+     * Returns the data for generating the maker EIP-712 permit signature
+     * @return The data for generating the maker EIP-712 permit signature
+     */
+    permitData(): PermitTransferFromData | PermitBatchTransferFromData;
+    /**
+     * Returns the order hash
+     * @return The order hash which is used as a key on-chain
+     */
+    hash(): string;
+    /**
+     * Returns any block overrides to be applied when quoting the order on chain
+     * @return The block overrides
+     */
+    get blockOverrides(): BlockOverrides;
+}
+export type TokenAmount = {
+    readonly token: string;
+    readonly amount: BigNumber;
+};
+export type ResolvedRelayFee = {
+    readonly token: string;
+    readonly amount: BigNumber;
+};
+export type OrderInfo = {
+    reactor: string;
+    swapper: string;
+    nonce: BigNumber;
+    deadline: number;
+    additionalValidationContract: string;
+    additionalValidationData: string;
+};
+export type OrderResolutionOptions = {
+    timestamp: number;
+    filler?: string;
+};
+export type PriorityOrderResolutionOptions = {
+    priorityFee: BigNumber;
+    currentBlock?: BigNumber;
+};
+export type V3OrderResolutionOptions = {
+    currentBlock: number;
+    filler?: string;
+};
+export type DutchOutput = {
+    readonly token: string;
+    readonly startAmount: BigNumber;
+    readonly endAmount: BigNumber;
+    readonly recipient: string;
+};
+export type DutchOutputJSON = Omit<DutchOutput, "startAmount" | "endAmount"> & {
+    startAmount: string;
+    endAmount: string;
+};
+export type DutchInput = {
+    readonly token: string;
+    readonly startAmount: BigNumber;
+    readonly endAmount: BigNumber;
+};
+export type DutchInputJSON = Omit<DutchInput, "startAmount" | "endAmount"> & {
+    startAmount: string;
+    endAmount: string;
+};
+export type CosignerData = {
+    decayStartTime: number;
+    decayEndTime: number;
+    exclusiveFiller: string;
+    exclusivityOverrideBps: BigNumber;
+    inputOverride: BigNumber;
+    outputOverrides: BigNumber[];
+};
+export type CosignerDataJSON = {
+    decayStartTime: number;
+    decayEndTime: number;
+    exclusiveFiller: string;
+    exclusivityOverrideBps: number;
+    inputOverride: string;
+    outputOverrides: string[];
+};
+export type PriorityInput = {
+    readonly token: string;
+    readonly amount: BigNumber;
+    readonly mpsPerPriorityFeeWei: BigNumber;
+};
+export type PriorityOutput = PriorityInput & {
+    readonly recipient: string;
+};
+export type PriorityInputJSON = Omit<PriorityInput, "amount" | "mpsPerPriorityFeeWei"> & {
+    amount: string;
+    mpsPerPriorityFeeWei: string;
+};
+export type PriorityOutputJSON = PriorityInputJSON & {
+    recipient: string;
+};
+export type V3DutchInput = {
+    readonly token: string;
+    readonly startAmount: BigNumber;
+    readonly curve: NonlinearDutchDecay;
+    readonly maxAmount: BigNumber;
+    readonly adjustmentPerGweiBaseFee: BigNumber;
+};
+export type V3DutchInputJSON = Omit<V3DutchInput, "startAmount" | "curve" | "maxAmount" | "adjustmentPerGweiBaseFee"> & {
+    startAmount: string;
+    curve: NonlinearDutchDecayJSON;
+    maxAmount: string;
+    adjustmentPerGweiBaseFee: string;
+};
+export type NonlinearDutchDecay = {
+    relativeBlocks: number[];
+    relativeAmounts: bigint[];
+};
+export type EncodedNonlinearDutchDecay = {
+    relativeBlocks: BigNumber;
+    relativeAmounts: string[];
+};
+export type EncodedV3DutchInput = Omit<V3DutchInput, "curve"> & {
+    curve: EncodedNonlinearDutchDecay;
+};
+export type EncodedV3DutchOutput = Omit<V3DutchOutput, "curve"> & {
+    curve: EncodedNonlinearDutchDecay;
+};
+export type NonlinearDutchDecayJSON = {
+    relativeBlocks: number[];
+    relativeAmounts: string[];
+};
+export type V3DutchOutput = {
+    readonly token: string;
+    readonly startAmount: BigNumber;
+    readonly curve: NonlinearDutchDecay;
+    readonly recipient: string;
+    readonly minAmount: BigNumber;
+    readonly adjustmentPerGweiBaseFee: BigNumber;
+};
+export type V3DutchOutputJSON = Omit<V3DutchOutput, "startAmount" | "curve" | "minAmount" | "adjustmentPerGweiBaseFee"> & {
+    startAmount: string;
+    curve: NonlinearDutchDecayJSON;
+    minAmount: string;
+    adjustmentPerGweiBaseFee: string;
+};

package/dist/types/src/order/validation.d.ts

@@ -0,0 +1,24 @@
+import { OrderInfo } from "./types";
+export declare enum ValidationType {
+    None = 0,
+    ExclusiveFiller = 1
+}
+type ExclusiveFillerData = {
+    filler: string;
+    lastExclusiveTimestamp: number;
+};
+export type ValidationInfo = {
+    additionalValidationContract: string;
+    additionalValidationData: string;
+};
+export type CustomOrderValidation = {
+    type: ValidationType.None;
+    data: null;
+} | {
+    type: ValidationType.ExclusiveFiller;
+    data: ExclusiveFillerData;
+};
+export declare function parseValidation(info: OrderInfo): CustomOrderValidation;
+export declare function parseExclusiveFillerData(encoded: string): CustomOrderValidation;
+export declare function encodeExclusiveFillerData(fillerAddress: string, lastExclusiveTimestamp: number, chainId?: number, additionalValidationContractAddress?: string): ValidationInfo;
+export {};

package/dist/types/src/order/validation.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/src/trade/DutchOrderTrade.d.ts

@@ -0,0 +1,33 @@
+import { Currency, CurrencyAmount, Price, TradeType } from "@juiceswapxyz/sdk-core";
+import { DutchOrder, DutchOrderInfo } from "../order";
+export declare class DutchOrderTrade<TInput extends Currency, TOutput extends Currency, TTradeType extends TradeType> {
+    readonly tradeType: TTradeType;
+    readonly order: DutchOrder;
+    private _inputAmount;
+    private _outputAmounts;
+    private _currencyIn;
+    private _currenciesOut;
+    constructor({ currencyIn, currenciesOut, orderInfo, tradeType, }: {
+        currencyIn: TInput;
+        currenciesOut: TOutput[];
+        orderInfo: DutchOrderInfo;
+        tradeType: TTradeType;
+    });
+    get inputAmount(): CurrencyAmount<TInput>;
+    get outputAmounts(): CurrencyAmount<TOutput>[];
+    private _firstNonFeeOutputStartEndAmounts;
+    private getFirstNonFeeOutputStartEndAmounts;
+    get outputAmount(): CurrencyAmount<TOutput>;
+    minimumAmountOut(): CurrencyAmount<TOutput>;
+    maximumAmountIn(): CurrencyAmount<TInput>;
+    private _executionPrice;
+    /**
+     * The price expressed in terms of output amount/input amount.
+     */
+    get executionPrice(): Price<TInput, TOutput>;
+    /**
+     * Return the execution price after accounting for slippage tolerance
+     * @returns The execution price
+     */
+    worstExecutionPrice(): Price<TInput, TOutput>;
+}

package/dist/types/src/trade/DutchOrderTrade.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/src/trade/PriorityOrderTrade.d.ts

@@ -0,0 +1,43 @@
+import { Currency, CurrencyAmount, Price, TradeType } from "@juiceswapxyz/sdk-core";
+import { UnsignedPriorityOrder, UnsignedPriorityOrderInfo } from "../order";
+export declare class PriorityOrderTrade<TInput extends Currency, TOutput extends Currency, TTradeType extends TradeType> {
+    readonly tradeType: TTradeType;
+    readonly order: UnsignedPriorityOrder;
+    readonly expectedAmounts: {
+        expectedAmountIn: string;
+        expectedAmountOut: string;
+    } | undefined;
+    private _inputAmount;
+    private _outputAmounts;
+    private _currencyIn;
+    private _currenciesOut;
+    constructor({ currencyIn, currenciesOut, orderInfo, tradeType, expectedAmounts, }: {
+        currencyIn: TInput;
+        currenciesOut: TOutput[];
+        orderInfo: UnsignedPriorityOrderInfo;
+        tradeType: TTradeType;
+        expectedAmounts?: {
+            expectedAmountIn: string;
+            expectedAmountOut: string;
+        };
+    });
+    get inputAmount(): CurrencyAmount<TInput>;
+    get outputAmounts(): CurrencyAmount<TOutput>[];
+    private _firstNonFeeOutputAmount;
+    private getFirstNonFeeOutputAmount;
+    get outputAmount(): CurrencyAmount<TOutput>;
+    minimumAmountOut(): CurrencyAmount<TOutput>;
+    maximumAmountIn(): CurrencyAmount<TInput>;
+    private _executionPrice;
+    /**
+     * The price expressed in terms of output amount/input amount.
+     */
+    get executionPrice(): Price<TInput, TOutput>;
+    /**
+     * Return the execution price after accounting for slippage tolerance
+     * @returns The execution price
+     */
+    worstExecutionPrice(): Price<TInput, TOutput>;
+    private getExpectedAmountIn;
+    private getExpectedAmountOut;
+}

package/dist/types/src/trade/PriorityOrderTrade.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/src/trade/RelayOrderTrade.d.ts

@@ -0,0 +1,34 @@
+import { Currency, CurrencyAmount, Price, TradeType } from "@juiceswapxyz/sdk-core";
+import { RelayOrder, RelayOrderInfo } from "../order";
+export declare class RelayOrderTrade<TInput extends Currency, TOutput extends Currency, TTradeType extends TradeType> {
+    readonly tradeType: TTradeType;
+    readonly order: RelayOrder;
+    private _outputAmount;
+    private _currenciesIn;
+    constructor({ currenciesIn, outputAmount, orderInfo, tradeType, }: {
+        currenciesIn: TInput[];
+        outputAmount: CurrencyAmount<TOutput>;
+        orderInfo: RelayOrderInfo;
+        tradeType: TTradeType;
+    });
+    get outputAmount(): CurrencyAmount<TOutput>;
+    private _feeStartEndAmounts;
+    private _inputAmount;
+    private getFeeInputStartEndAmounts;
+    private getInputAmount;
+    get amountIn(): CurrencyAmount<TInput>;
+    get amountInFee(): CurrencyAmount<TInput>;
+    get maximumAmountInFee(): CurrencyAmount<TInput>;
+    private _executionPrice;
+    /**
+     * The price expressed in terms of output amount/input amount.
+     * @dev this only takes into account non fee inputs (does not include gas)
+     */
+    get executionPrice(): Price<TInput, TOutput>;
+    /**
+     * Return the execution price after accounting for slippage tolerance
+     * @dev this only takes into account non fee inputs (does not include gas)
+     * @returns The execution price
+     */
+    worstExecutionPrice(): Price<TInput, TOutput>;
+}

package/dist/types/src/trade/RelayOrderTrade.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/src/trade/V2DutchOrderTrade.d.ts

@@ -0,0 +1,33 @@
+import { Currency, CurrencyAmount, Price, TradeType } from "@juiceswapxyz/sdk-core";
+import { UnsignedV2DutchOrder, UnsignedV2DutchOrderInfo } from "../order";
+export declare class V2DutchOrderTrade<TInput extends Currency, TOutput extends Currency, TTradeType extends TradeType> {
+    readonly tradeType: TTradeType;
+    readonly order: UnsignedV2DutchOrder;
+    private _inputAmount;
+    private _outputAmounts;
+    private _currencyIn;
+    private _currenciesOut;
+    constructor({ currencyIn, currenciesOut, orderInfo, tradeType, }: {
+        currencyIn: TInput;
+        currenciesOut: TOutput[];
+        orderInfo: UnsignedV2DutchOrderInfo;
+        tradeType: TTradeType;
+    });
+    get inputAmount(): CurrencyAmount<TInput>;
+    get outputAmounts(): CurrencyAmount<TOutput>[];
+    private _firstNonFeeOutputStartEndAmounts;
+    private getFirstNonFeeOutputStartEndAmounts;
+    get outputAmount(): CurrencyAmount<TOutput>;
+    minimumAmountOut(): CurrencyAmount<TOutput>;
+    maximumAmountIn(): CurrencyAmount<TInput>;
+    private _executionPrice;
+    /**
+     * The price expressed in terms of output amount/input amount.
+     */
+    get executionPrice(): Price<TInput, TOutput>;
+    /**
+     * Return the execution price after accounting for slippage tolerance
+     * @returns The execution price
+     */
+    worstExecutionPrice(): Price<TInput, TOutput>;
+}

package/dist/types/src/trade/V2DutchOrderTrade.test.d.ts

@@ -0,0 +1 @@
+export {};