@cronos-labs/rfq-sdk 0.2.3

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/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/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/index.d.ts

@@ -0,0 +1,18 @@
+import { DutchOrder } from "./DutchOrder";
+import { CosignedPriorityOrder, UnsignedPriorityOrder } from "./PriorityOrder";
+import { RelayOrder } from "./RelayOrder";
+import { CosignedV2DutchOrder, UnsignedV2DutchOrder } from "./V2DutchOrder";
+import { CosignedV3DutchOrder, UnsignedV3DutchOrder } from "./V3DutchOrder";
+import { CosignedHybridOrder, UnsignedHybridOrder } from "./v4/HybridOrder";
+export * from "./DutchOrder";
+export * from "./PriorityOrder";
+export * from "./RelayOrder";
+export * from "./types";
+export * from "./validation";
+export * from "./V2DutchOrder";
+export * from "./V3DutchOrder";
+export type { OrderInfoV4, HybridInput, HybridOutput, HybridCosignerData, UnsignedHybridOrderInfo, CosignedHybridOrderInfo, UnsignedHybridOrderInfoJSON, CosignedHybridOrderInfoJSON, HybridCosignerDataJSON, OrderInfoV4JSON, HybridInputJSON, HybridOutputJSON, InputToken, OutputToken, ResolvedOrder, HybridOrderResolutionOptions, BlockOverridesV4, DCAIntent, DCAOrderCosignerData, DCAExecutionState, DCAIntentJSON, PrivateIntent, OutputAllocation, FeedInfo, PermitData, } from "./v4/types";
+export * from "./v4/HybridOrder";
+export * from "./v4/hashing";
+export type UniswapXOrder = DutchOrder | UnsignedV2DutchOrder | CosignedV2DutchOrder | UnsignedV3DutchOrder | CosignedV3DutchOrder | UnsignedPriorityOrder | CosignedPriorityOrder | UnsignedHybridOrder | CosignedHybridOrder;
+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/v4/HybridOrder.d.ts

@@ -0,0 +1,83 @@
+import { SignatureLike } from "@ethersproject/bytes";
+import { PermitTransferFrom, PermitTransferFromData, Witness } from "@uniswap/permit2-sdk";
+import { BigNumber } from "ethers";
+import { ResolvedUniswapXOrder } from "../../utils/OrderQuoter";
+import { BlockOverridesV4, CosignedHybridOrderInfo, CosignedHybridOrderInfoJSON, HybridCosignerData, HybridOrderResolutionOptions, UnsignedHybridOrderInfo, UnsignedHybridOrderInfoJSON } from "./types";
+export declare class OrderResolutionError extends Error {
+    constructor(message: string);
+}
+export declare class HybridOrderPriceCurveError extends Error {
+    constructor(message: string);
+}
+export declare class HybridOrderCosignatureError extends Error {
+    constructor(message: string);
+}
+/**
+ * Unsigned HybridOrder - base class without cosigner data
+ */
+export declare class UnsignedHybridOrder {
+    readonly info: UnsignedHybridOrderInfo;
+    readonly chainId: number;
+    readonly resolver: string;
+    readonly permit2Address: string;
+    constructor(info: UnsignedHybridOrderInfo, chainId: number, resolver: string, _permit2Address?: string);
+    /**
+     * Parse a serialized HybridOrder into an UnsignedHybridOrder
+     */
+    static parse(encoded: string, chainId: number, permit2?: string): UnsignedHybridOrder;
+    static fromJSON(json: UnsignedHybridOrderInfoJSON, chainId: number, resolver: string, _permit2Address?: string): UnsignedHybridOrder;
+    /**
+     * Encode a price curve element from duration and scaling factor
+     */
+    static encodePriceCurveElement(duration: number, scalingFactor: BigNumber): BigNumber;
+    /**
+     * Decode a price curve element into duration and scaling factor
+     */
+    static decodePriceCurveElement(value: BigNumber): {
+        duration: number;
+        scalingFactor: BigNumber;
+    };
+    hash(): string;
+    serialize(): string;
+    permitData(): PermitTransferFromData;
+    getSigner(signature: SignatureLike): string;
+    protected toPermit(): PermitTransferFrom;
+    protected witness(): Witness;
+    get blockOverrides(): BlockOverridesV4;
+    resolve(_options: HybridOrderResolutionOptions): ResolvedUniswapXOrder;
+    cosignatureHash(cosignerData: HybridCosignerData): string;
+    toJSON(): UnsignedHybridOrderInfoJSON & {
+        chainId: number;
+        resolver: string;
+        permit2Address: string;
+    };
+}
+/**
+ * Cosigned HybridOrder - includes cosigner data and signature
+ */
+export declare class CosignedHybridOrder extends UnsignedHybridOrder {
+    readonly info: CosignedHybridOrderInfo;
+    readonly chainId: number;
+    readonly resolver: string;
+    constructor(info: CosignedHybridOrderInfo, chainId: number, resolver: string, _permit2Address?: string);
+    /**
+     * Parse a serialized HybridOrder into a CosignedHybridOrder
+     */
+    static parse(encoded: string, chainId: number, permit2?: string): CosignedHybridOrder;
+    /**
+     * Create a CosignedHybridOrder from an UnsignedHybridOrder
+     */
+    static fromUnsignedOrder(order: UnsignedHybridOrder, cosignerData: HybridCosignerData, cosignature: string): CosignedHybridOrder;
+    static fromJSON(json: CosignedHybridOrderInfoJSON, chainId: number, resolver: string, _permit2Address?: string): CosignedHybridOrder;
+    hash(): string;
+    serialize(): string;
+    get blockOverrides(): BlockOverridesV4;
+    resolve(options: HybridOrderResolutionOptions): ResolvedUniswapXOrder;
+    toJSON(): CosignedHybridOrderInfoJSON & {
+        chainId: number;
+        resolver: string;
+        permit2Address: string;
+    };
+    cosignatureHash(): string;
+    recoverCosigner(): string;
+}

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

@@ -0,0 +1,87 @@
+import { CosignedHybridOrderInfo, DCAIntent, DCAOrderCosignerData, HybridCosignerData, OrderInfoV4, PrivateIntent } from "./types";
+/**
+ * EIP-712 type string for OrderInfoV4
+ */
+export declare const ORDER_INFO_V4_TYPE_STRING: string;
+/**
+ * EIP-712 type hash for OrderInfoV4
+ */
+export declare const ORDER_INFO_V4_TYPE_HASH: string;
+/**
+ * EIP-712 witness types for HybridOrder (for Permit2 signature)
+ * NOTE: Types must be in alphabetical order for EIP-712 spec compliance
+ */
+export declare const HYBRID_ORDER_TYPES: {
+    HybridInput: {
+        name: string;
+        type: string;
+    }[];
+    HybridOrder: {
+        name: string;
+        type: string;
+    }[];
+    HybridOutput: {
+        name: string;
+        type: string;
+    }[];
+    OrderInfo: {
+        name: string;
+        type: string;
+    }[];
+};
+/**
+ * Hash OrderInfoV4 structure
+ * @param info The OrderInfoV4 to hash
+ * @returns The keccak256 hash
+ */
+export declare function hashOrderInfoV4(info: OrderInfoV4): string;
+export declare function hashHybridOrder(order: CosignedHybridOrderInfo): string;
+/**
+ * Compute cosigner digest (orderHash || chainId || cosignerData encoding)
+ */
+export declare function hashHybridCosignerData(orderHash: string, cosignerData: HybridCosignerData, chainId: number): string;
+/**
+ * Hash PrivateIntent structure
+ * @param privateIntent The PrivateIntent to hash
+ * @returns The keccak256 hash
+ */
+export declare function hashPrivateIntent(privateIntent: PrivateIntent): string;
+/**
+ * Hash DCAIntent structure
+ * Note: Intent should have privateIntent zeroed out for signing, with separate privateIntentHash
+ * @param intent The DCAIntent to hash (with zeroed privateIntent)
+ * @param privateIntentHash The hash of the PrivateIntent
+ * @returns The keccak256 hash
+ */
+export declare function hashDCAIntent(intent: DCAIntent, privateIntentHash: string): string;
+/**
+ * EIP-712 type hash for DCAOrderCosignerData
+ */
+export declare const DCA_COSIGNER_DATA_TYPE_HASH: string;
+/**
+ * Hash DCAOrderCosignerData structure
+ * @param cosignerData The DCAOrderCosignerData to hash
+ * @returns The keccak256 hash
+ */
+export declare function hashDCACosignerData(cosignerData: DCAOrderCosignerData): string;
+/**
+ * EIP-712 type definitions for DCAIntent
+ */
+export declare const DCA_INTENT_TYPES: {
+    DCAIntent: {
+        name: string;
+        type: string;
+    }[];
+    OutputAllocation: {
+        name: string;
+        type: string;
+    }[];
+    PrivateIntent: {
+        name: string;
+        type: string;
+    }[];
+    FeedInfo: {
+        name: string;
+        type: string;
+    }[];
+};

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

@@ -0,0 +1,3 @@
+export * from "./types";
+export * from "./hashing";
+export * from "./HybridOrder";