@cowprotocol/cow-sdk 2.4.0-rc.0 → 3.0.0-rc.3

package/dist/composable/{conditionalorder.d.ts → ConditionalOrder.d.ts}

@@ -1,11 +1,6 @@
-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;
-};
+import { BigNumber, providers } from 'ethers';
+import { ConditionalOrderArguments, ConditionalOrderParams, ContextFactory, IsValidResult, PollResult, PollResultErrors } from './types';
+import { SupportedChainId } from '../common';
 /**
  * An abstract base class from which all conditional orders should inherit.
  *
@@ -20,27 +15,29 @@ export type ConditionalOrderParams = {
  * **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> {
+export declare abstract class ConditionalOrder<D, S> {
     readonly handler: string;
     readonly salt: string;
-    readonly staticInput: T;
+    readonly data: D;
+    readonly staticInput: S;
     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`.
+     * This constructor **MUST** be called by any class that inherits from `ConditionalOrder`.
      *
      * **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 data The data of the 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);
+    constructor(params: ConditionalOrderArguments<D>);
     /**
-     * Get the concrete type of the conditional order.
+     * Get a descriptive name for the type of the conditional order (i.e twap, dca, etc).
+     *
      * @returns {string} The concrete type of the conditional order.
      */
     abstract get orderType(): string;
@@ -51,6 +48,8 @@ export declare abstract class BaseConditionalOrder<T, P> {
      * @returns The context dependency.
      */
     get context(): ContextFactory | undefined;
+    assertIsValid(): void;
+    abstract isValid(): IsValidResult;
     /**
      * Get the calldata for creating the conditional order.
      *
@@ -67,7 +66,7 @@ export declare abstract class BaseConditionalOrder<T, P> {
      */
     get removeCalldata(): string;
     /**
-     * Calculate the id of the conditional order.
+     * Calculate the id of the conditional order (which also happens to be the key used for `ctx` in the ComposableCoW contract).
      *
      * This is a `keccak256` hash of the serialized conditional order.
      * @returns The id of the conditional order.
@@ -95,15 +94,9 @@ export declare abstract class BaseConditionalOrder<T, P> {
      * @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;
@@ -115,39 +108,73 @@ export declare abstract class BaseConditionalOrder<T, P> {
     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.
+     * @param data The order's data struct.
      * @returns An ABI-encoded representation of the order's data struct.
      */
-    protected encodeStaticInputHelper(orderDataTypes: string[], staticInput: T): string;
+    protected encodeStaticInputHelper(orderDataTypes: string[], staticInput: S): string;
     /**
-     * Apply any transformations to the parameters that are passed in to the constructor.
+     * Poll a conditional order to see if it is tradeable.
      *
-     * **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.
+     * @param owner The owner of the conditional order.
+     * @param p The proof and parameters.
+     * @param chain Which chain to use for the ComposableCoW contract.
+     * @param provider An RPC provider for the chain.
+     * @param offChainInputFn A function, if provided, that will return the off-chain input for the conditional order.
+     * @throws If the conditional order is not tradeable.
+     * @returns The tradeable `GPv2Order.Data` struct and the `signature` for the conditional order.
      */
-    protected transformParamsToData(params: P): T;
+    poll(owner: string, chain: SupportedChainId, provider: providers.Provider): Promise<PollResult>;
     /**
-     * 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
+     * Checks if the owner authorized the conditional order.
+     *
+     * @param owner The owner of the conditional order.
+     * @param chain Which chain to use for the ComposableCoW contract.
+     * @param provider An RPC provider for the chain.
+     * @returns true if the owner authorized the order, false otherwise.
      */
-    static encodeParams(leaf: ConditionalOrderParams): string;
+    isAuthorized(owner: string, chain: SupportedChainId, provider: providers.Provider): Promise<boolean>;
     /**
-     * Decode the `ConditionalOrderParams` for the conditional order.
-     * @param encoded The encoded conditional order.
-     * @returns The decoded conditional order.
+     * Allow concrete conditional orders to perform additional validation for the poll method.
+     *
+     * This will allow the concrete orders to decide when an order shouldn't be polled again. For example, if the orders is expired.
+     * It also allows to signal when should the next check be done. For example, an order could signal that the validations will fail until a certain time or block.
+     *
+     * @param owner The owner of the conditional order.
+     * @param chain Which chain to use for the ComposableCoW contract.
+     * @param provider An RPC provider for the chain.
+     *
+     * @returns undefined if the concrete order can't make a decision. Otherwise, it returns a PollResultErrors object.
+     */
+    protected abstract pollValidate(owner: string, chain: SupportedChainId, provider: providers.Provider): Promise<PollResultErrors | undefined>;
+    /**
+     * Convert the struct that the contract expect as an encoded `staticInput` into a friendly data object modeling the smart order.
+     *
+     * **NOTE**: This should be overridden by any conditional order that requires transformations.
+     * This implementation is a no-op if you use the same type for both.
+     *
+     * @param params {S} Parameters that are passed in to the constructor.
+     * @returns {D} The static input for the conditional order.
+     */
+    abstract transformStructToData(params: S): D;
+    /**
+     * Converts a friendly data object modeling the smart order into the struct that the contract expect as an encoded `staticInput`.
+     *
+     * **NOTE**: This should be overridden by any conditional order that requires transformations.
+     * This implementation is a no-op if you use the same type for both.
+     *
+     * @param params {S} Parameters that are passed in to the constructor.
+     * @returns {D} The static input for the conditional order.
      */
-    static decodeParams(encoded: string): ConditionalOrderParams;
+    abstract transformDataToStruct(params: D): S;
     /**
      * A helper function for generically deserializing a conditional order.
      * @param s The ABI-encoded `IConditionalOrder.Params` struct to deserialize.

package/dist/composable/ConditionalOrderFactory.d.ts

@@ -0,0 +1,9 @@
+import { type ConditionalOrder } from './ConditionalOrder';
+import { ConditionalOrderParams } from './types';
+export type FromParams<D, S> = (params: ConditionalOrderParams) => ConditionalOrder<D, S>;
+export type ConditionalOrderRegistry = Record<string, FromParams<unknown, unknown>>;
+export declare class ConditionalOrderFactory {
+    knownOrderTypes: ConditionalOrderRegistry;
+    constructor(registry: ConditionalOrderRegistry);
+    fromParams(params: ConditionalOrderParams): ConditionalOrder<unknown, unknown> | undefined;
+}

package/dist/composable/{multiplexer.d.ts → Multiplexer.d.ts}

@@ -1,56 +1,9 @@
 import { providers } from 'ethers';
 import { SupportedChainId } from '../common';
-import { BaseConditionalOrder, ConditionalOrderParams } from './conditionalorder';
 import { ComposableCoW, GPv2Order } from './generated/ComposableCoW';
-export type Orders = Record<string, BaseConditionalOrder<any, any>>;
-export declare enum ProofLocation {
-    PRIVATE = 0,
-    EMITTED = 1,
-    SWARM = 2,
-    WAKU = 3,
-    RESERVED = 4,
-    IPFS = 5
-}
-/**
- * A factory and it's arguments that are called at transaction mining time to generate the context
- * for a conditional order(s).
- *
- * This allows to support the case where conditional orders may want to *commence* validity at the
- * time of transaction mining, like in the case of a `TWAP` executed by a DAO or `Safe` that takes
- * a reasonable amount of time to aggregate signatures or collect votes.
- *
- * @remarks This is used in conjunction with `setRootWithContext` or `createWithContext`.
- */
-export type ContextFactory = {
-    address: string;
-    factoryArgs?: {
-        args: any[];
-        argsType: string[];
-    };
-};
-/**
- * A struct for a proof that can be used with `setRoot` and `setRootWithContext` on a
- * ComposableCoW-enabled Safe.
- */
-export type ProofStruct = {
-    location: ProofLocation;
-    data: string | '0x';
-};
-/**
- * Payload for emitting a merkle root to a ComposableCoW-enabled Safe.
- *
- * If setting `ProofLocation.EMITTED`, this type should be used as the `data` in the `Proof` struct.
- */
-export type PayloadLocationEmitted = {
-    proofs: ProofWithParams[];
-};
-/**
- * A proof for a conditional order and it's parameters.
- */
-export type ProofWithParams = {
-    proof: string[];
-    params: ConditionalOrderParams;
-};
+import { ProofLocation, ProofWithParams, ConditionalOrderParams } from './types';
+import { ConditionalOrder } from './ConditionalOrder';
+export type Orders = Record<string, ConditionalOrder<unknown, unknown>>;
 /**
  * Multiplexer for conditional orders - using `ComposableCoW`!
  *
@@ -61,7 +14,7 @@ export type ProofWithParams = {
  * - Support for passing an optional upload function to upload the proofs to a decentralized storage network
  */
 export declare class Multiplexer {
-    static orderTypeRegistry: Record<string, new (...args: any[]) => BaseConditionalOrder<any, any>>;
+    static orderTypeRegistry: Record<string, new (...args: unknown[]) => ConditionalOrder<unknown, unknown>>;
     chain: SupportedChainId;
     location: ProofLocation;
     private orders;
@@ -99,30 +52,30 @@ export declare class Multiplexer {
      * Add a conditional order to the merkle tree.
      * @param order The order to add to the merkle tree.
      */
-    add<T, P>(order: BaseConditionalOrder<T, P>): void;
+    add<T, P>(order: ConditionalOrder<T, P>): void;
     /**
      * Remove a conditional order from the merkle tree.
-     * @param id The id of the `BaseConditionalOrder` to remove from the merkle tree.
+     * @param id The id of the `ConditionalOrder` to remove from the merkle tree.
      */
     remove(id: string): void;
     /**
      * Update a given conditional order in the merkle tree.
-     * @param id The id of the `BaseConditionalOrder` to update.
-     * @param updater A function that takes the existing `BaseConditionalOrder` and context, returning an updated `BaseConditionalOrder`.
+     * @param id The id of the `ConditionalOrder` to update.
+     * @param updater A function that takes the existing `ConditionalOrder` and context, returning an updated `ConditionalOrder`.
      */
-    update<T, P>(id: string, updater: (order: BaseConditionalOrder<T, P>, ctx?: string) => BaseConditionalOrder<T, P>): void;
+    update(id: string, updater: (order: ConditionalOrder<unknown, unknown>, ctx?: string) => ConditionalOrder<unknown, unknown>): void;
     /**
      * Accessor for a given conditional order in the multiplexer.
-     * @param id The `id` of the `BaseConditionalOrder` to retrieve.
-     * @returns A `BaseConditionalOrder` with the given `id`.
+     * @param id The `id` of the `ConditionalOrder` to retrieve.
+     * @returns A `ConditionalOrder` with the given `id`.
      */
-    getById(id: string): BaseConditionalOrder<any, any>;
+    getById(id: string): ConditionalOrder<unknown, unknown>;
     /**
      * Accessor for a given conditional order in the multiplexer.
-     * @param i The index of the `BaseConditionalOrder` to retrieve.
-     * @returns A `BaseConditionalOrder` at the given index.
+     * @param i The index of the `ConditionalOrder` to retrieve.
+     * @returns A `ConditionalOrder` at the given index.
      */
-    getByIndex(i: number): BaseConditionalOrder<any, any>;
+    getByIndex(i: number): ConditionalOrder<unknown, unknown>;
     /**
      * Get all the conditional order ids in the multiplexer.
      */
@@ -213,7 +166,7 @@ export declare class Multiplexer {
      * @param orderType The order type to register.
      * @param conditionalOrderClass The class to use for the given order type.
      */
-    static registerOrderType(orderType: string, conditionalOrderClass: new (...args: any[]) => BaseConditionalOrder<any, any>): void;
+    static registerOrderType(orderType: string, conditionalOrderClass: new (...args: unknown[]) => ConditionalOrder<unknown, unknown>): void;
     /**
      * Reset the order type registry.
      */

package/dist/composable/contracts.d.ts

@@ -0,0 +1,6 @@
+import { providers } from 'ethers';
+import { SupportedChainId } from '../common';
+import { ComposableCoW } from './generated';
+import { ComposableCoWInterface } from './generated/ComposableCoW';
+export declare function getComposableCowInterface(): ComposableCoWInterface;
+export declare function getComposableCow(chain: SupportedChainId, provider: providers.Provider): ComposableCoW;

package/dist/composable/index.d.ts

@@ -1,4 +1,6 @@
-export * from './extensible';
-export * from './multiplexer';
-export * from './conditionalorder';
 export * from './types';
+export * from './utils';
+export * from './ConditionalOrder';
+export * from './Multiplexer';
+export * from './ConditionalOrderFactory';
+export * from './orderTypes';

package/dist/composable/orderTypes/Twap.d.ts

@@ -0,0 +1,222 @@
+import { BigNumber, providers } from 'ethers';
+import { ConditionalOrder } from '../ConditionalOrder';
+import { ConditionalOrderArguments, ConditionalOrderParams, ContextFactory, IsNotValid, IsValid, PollResultErrors } from '../types';
+import { SupportedChainId } from '../../common';
+export declare const TWAP_ADDRESS = "0x6cF1e9cA41f7611dEf408122793c358a3d11E5a5";
+/**
+ * The address of the `CurrentBlockTimestampFactory` contract
+ *
+ * **NOTE**: This is used in the event that TWAP's have a `t0` of `0`.
+ */
+export declare const CURRENT_BLOCK_TIMESTAMP_FACTORY_ADDRESS = "0x52eD56Da04309Aca4c3FECC595298d80C2f16BAc";
+export declare const MAX_UINT32: BigNumber;
+export declare const MAX_FREQUENCY: BigNumber;
+/**
+ * Base parameters for a TWAP order. Shared by:
+ *   - TwapStruct (modeling the contract's struct used for `staticInput`).
+ *   - TwapData (modeling the friendly SDK interface).
+ */
+export type TwapDataBase = {
+    /**
+     * which token to sell
+     */
+    readonly sellToken: string;
+    /**
+     * which token to buy
+     */
+    readonly buyToken: string;
+    /**
+     * who to send the tokens to
+     */
+    readonly receiver: string;
+    /**
+     * Meta-data associated with the order. Normally would be the keccak256 hash of the document generated in http://github.com/cowprotocol/app-data
+     *
+     * This hash should have been uploaded to the API https://api.cow.fi/docs/#/default/put_api_v1_app_data__app_data_hash_ and potentially to other data availability protocols like IPFS.
+     *
+     */
+    readonly appData: string;
+};
+/**
+ * Parameters for a TWAP order, as expected by the contract's `staticInput`.
+ */
+export interface TwapStruct extends TwapDataBase {
+    /**
+     * amount of sellToken to sell in each part
+     */
+    readonly partSellAmount: BigNumber;
+    /**
+     * minimum amount of buyToken that must be bought in each part
+     */
+    readonly minPartLimit: BigNumber;
+    /**
+     * start time of the TWAP
+     */
+    readonly t0: BigNumber;
+    /**
+     * number of parts
+     */
+    readonly n: BigNumber;
+    /**
+     * duration of the TWAP interval
+     */
+    readonly t: BigNumber;
+    /**
+     * whether the TWAP is valid for the entire interval or not
+     */
+    readonly span: BigNumber;
+}
+/**
+ * Parameters for a TWAP order, made a little more user-friendly for SDK users.
+ *
+ * @see {@link TwapStruct} for the native struct.
+ */
+export interface TwapData extends TwapDataBase {
+    /**
+     * total amount of sellToken to sell across the entire TWAP
+     */
+    readonly sellAmount: BigNumber;
+    /**
+     * minimum amount of buyToken that must be bought across the entire TWAP
+     */
+    readonly buyAmount: BigNumber;
+    /**
+     * start time of the TWAP
+     */
+    readonly startTime?: StartTime;
+    /**
+     * number of parts
+     */
+    readonly numberOfParts: BigNumber;
+    /**
+     * duration of the TWAP interval
+     */
+    readonly timeBetweenParts: BigNumber;
+    /**
+     * whether the TWAP is valid for the entire interval or not
+     */
+    readonly durationOfPart?: DurationOfPart;
+}
+export type DurationOfPart = {
+    durationType: DurationType.AUTO;
+} | {
+    durationType: DurationType.LIMIT_DURATION;
+    duration: BigNumber;
+};
+export declare enum DurationType {
+    AUTO = "AUTO",
+    LIMIT_DURATION = "LIMIT_DURATION"
+}
+export type StartTime = {
+    startType: StartTimeValue.AT_MINING_TIME;
+} | {
+    startType: StartTimeValue.AT_EPOC;
+    epoch: BigNumber;
+};
+export declare enum StartTimeValue {
+    AT_MINING_TIME = "AT_MINING_TIME",
+    AT_EPOC = "AT_EPOC"
+}
+/**
+ * `ComposableCoW` implementation of a TWAP order.
+ * @author mfw78 <mfw78@rndlabs.xyz>
+ */
+export declare class Twap extends ConditionalOrder<TwapData, TwapStruct> {
+    /**
+     * @see {@link ConditionalOrder.constructor}
+     * @throws If the TWAP order is invalid.
+     * @throws If the TWAP order is not ABI-encodable.
+     * @throws If the handler is not the TWAP address.
+     */
+    constructor(params: ConditionalOrderArguments<TwapData>);
+    /**
+     * Create a TWAP order with sound defaults.
+     * @param data The TWAP order parameters in a more user-friendly format.
+     * @returns An instance of the TWAP order.
+     */
+    static fromData(data: TwapData): Twap;
+    /**
+     * Create a TWAP order with sound defaults.
+     * @param data The TWAP order parameters in a more user-friendly format.
+     * @returns An instance of the TWAP order.
+     */
+    static fromParams(params: ConditionalOrderParams): Twap;
+    /**
+     * Enforces that TWAPs will commence at the beginning of a block by use of the
+     * `CurrentBlockTimestampFactory` contract to provide the current block timestamp
+     * as the start time of the TWAP.
+     */
+    get context(): ContextFactory | undefined;
+    /**
+     * @inheritdoc {@link ConditionalOrder.orderType}
+     */
+    get orderType(): string;
+    /**
+     * Validate the TWAP order.
+     * @param data The TWAP order to validate.
+     * @returns Whether the TWAP order is valid.
+     * @throws If the TWAP order is invalid.
+     * @see {@link TwapStruct} for the native struct.
+     */
+    isValid(): IsValid | IsNotValid;
+    /**
+     * Checks if the owner authorized the conditional order.
+     *
+     * @param owner The owner of the conditional order.
+     * @param chain Which chain to use for the ComposableCoW contract.
+     * @param provider An RPC provider for the chain.
+     * @returns true if the owner authorized the order, false otherwise.
+     */
+    protected pollValidate(_owner: string, _chain: SupportedChainId, _provider: providers.Provider): Promise<PollResultErrors | undefined>;
+    /**
+     * Serialize the TWAP order into it's ABI-encoded form.
+     * @returns {string} The ABI-encoded TWAP order.
+     */
+    serialize(): string;
+    /**
+     * Get the encoded static input for the TWAP order.
+     * @returns {string} The ABI-encoded TWAP order.
+     */
+    encodeStaticInput(): string;
+    /**
+     * Deserialize a TWAP order from it's ABI-encoded form.
+     * @param {string} twapSerialized ABI-encoded TWAP order to deserialize.
+     * @returns A deserialized TWAP order.
+     */
+    static deserialize(twapSerialized: string): Twap;
+    /**
+     * Create a human-readable string representation of the TWAP order.
+     * @param {((address: string, amount: BigNumber) => string) | undefined} tokenFormatter An optional
+     *        function that takes an address and an amount and returns a human-readable string.
+     * @returns {string} A human-readable string representation of the TWAP order.
+     */
+    toString(tokenFormatter?: (address: string, amount: BigNumber) => string): string;
+    /**
+     * Transform parameters into a native struct.
+     *
+     * @param {TwapData} data As passed by the consumer of the API.
+     * @returns {TwapStruct} A formatted struct as expected by the smart contract.
+     */
+    transformDataToStruct(data: TwapData): TwapStruct;
+    /**
+     * Transform parameters into a TWAP order struct.
+     *
+     * @param {TwapData} params As passed by the consumer of the API.
+     * @returns {TwapStruct} A formatted struct as expected by the smart contract.
+     */
+    transformStructToData(struct: TwapStruct): TwapData;
+}
+/**
+ * Transform parameters into a native struct.
+ *
+ * @param {TwapData} data As passed by the consumer of the API.
+ * @returns {TwapStruct} A formatted struct as expected by the smart contract.
+ */
+export declare function transformDataToStruct(data: TwapData): TwapStruct;
+/**
+ * Transform parameters into a TWAP order struct.
+ *
+ * @param {TwapData} params As passed by the consumer of the API.
+ * @returns {TwapStruct} A formatted struct as expected by the smart contract.
+ */
+export declare function transformStructToData(struct: TwapStruct): TwapData;

package/dist/composable/orderTypes/index.d.ts

@@ -0,0 +1,3 @@
+import { ConditionalOrderRegistry } from '../ConditionalOrderFactory';
+export * from './Twap';
+export declare const DEFAULT_CONDITIONAL_ORDER_REGSTRY: ConditionalOrderRegistry;

package/dist/composable/types.d.ts

@@ -0,0 +1,111 @@
+import { GPv2Order } from './generated/ComposableCoW';
+export interface ConditionalOrderArguments<T> {
+    handler: string;
+    data: T;
+    salt?: string;
+    hasOffChainInput?: boolean;
+}
+export type ConditionalOrderParams = {
+    readonly handler: string;
+    readonly salt: string;
+    readonly staticInput: string;
+};
+export declare enum ProofLocation {
+    PRIVATE = 0,
+    EMITTED = 1,
+    SWARM = 2,
+    WAKU = 3,
+    RESERVED = 4,
+    IPFS = 5
+}
+/**
+ * A factory and it's arguments that are called at transaction mining time to generate the context
+ * for a conditional order(s).
+ *
+ * This allows to support the case where conditional orders may want to *commence* validity at the
+ * time of transaction mining, like in the case of a `TWAP` executed by a DAO or `Safe` that takes
+ * a reasonable amount of time to aggregate signatures or collect votes.
+ *
+ * @remarks This is used in conjunction with `setRootWithContext` or `createWithContext`.
+ */
+export type ContextFactory = {
+    address: string;
+    factoryArgs?: {
+        args: unknown[];
+        argsType: string[];
+    };
+};
+/**
+ * A struct for a proof that can be used with `setRoot` and `setRootWithContext` on a
+ * ComposableCoW-enabled Safe.
+ */
+export type ProofStruct = {
+    location: ProofLocation;
+    data: string | '0x';
+};
+/**
+ * Payload for emitting a merkle root to a ComposableCoW-enabled Safe.
+ *
+ * If setting `ProofLocation.EMITTED`, this type should be used as the `data` in the `Proof` struct.
+ */
+export type PayloadLocationEmitted = {
+    proofs: ProofWithParams[];
+};
+/**
+ * A proof for a conditional order and it's parameters.
+ */
+export type ProofWithParams = {
+    proof: string[];
+    params: ConditionalOrderParams;
+};
+export type PollResult = PollResultSuccess | PollResultErrors;
+export type PollResultErrors = PollResultTryNextBlock | PollResultTryOnBlock | PollResultTryAtEpoch | PollResultUnexpectedError | PollResultDontTryAgain;
+export declare enum PollResultCode {
+    SUCCESS = "SUCCESS",
+    UNEXPECTED_ERROR = "UNEXPECTED_ERROR",
+    TRY_NEXT_BLOCK = "TRY_NEXT_BLOCK",
+    TRY_ON_BLOCK = "TRY_ON_BLOCK",
+    TRY_AT_EPOCH = "TRY_AT_DATE",
+    DONT_TRY_AGAIN = "DONT_TRY_AGAIN"
+}
+export interface PollResultSuccess {
+    readonly result: PollResultCode.SUCCESS;
+    readonly order: GPv2Order.DataStructOutput;
+    readonly signature: string;
+}
+export interface PollResultUnexpectedError {
+    readonly result: PollResultCode.UNEXPECTED_ERROR;
+    readonly error: unknown;
+}
+export interface PollResultTryNextBlock {
+    readonly result: PollResultCode.TRY_NEXT_BLOCK;
+    reason?: string;
+}
+export interface PollResultTryOnBlock {
+    readonly result: PollResultCode.TRY_ON_BLOCK;
+    readonly blockNumber: number;
+    reason?: string;
+}
+export interface PollResultTryAtEpoch {
+    readonly result: PollResultCode.TRY_AT_EPOCH;
+    /**
+     * The epoch after which it is ok to re-try to to poll this order.
+     * The value is expressed as a Unix timestamp (in seconds).
+     *
+     * This epoch will be inclusive, meaning that it is ok to re-try at the block mined pricesely at this epoch or later.
+     */
+    readonly epoch: number;
+    reason?: string;
+}
+export interface PollResultDontTryAgain {
+    readonly result: PollResultCode.DONT_TRY_AGAIN;
+    reason?: string;
+}
+export type IsValidResult = IsValid | IsNotValid;
+export interface IsValid {
+    isValid: true;
+}
+export interface IsNotValid {
+    isValid: false;
+    reason: string;
+}