@cowprotocol/cow-sdk 2.3.1 → 2.4.0-rc.0

package/dist/common/chains.d.ts

@@ -1,3 +1,7 @@
+/**
+ * Supported chains and their `chainId` for the SDK.
+ * @enum
+ */
 export declare enum SupportedChainId {
     MAINNET = 1,
     GOERLI = 5,

package/dist/common/configs.d.ts

@@ -1,6 +1,16 @@
 import { SupportedChainId } from './chains';
 import { BackoffOptions } from 'exponential-backoff';
 import { RateLimiterOpts } from 'limiter/dist/esm';
+/**
+ * IPFS configuration.
+ *
+ * For production use, consider using {@link Pinata: https://www.pinata.cloud/}
+ * @property {string} [uri] The URI of the IPFS node to use.
+ * @property {string} [writeUri] The URI of the IPFS node to use for writing.
+ * @property {string} [readUri] The URI of the IPFS node to use for reading.
+ * @property {string} [pinataApiKey] The API key to use for Pinata.
+ * @property {string} [pinataApiSecret] The API secret to use for Pinata.
+ */
 export interface IpfsConfig {
     uri?: string;
     writeUri?: string;
@@ -8,17 +18,55 @@ export interface IpfsConfig {
     pinataApiKey?: string;
     pinataApiSecret?: string;
 }
+/**
+ * @property {RateLimiterOpts} [limiterOpts] The options to use for the rate limiter.
+ * @property {BackoffOptions} [backoffOpts] The options to use for the backoff.
+ */
 export interface RequestOptions {
     limiterOpts?: RateLimiterOpts;
     backoffOpts?: BackoffOptions;
 }
+/**
+ * The environment to use for the Cow API.
+ */
 export type CowEnv = 'prod' | 'staging';
+/**
+ * Override some properties of the {@link ApiContext}.
+ */
 export type PartialApiContext = Partial<ApiContext>;
+/**
+ * @property {string} [1] The base URL for the mainnet API.
+ * @property {string} [5] The base URL for the Goerli testnet API.
+ * @property {string} [100] The base URL for the Gnosis Chain API.
+ */
 export type ApiBaseUrls = Record<SupportedChainId, string>;
+/**
+ * Define the context to use for the CoW Protocol API.
+ *
+ * CoW Protocol is a set of smart contracts and off-chain services, deployed on **multiple chains**.
+ * {@link SupportedChainId Supported chains} are:
+ * - Mainnet
+ * - Goerli
+ * - Gnosis Chain
+ *
+ * Each chain has it's own API, and each API has it's own base URL.
+ *
+ * Options may be selectively overridden by passing a {@link PartialApiContext} to the constructor.
+ * @see {@link https://api.cow.fi/docs/#/}
+ * @property {SupportedChainId} chainId The `chainId`` corresponding to this CoW Protocol API instance.
+ * @property {CowEnv} env The environment that this context corresponds to.
+ * @property {ApiBaseUrls} [baseUrls] URls that may be used to connect to this context.
+ */
 export interface ApiContext {
     chainId: SupportedChainId;
     env: CowEnv;
     baseUrls?: ApiBaseUrls;
 }
+/**
+ * The list of available environments.
+ */
 export declare const ENVS_LIST: CowEnv[];
+/**
+ * The default CoW Protocol API context.
+ */
 export declare const DEFAULT_COW_API_CONTEXT: ApiContext;

package/dist/common/consts.d.ts

@@ -1,3 +1,20 @@
 import { SupportedChainId } from './chains';
+export declare const BUY_ETH_ADDRESS = "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE";
+export declare const EXTENSIBLE_FALLBACK_HANDLER = "0x2f55e8b20D0B9FEFA187AA7d00B6Cbe563605bF5";
+export declare const COMPOSABLE_COW = "0xfdaFc9d1902f4e0b84f65F49f244b32b31013b74";
+/**
+ * The list of supported chains.
+ */
 export declare const ALL_SUPPORTED_CHAIN_IDS: SupportedChainId[];
+/**
+ * An object containing the addresses of the CoW Protocol settlement contracts for each supported chain.
+ */
 export declare const COW_PROTOCOL_SETTLEMENT_CONTRACT_ADDRESS: Record<number, string>;
+/**
+ * An object containing the addresses of the `ExtensibleFallbackHandler` contracts for each supported chain.
+ */
+export declare const EXTENSIBLE_FALLBACK_HANDLER_CONTRACT_ADDRESS: Record<number, string>;
+/**
+ * An object containing the addresses of the `ComposableCow` contracts for each supported chain.
+ */
+export declare const COMPOSABLE_COW_CONTRACT_ADDRESS: Record<number, string>;

package/dist/composable/conditionalorder.d.ts

@@ -0,0 +1,160 @@
+import { BigNumber, ethers } from 'ethers';
+import { ContextFactory } from './multiplexer';
+export declare const CONDITIONAL_ORDER_PARAMS_ABI: string[];
+export type ConditionalOrderParams = {
+    readonly handler: string;
+    readonly salt: string;
+    readonly staticInput: string;
+};
+/**
+ * An abstract base class from which all conditional orders should inherit.
+ *
+ * This class provides some basic functionality to help with handling conditional orders,
+ * such as:
+ * - Validating the conditional order
+ * - Creating a human-readable string representation of the conditional order
+ * - Serializing the conditional order for use with the `IConditionalOrder` struct
+ * - Getting any dependencies for the conditional order
+ * - Getting the off-chain input for the conditional order
+ *
+ * **NOTE**: Instances of conditional orders have an `id` property that is a `keccak256` hash of
+ *           the serialized conditional order.
+ */
+export declare abstract class BaseConditionalOrder<T, P> {
+    readonly handler: string;
+    readonly salt: string;
+    readonly staticInput: T;
+    readonly hasOffChainInput: boolean;
+    /**
+     * A constructor that provides some basic validation for the conditional order.
+     *
+     * This constructor **MUST** be called by any class that inherits from `BaseConditionalOrder`.
+     *
+     * **NOTE**: The salt is optional and will be randomly generated if not provided.
+     * @param handler The address of the handler for the conditional order.
+     * @param salt A 32-byte string used to salt the conditional order.
+     * @param staticInput The static input for the conditional order.
+     * @param hasOffChainInput Whether the conditional order has off-chain input.
+     * @throws If the handler is not a valid ethereum address.
+     * @throws If the salt is not a valid 32-byte string.
+     */
+    constructor(handler: string, salt: string | undefined, staticInput: P, hasOffChainInput?: boolean);
+    /**
+     * Get the concrete type of the conditional order.
+     * @returns {string} The concrete type of the conditional order.
+     */
+    abstract get orderType(): string;
+    /**
+     * Get the context dependency for the conditional order.
+     *
+     * This is used when calling `createWithContext` or `setRootWithContext` on a ComposableCoW-enabled Safe.
+     * @returns The context dependency.
+     */
+    get context(): ContextFactory | undefined;
+    /**
+     * Get the calldata for creating the conditional order.
+     *
+     * This will automatically determine whether or not to use `create` or `createWithContext` based on the
+     * order type's context dependency.
+     *
+     * **NOTE**: By default, this will cause the create to emit the `ConditionalOrderCreated` event.
+     * @returns The calldata for creating the conditional order.
+     */
+    get createCalldata(): string;
+    /**
+     * Get the calldata for removing a conditional order that was created as a single order.
+     * @returns The calldata for removing the conditional order.
+     */
+    get removeCalldata(): string;
+    /**
+     * Calculate the id of the conditional order.
+     *
+     * This is a `keccak256` hash of the serialized conditional order.
+     * @returns The id of the conditional order.
+     */
+    get id(): string;
+    /**
+     * Get the `leaf` of the conditional order. This is the data that is used to create the merkle tree.
+     *
+     * For the purposes of this library, the `leaf` is the `ConditionalOrderParams` struct.
+     * @returns The `leaf` of the conditional order.
+     * @see ConditionalOrderParams
+     */
+    get leaf(): ConditionalOrderParams;
+    /**
+     * Calculate the id of the conditional order.
+     * @param leaf The `leaf` representing the conditional order.
+     * @returns The id of the conditional order.
+     * @see ConditionalOrderParams
+     */
+    static leafToId(leaf: ConditionalOrderParams): string;
+    /**
+     * If the conditional order has off-chain input, return it!
+     *
+     * **NOTE**: This should be overridden by any conditional order that has off-chain input.
+     * @returns The off-chain input.
+     */
+    get offChainInput(): string;
+    /**
+     * Helper method for validating ABI types.
+     * @param types ABI types to validate against.
+     * @param values The values to validate.
+     * @returns {boolean} Whether the values are valid ABI for the given types.
+     */
+    protected static isValidAbi(types: readonly (string | ethers.utils.ParamType)[], values: any[]): boolean;
+    /**
+     * Create a human-readable string representation of the conditional order.
+     * @param tokenFormatter An optional function that takes an address and an amount and returns a human-readable string.
+     */
+    abstract toString(tokenFormatter?: (address: string, amount: BigNumber) => string): string;
+    /**
+     * Serializes the conditional order into it's ABI-encoded form.
+     *
+     * @returns The equivalent of `IConditionalOrder.Params` for the conditional order.
+     */
+    abstract serialize(): string;
+    /**
+     * Encode the `staticInput` for the conditional order.
+     * @returns The ABI-encoded `staticInput` for the conditional order.
+     * @see ConditionalOrderParams
+     */
+    abstract encodeStaticInput(): string;
+    /**
+     * A helper function for generically serializing a conditional order's static input.
+     * @param orderDataTypes ABI types for the order's data struct.
+     * @param staticInput The order's data struct.
+     * @returns An ABI-encoded representation of the order's data struct.
+     */
+    protected encodeStaticInputHelper(orderDataTypes: string[], staticInput: T): string;
+    /**
+     * Apply any transformations to the parameters that are passed in to the constructor.
+     *
+     * **NOTE**: This should be overridden by any conditional order that requires transformations.
+     * This implementation is a no-op.
+     * @param params {P} Parameters that are passed in to the constructor.
+     * @returns {T} The static input for the conditional order.
+     */
+    protected transformParamsToData(params: P): T;
+    /**
+     * Encode the `ConditionalOrderParams` for the conditional order.
+     * @param leaf The `ConditionalOrderParams` struct representing the conditional order as taken from a merkle tree.
+     * @returns The ABI-encoded conditional order.
+     * @see ConditionalOrderParams
+     */
+    static encodeParams(leaf: ConditionalOrderParams): string;
+    /**
+     * Decode the `ConditionalOrderParams` for the conditional order.
+     * @param encoded The encoded conditional order.
+     * @returns The decoded conditional order.
+     */
+    static decodeParams(encoded: string): ConditionalOrderParams;
+    /**
+     * A helper function for generically deserializing a conditional order.
+     * @param s The ABI-encoded `IConditionalOrder.Params` struct to deserialize.
+     * @param handler Address of the handler for the conditional order.
+     * @param orderDataTypes ABI types for the order's data struct.
+     * @param callback A callback function that takes the deserialized data struct and the salt and returns an instance of the class.
+     * @returns An instance of the conditional order class.
+     */
+    protected static deserializeHelper<T>(s: string, handler: string, orderDataTypes: string[], callback: (d: any, salt: string) => T): T;
+}

package/dist/composable/extensible.d.ts

@@ -0,0 +1,6 @@
+import { providers } from 'ethers';
+import { SupportedChainId } from '../common';
+export declare function isExtensibleFallbackHandler(handler: string, chainId: SupportedChainId): boolean;
+export declare function isComposableCow(handler: string, chainId: SupportedChainId): boolean;
+export declare function getDomainVerifier(safe: string, domain: string, chainId: SupportedChainId, provider: providers.Provider): Promise<string>;
+export declare function createSetDomainVerifierTx(domain: string, verifier: string): string;

package/dist/composable/generated/ComposableCoW.d.ts

@@ -0,0 +1,340 @@
+import type { BaseContract, BigNumber, BigNumberish, BytesLike, CallOverrides, ContractTransaction, Overrides, PopulatedTransaction, Signer, utils } from "ethers";
+import type { FunctionFragment, Result, EventFragment } from "@ethersproject/abi";
+import type { Listener, Provider } from "@ethersproject/providers";
+import type { TypedEventFilter, TypedEvent, TypedListener, OnEvent } from "./common";
+export declare namespace IConditionalOrder {
+    type ConditionalOrderParamsStruct = {
+        handler: string;
+        salt: BytesLike;
+        staticInput: BytesLike;
+    };
+    type ConditionalOrderParamsStructOutput = [string, string, string] & {
+        handler: string;
+        salt: string;
+        staticInput: string;
+    };
+}
+export declare namespace ComposableCoW {
+    type ProofStruct = {
+        location: BigNumberish;
+        data: BytesLike;
+    };
+    type ProofStructOutput = [BigNumber, string] & {
+        location: BigNumber;
+        data: string;
+    };
+}
+export declare namespace GPv2Order {
+    type DataStruct = {
+        sellToken: string;
+        buyToken: string;
+        receiver: string;
+        sellAmount: BigNumberish;
+        buyAmount: BigNumberish;
+        validTo: BigNumberish;
+        appData: BytesLike;
+        feeAmount: BigNumberish;
+        kind: BytesLike;
+        partiallyFillable: boolean;
+        sellTokenBalance: BytesLike;
+        buyTokenBalance: BytesLike;
+    };
+    type DataStructOutput = [
+        string,
+        string,
+        string,
+        BigNumber,
+        BigNumber,
+        number,
+        string,
+        BigNumber,
+        string,
+        boolean,
+        string,
+        string
+    ] & {
+        sellToken: string;
+        buyToken: string;
+        receiver: string;
+        sellAmount: BigNumber;
+        buyAmount: BigNumber;
+        validTo: number;
+        appData: string;
+        feeAmount: BigNumber;
+        kind: string;
+        partiallyFillable: boolean;
+        sellTokenBalance: string;
+        buyTokenBalance: string;
+    };
+}
+export interface ComposableCoWInterface extends utils.Interface {
+    functions: {
+        "cabinet(address,bytes32)": FunctionFragment;
+        "create((address,bytes32,bytes),bool)": FunctionFragment;
+        "createWithContext((address,bytes32,bytes),address,bytes,bool)": FunctionFragment;
+        "domainSeparator()": FunctionFragment;
+        "getTradeableOrderWithSignature(address,(address,bytes32,bytes),bytes,bytes32[])": FunctionFragment;
+        "hash((address,bytes32,bytes))": FunctionFragment;
+        "isValidSafeSignature(address,address,bytes32,bytes32,bytes32,bytes,bytes)": FunctionFragment;
+        "remove(bytes32)": FunctionFragment;
+        "roots(address)": FunctionFragment;
+        "setRoot(bytes32,(uint256,bytes))": FunctionFragment;
+        "setRootWithContext(bytes32,(uint256,bytes),address,bytes)": FunctionFragment;
+        "setSwapGuard(address)": FunctionFragment;
+        "singleOrders(address,bytes32)": FunctionFragment;
+        "swapGuards(address)": FunctionFragment;
+    };
+    getFunction(nameOrSignatureOrTopic: "cabinet" | "create" | "createWithContext" | "domainSeparator" | "getTradeableOrderWithSignature" | "hash" | "isValidSafeSignature" | "remove" | "roots" | "setRoot" | "setRootWithContext" | "setSwapGuard" | "singleOrders" | "swapGuards"): FunctionFragment;
+    encodeFunctionData(functionFragment: "cabinet", values: [string, BytesLike]): string;
+    encodeFunctionData(functionFragment: "create", values: [IConditionalOrder.ConditionalOrderParamsStruct, boolean]): string;
+    encodeFunctionData(functionFragment: "createWithContext", values: [
+        IConditionalOrder.ConditionalOrderParamsStruct,
+        string,
+        BytesLike,
+        boolean
+    ]): string;
+    encodeFunctionData(functionFragment: "domainSeparator", values?: undefined): string;
+    encodeFunctionData(functionFragment: "getTradeableOrderWithSignature", values: [
+        string,
+        IConditionalOrder.ConditionalOrderParamsStruct,
+        BytesLike,
+        BytesLike[]
+    ]): string;
+    encodeFunctionData(functionFragment: "hash", values: [IConditionalOrder.ConditionalOrderParamsStruct]): string;
+    encodeFunctionData(functionFragment: "isValidSafeSignature", values: [
+        string,
+        string,
+        BytesLike,
+        BytesLike,
+        BytesLike,
+        BytesLike,
+        BytesLike
+    ]): string;
+    encodeFunctionData(functionFragment: "remove", values: [BytesLike]): string;
+    encodeFunctionData(functionFragment: "roots", values: [string]): string;
+    encodeFunctionData(functionFragment: "setRoot", values: [BytesLike, ComposableCoW.ProofStruct]): string;
+    encodeFunctionData(functionFragment: "setRootWithContext", values: [BytesLike, ComposableCoW.ProofStruct, string, BytesLike]): string;
+    encodeFunctionData(functionFragment: "setSwapGuard", values: [string]): string;
+    encodeFunctionData(functionFragment: "singleOrders", values: [string, BytesLike]): string;
+    encodeFunctionData(functionFragment: "swapGuards", values: [string]): string;
+    decodeFunctionResult(functionFragment: "cabinet", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "create", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "createWithContext", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "domainSeparator", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getTradeableOrderWithSignature", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "hash", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "isValidSafeSignature", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "remove", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "roots", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "setRoot", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "setRootWithContext", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "setSwapGuard", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "singleOrders", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "swapGuards", data: BytesLike): Result;
+    events: {
+        "ConditionalOrderCreated(address,(address,bytes32,bytes))": EventFragment;
+        "MerkleRootSet(address,bytes32,(uint256,bytes))": EventFragment;
+        "SwapGuardSet(address,address)": EventFragment;
+    };
+    getEvent(nameOrSignatureOrTopic: "ConditionalOrderCreated"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "MerkleRootSet"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "SwapGuardSet"): EventFragment;
+}
+export interface ConditionalOrderCreatedEventObject {
+    owner: string;
+    params: IConditionalOrder.ConditionalOrderParamsStructOutput;
+}
+export type ConditionalOrderCreatedEvent = TypedEvent<[
+    string,
+    IConditionalOrder.ConditionalOrderParamsStructOutput
+], ConditionalOrderCreatedEventObject>;
+export type ConditionalOrderCreatedEventFilter = TypedEventFilter<ConditionalOrderCreatedEvent>;
+export interface MerkleRootSetEventObject {
+    owner: string;
+    root: string;
+    proof: ComposableCoW.ProofStructOutput;
+}
+export type MerkleRootSetEvent = TypedEvent<[
+    string,
+    string,
+    ComposableCoW.ProofStructOutput
+], MerkleRootSetEventObject>;
+export type MerkleRootSetEventFilter = TypedEventFilter<MerkleRootSetEvent>;
+export interface SwapGuardSetEventObject {
+    owner: string;
+    swapGuard: string;
+}
+export type SwapGuardSetEvent = TypedEvent<[
+    string,
+    string
+], SwapGuardSetEventObject>;
+export type SwapGuardSetEventFilter = TypedEventFilter<SwapGuardSetEvent>;
+export interface ComposableCoW extends BaseContract {
+    connect(signerOrProvider: Signer | Provider | string): this;
+    attach(addressOrName: string): this;
+    deployed(): Promise<this>;
+    interface: ComposableCoWInterface;
+    queryFilter<TEvent extends TypedEvent>(event: TypedEventFilter<TEvent>, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TEvent>>;
+    listeners<TEvent extends TypedEvent>(eventFilter?: TypedEventFilter<TEvent>): Array<TypedListener<TEvent>>;
+    listeners(eventName?: string): Array<Listener>;
+    removeAllListeners<TEvent extends TypedEvent>(eventFilter: TypedEventFilter<TEvent>): this;
+    removeAllListeners(eventName?: string): this;
+    off: OnEvent<this>;
+    on: OnEvent<this>;
+    once: OnEvent<this>;
+    removeListener: OnEvent<this>;
+    functions: {
+        cabinet(arg0: string, arg1: BytesLike, overrides?: CallOverrides): Promise<[string]>;
+        create(params: IConditionalOrder.ConditionalOrderParamsStruct, dispatch: boolean, overrides?: Overrides & {
+            from?: string;
+        }): Promise<ContractTransaction>;
+        createWithContext(params: IConditionalOrder.ConditionalOrderParamsStruct, factory: string, data: BytesLike, dispatch: boolean, overrides?: Overrides & {
+            from?: string;
+        }): Promise<ContractTransaction>;
+        domainSeparator(overrides?: CallOverrides): Promise<[string]>;
+        getTradeableOrderWithSignature(owner: string, params: IConditionalOrder.ConditionalOrderParamsStruct, offchainInput: BytesLike, proof: BytesLike[], overrides?: CallOverrides): Promise<[
+            GPv2Order.DataStructOutput,
+            string
+        ] & {
+            order: GPv2Order.DataStructOutput;
+            signature: string;
+        }>;
+        hash(params: IConditionalOrder.ConditionalOrderParamsStruct, overrides?: CallOverrides): Promise<[string]>;
+        isValidSafeSignature(safe: string, sender: string, _hash: BytesLike, _domainSeparator: BytesLike, arg4: BytesLike, encodeData: BytesLike, payload: BytesLike, overrides?: CallOverrides): Promise<[string] & {
+            magic: string;
+        }>;
+        remove(singleOrderHash: BytesLike, overrides?: Overrides & {
+            from?: string;
+        }): Promise<ContractTransaction>;
+        roots(arg0: string, overrides?: CallOverrides): Promise<[string]>;
+        setRoot(root: BytesLike, proof: ComposableCoW.ProofStruct, overrides?: Overrides & {
+            from?: string;
+        }): Promise<ContractTransaction>;
+        setRootWithContext(root: BytesLike, proof: ComposableCoW.ProofStruct, factory: string, data: BytesLike, overrides?: Overrides & {
+            from?: string;
+        }): Promise<ContractTransaction>;
+        setSwapGuard(swapGuard: string, overrides?: Overrides & {
+            from?: string;
+        }): Promise<ContractTransaction>;
+        singleOrders(arg0: string, arg1: BytesLike, overrides?: CallOverrides): Promise<[boolean]>;
+        swapGuards(arg0: string, overrides?: CallOverrides): Promise<[string]>;
+    };
+    cabinet(arg0: string, arg1: BytesLike, overrides?: CallOverrides): Promise<string>;
+    create(params: IConditionalOrder.ConditionalOrderParamsStruct, dispatch: boolean, overrides?: Overrides & {
+        from?: string;
+    }): Promise<ContractTransaction>;
+    createWithContext(params: IConditionalOrder.ConditionalOrderParamsStruct, factory: string, data: BytesLike, dispatch: boolean, overrides?: Overrides & {
+        from?: string;
+    }): Promise<ContractTransaction>;
+    domainSeparator(overrides?: CallOverrides): Promise<string>;
+    getTradeableOrderWithSignature(owner: string, params: IConditionalOrder.ConditionalOrderParamsStruct, offchainInput: BytesLike, proof: BytesLike[], overrides?: CallOverrides): Promise<[
+        GPv2Order.DataStructOutput,
+        string
+    ] & {
+        order: GPv2Order.DataStructOutput;
+        signature: string;
+    }>;
+    hash(params: IConditionalOrder.ConditionalOrderParamsStruct, overrides?: CallOverrides): Promise<string>;
+    isValidSafeSignature(safe: string, sender: string, _hash: BytesLike, _domainSeparator: BytesLike, arg4: BytesLike, encodeData: BytesLike, payload: BytesLike, overrides?: CallOverrides): Promise<string>;
+    remove(singleOrderHash: BytesLike, overrides?: Overrides & {
+        from?: string;
+    }): Promise<ContractTransaction>;
+    roots(arg0: string, overrides?: CallOverrides): Promise<string>;
+    setRoot(root: BytesLike, proof: ComposableCoW.ProofStruct, overrides?: Overrides & {
+        from?: string;
+    }): Promise<ContractTransaction>;
+    setRootWithContext(root: BytesLike, proof: ComposableCoW.ProofStruct, factory: string, data: BytesLike, overrides?: Overrides & {
+        from?: string;
+    }): Promise<ContractTransaction>;
+    setSwapGuard(swapGuard: string, overrides?: Overrides & {
+        from?: string;
+    }): Promise<ContractTransaction>;
+    singleOrders(arg0: string, arg1: BytesLike, overrides?: CallOverrides): Promise<boolean>;
+    swapGuards(arg0: string, overrides?: CallOverrides): Promise<string>;
+    callStatic: {
+        cabinet(arg0: string, arg1: BytesLike, overrides?: CallOverrides): Promise<string>;
+        create(params: IConditionalOrder.ConditionalOrderParamsStruct, dispatch: boolean, overrides?: CallOverrides): Promise<void>;
+        createWithContext(params: IConditionalOrder.ConditionalOrderParamsStruct, factory: string, data: BytesLike, dispatch: boolean, overrides?: CallOverrides): Promise<void>;
+        domainSeparator(overrides?: CallOverrides): Promise<string>;
+        getTradeableOrderWithSignature(owner: string, params: IConditionalOrder.ConditionalOrderParamsStruct, offchainInput: BytesLike, proof: BytesLike[], overrides?: CallOverrides): Promise<[
+            GPv2Order.DataStructOutput,
+            string
+        ] & {
+            order: GPv2Order.DataStructOutput;
+            signature: string;
+        }>;
+        hash(params: IConditionalOrder.ConditionalOrderParamsStruct, overrides?: CallOverrides): Promise<string>;
+        isValidSafeSignature(safe: string, sender: string, _hash: BytesLike, _domainSeparator: BytesLike, arg4: BytesLike, encodeData: BytesLike, payload: BytesLike, overrides?: CallOverrides): Promise<string>;
+        remove(singleOrderHash: BytesLike, overrides?: CallOverrides): Promise<void>;
+        roots(arg0: string, overrides?: CallOverrides): Promise<string>;
+        setRoot(root: BytesLike, proof: ComposableCoW.ProofStruct, overrides?: CallOverrides): Promise<void>;
+        setRootWithContext(root: BytesLike, proof: ComposableCoW.ProofStruct, factory: string, data: BytesLike, overrides?: CallOverrides): Promise<void>;
+        setSwapGuard(swapGuard: string, overrides?: CallOverrides): Promise<void>;
+        singleOrders(arg0: string, arg1: BytesLike, overrides?: CallOverrides): Promise<boolean>;
+        swapGuards(arg0: string, overrides?: CallOverrides): Promise<string>;
+    };
+    filters: {
+        "ConditionalOrderCreated(address,(address,bytes32,bytes))"(owner?: string | null, params?: null): ConditionalOrderCreatedEventFilter;
+        ConditionalOrderCreated(owner?: string | null, params?: null): ConditionalOrderCreatedEventFilter;
+        "MerkleRootSet(address,bytes32,(uint256,bytes))"(owner?: string | null, root?: null, proof?: null): MerkleRootSetEventFilter;
+        MerkleRootSet(owner?: string | null, root?: null, proof?: null): MerkleRootSetEventFilter;
+        "SwapGuardSet(address,address)"(owner?: string | null, swapGuard?: null): SwapGuardSetEventFilter;
+        SwapGuardSet(owner?: string | null, swapGuard?: null): SwapGuardSetEventFilter;
+    };
+    estimateGas: {
+        cabinet(arg0: string, arg1: BytesLike, overrides?: CallOverrides): Promise<BigNumber>;
+        create(params: IConditionalOrder.ConditionalOrderParamsStruct, dispatch: boolean, overrides?: Overrides & {
+            from?: string;
+        }): Promise<BigNumber>;
+        createWithContext(params: IConditionalOrder.ConditionalOrderParamsStruct, factory: string, data: BytesLike, dispatch: boolean, overrides?: Overrides & {
+            from?: string;
+        }): Promise<BigNumber>;
+        domainSeparator(overrides?: CallOverrides): Promise<BigNumber>;
+        getTradeableOrderWithSignature(owner: string, params: IConditionalOrder.ConditionalOrderParamsStruct, offchainInput: BytesLike, proof: BytesLike[], overrides?: CallOverrides): Promise<BigNumber>;
+        hash(params: IConditionalOrder.ConditionalOrderParamsStruct, overrides?: CallOverrides): Promise<BigNumber>;
+        isValidSafeSignature(safe: string, sender: string, _hash: BytesLike, _domainSeparator: BytesLike, arg4: BytesLike, encodeData: BytesLike, payload: BytesLike, overrides?: CallOverrides): Promise<BigNumber>;
+        remove(singleOrderHash: BytesLike, overrides?: Overrides & {
+            from?: string;
+        }): Promise<BigNumber>;
+        roots(arg0: string, overrides?: CallOverrides): Promise<BigNumber>;
+        setRoot(root: BytesLike, proof: ComposableCoW.ProofStruct, overrides?: Overrides & {
+            from?: string;
+        }): Promise<BigNumber>;
+        setRootWithContext(root: BytesLike, proof: ComposableCoW.ProofStruct, factory: string, data: BytesLike, overrides?: Overrides & {
+            from?: string;
+        }): Promise<BigNumber>;
+        setSwapGuard(swapGuard: string, overrides?: Overrides & {
+            from?: string;
+        }): Promise<BigNumber>;
+        singleOrders(arg0: string, arg1: BytesLike, overrides?: CallOverrides): Promise<BigNumber>;
+        swapGuards(arg0: string, overrides?: CallOverrides): Promise<BigNumber>;
+    };
+    populateTransaction: {
+        cabinet(arg0: string, arg1: BytesLike, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        create(params: IConditionalOrder.ConditionalOrderParamsStruct, dispatch: boolean, overrides?: Overrides & {
+            from?: string;
+        }): Promise<PopulatedTransaction>;
+        createWithContext(params: IConditionalOrder.ConditionalOrderParamsStruct, factory: string, data: BytesLike, dispatch: boolean, overrides?: Overrides & {
+            from?: string;
+        }): Promise<PopulatedTransaction>;
+        domainSeparator(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        getTradeableOrderWithSignature(owner: string, params: IConditionalOrder.ConditionalOrderParamsStruct, offchainInput: BytesLike, proof: BytesLike[], overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        hash(params: IConditionalOrder.ConditionalOrderParamsStruct, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        isValidSafeSignature(safe: string, sender: string, _hash: BytesLike, _domainSeparator: BytesLike, arg4: BytesLike, encodeData: BytesLike, payload: BytesLike, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        remove(singleOrderHash: BytesLike, overrides?: Overrides & {
+            from?: string;
+        }): Promise<PopulatedTransaction>;
+        roots(arg0: string, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        setRoot(root: BytesLike, proof: ComposableCoW.ProofStruct, overrides?: Overrides & {
+            from?: string;
+        }): Promise<PopulatedTransaction>;
+        setRootWithContext(root: BytesLike, proof: ComposableCoW.ProofStruct, factory: string, data: BytesLike, overrides?: Overrides & {
+            from?: string;
+        }): Promise<PopulatedTransaction>;
+        setSwapGuard(swapGuard: string, overrides?: Overrides & {
+            from?: string;
+        }): Promise<PopulatedTransaction>;
+        singleOrders(arg0: string, arg1: BytesLike, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        swapGuards(arg0: string, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+    };
+}