@cowprotocol/cow-sdk 5.5.1 → 5.6.0

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

@@ -0,0 +1,141 @@
+import type { BaseContract, BigNumber, BigNumberish, BytesLike, CallOverrides, 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 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 TWAPInterface extends utils.Interface {
+    functions: {
+        "getTradeableOrder(address,address,bytes32,bytes,bytes)": FunctionFragment;
+        "supportsInterface(bytes4)": FunctionFragment;
+        "verify(address,address,bytes32,bytes32,bytes32,bytes,bytes,(address,address,address,uint256,uint256,uint32,bytes32,uint256,bytes32,bool,bytes32,bytes32))": FunctionFragment;
+    };
+    getFunction(nameOrSignatureOrTopic: "getTradeableOrder" | "supportsInterface" | "verify"): FunctionFragment;
+    encodeFunctionData(functionFragment: "getTradeableOrder", values: [string, string, BytesLike, BytesLike, BytesLike]): string;
+    encodeFunctionData(functionFragment: "supportsInterface", values: [BytesLike]): string;
+    encodeFunctionData(functionFragment: "verify", values: [
+        string,
+        string,
+        BytesLike,
+        BytesLike,
+        BytesLike,
+        BytesLike,
+        BytesLike,
+        GPv2Order.DataStruct
+    ]): string;
+    decodeFunctionResult(functionFragment: "getTradeableOrder", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "supportsInterface", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "verify", data: BytesLike): Result;
+    events: {
+        "ConditionalOrderCreated(address,(address,bytes32,bytes))": EventFragment;
+    };
+    getEvent(nameOrSignatureOrTopic: "ConditionalOrderCreated"): EventFragment;
+}
+export interface ConditionalOrderCreatedEventObject {
+    owner: string;
+    params: IConditionalOrder.ConditionalOrderParamsStructOutput;
+}
+export type ConditionalOrderCreatedEvent = TypedEvent<[
+    string,
+    IConditionalOrder.ConditionalOrderParamsStructOutput
+], ConditionalOrderCreatedEventObject>;
+export type ConditionalOrderCreatedEventFilter = TypedEventFilter<ConditionalOrderCreatedEvent>;
+export interface TWAP extends BaseContract {
+    connect(signerOrProvider: Signer | Provider | string): this;
+    attach(addressOrName: string): this;
+    deployed(): Promise<this>;
+    interface: TWAPInterface;
+    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: {
+        getTradeableOrder(owner: string, arg1: string, ctx: BytesLike, staticInput: BytesLike, arg4: BytesLike, overrides?: CallOverrides): Promise<[
+            GPv2Order.DataStructOutput
+        ] & {
+            order: GPv2Order.DataStructOutput;
+        }>;
+        supportsInterface(interfaceId: BytesLike, overrides?: CallOverrides): Promise<[boolean]>;
+        verify(owner: string, sender: string, _hash: BytesLike, domainSeparator: BytesLike, ctx: BytesLike, staticInput: BytesLike, offchainInput: BytesLike, arg7: GPv2Order.DataStruct, overrides?: CallOverrides): Promise<[void]>;
+    };
+    getTradeableOrder(owner: string, arg1: string, ctx: BytesLike, staticInput: BytesLike, arg4: BytesLike, overrides?: CallOverrides): Promise<GPv2Order.DataStructOutput>;
+    supportsInterface(interfaceId: BytesLike, overrides?: CallOverrides): Promise<boolean>;
+    verify(owner: string, sender: string, _hash: BytesLike, domainSeparator: BytesLike, ctx: BytesLike, staticInput: BytesLike, offchainInput: BytesLike, arg7: GPv2Order.DataStruct, overrides?: CallOverrides): Promise<void>;
+    callStatic: {
+        getTradeableOrder(owner: string, arg1: string, ctx: BytesLike, staticInput: BytesLike, arg4: BytesLike, overrides?: CallOverrides): Promise<GPv2Order.DataStructOutput>;
+        supportsInterface(interfaceId: BytesLike, overrides?: CallOverrides): Promise<boolean>;
+        verify(owner: string, sender: string, _hash: BytesLike, domainSeparator: BytesLike, ctx: BytesLike, staticInput: BytesLike, offchainInput: BytesLike, arg7: GPv2Order.DataStruct, overrides?: CallOverrides): Promise<void>;
+    };
+    filters: {
+        "ConditionalOrderCreated(address,(address,bytes32,bytes))"(owner?: string | null, params?: null): ConditionalOrderCreatedEventFilter;
+        ConditionalOrderCreated(owner?: string | null, params?: null): ConditionalOrderCreatedEventFilter;
+    };
+    estimateGas: {
+        getTradeableOrder(owner: string, arg1: string, ctx: BytesLike, staticInput: BytesLike, arg4: BytesLike, overrides?: CallOverrides): Promise<BigNumber>;
+        supportsInterface(interfaceId: BytesLike, overrides?: CallOverrides): Promise<BigNumber>;
+        verify(owner: string, sender: string, _hash: BytesLike, domainSeparator: BytesLike, ctx: BytesLike, staticInput: BytesLike, offchainInput: BytesLike, arg7: GPv2Order.DataStruct, overrides?: CallOverrides): Promise<BigNumber>;
+    };
+    populateTransaction: {
+        getTradeableOrder(owner: string, arg1: string, ctx: BytesLike, staticInput: BytesLike, arg4: BytesLike, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        supportsInterface(interfaceId: BytesLike, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        verify(owner: string, sender: string, _hash: BytesLike, domainSeparator: BytesLike, ctx: BytesLike, staticInput: BytesLike, offchainInput: BytesLike, arg7: GPv2Order.DataStruct, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+    };
+}

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

@@ -0,0 +1,21 @@
+import type { Listener } from "@ethersproject/providers";
+import type { Event, EventFilter } from "ethers";
+export interface TypedEvent<TArgsArray extends Array<any> = any, TArgsObject = any> extends Event {
+    args: TArgsArray & TArgsObject;
+}
+export interface TypedEventFilter<_TEvent extends TypedEvent> extends EventFilter {
+}
+export interface TypedListener<TEvent extends TypedEvent> {
+    (...listenerArg: [...__TypechainArgsArray<TEvent>, TEvent]): void;
+}
+type __TypechainArgsArray<T> = T extends TypedEvent<infer U> ? U : never;
+export interface OnEvent<TRes> {
+    <TEvent extends TypedEvent>(eventFilter: TypedEventFilter<TEvent>, listener: TypedListener<TEvent>): TRes;
+    (eventName: string, listener: Listener): TRes;
+}
+export type MinEthersFactory<C, ARGS> = {
+    deploy(...a: ARGS[]): Promise<C>;
+};
+export type GetContractTypeFromFactory<F> = F extends MinEthersFactory<infer C, any> ? C : never;
+export type GetARGsTypeFromFactory<F> = F extends MinEthersFactory<any, any> ? Parameters<F["deploy"]> : never;
+export {};

package/dist/composable/generated/factories/ComposableCoW__factory.d.ts

@@ -0,0 +1,475 @@
+import { Signer } from "ethers";
+import type { Provider } from "@ethersproject/providers";
+import type { ComposableCoW, ComposableCoWInterface } from "../ComposableCoW";
+export declare class ComposableCoW__factory {
+    static readonly abi: readonly [{
+        readonly inputs: readonly [{
+            readonly internalType: "address";
+            readonly name: "_settlement";
+            readonly type: "address";
+        }];
+        readonly stateMutability: "nonpayable";
+        readonly type: "constructor";
+    }, {
+        readonly inputs: readonly [];
+        readonly name: "InterfaceNotSupported";
+        readonly type: "error";
+    }, {
+        readonly inputs: readonly [];
+        readonly name: "InvalidHandler";
+        readonly type: "error";
+    }, {
+        readonly inputs: readonly [];
+        readonly name: "ProofNotAuthed";
+        readonly type: "error";
+    }, {
+        readonly inputs: readonly [];
+        readonly name: "SingleOrderNotAuthed";
+        readonly type: "error";
+    }, {
+        readonly inputs: readonly [];
+        readonly name: "SwapGuardRestricted";
+        readonly type: "error";
+    }, {
+        readonly anonymous: false;
+        readonly inputs: readonly [{
+            readonly indexed: true;
+            readonly internalType: "address";
+            readonly name: "owner";
+            readonly type: "address";
+        }, {
+            readonly components: readonly [{
+                readonly internalType: "contract IConditionalOrder";
+                readonly name: "handler";
+                readonly type: "address";
+            }, {
+                readonly internalType: "bytes32";
+                readonly name: "salt";
+                readonly type: "bytes32";
+            }, {
+                readonly internalType: "bytes";
+                readonly name: "staticInput";
+                readonly type: "bytes";
+            }];
+            readonly indexed: false;
+            readonly internalType: "struct IConditionalOrder.ConditionalOrderParams";
+            readonly name: "params";
+            readonly type: "tuple";
+        }];
+        readonly name: "ConditionalOrderCreated";
+        readonly type: "event";
+    }, {
+        readonly anonymous: false;
+        readonly inputs: readonly [{
+            readonly indexed: true;
+            readonly internalType: "address";
+            readonly name: "owner";
+            readonly type: "address";
+        }, {
+            readonly indexed: false;
+            readonly internalType: "bytes32";
+            readonly name: "root";
+            readonly type: "bytes32";
+        }, {
+            readonly components: readonly [{
+                readonly internalType: "uint256";
+                readonly name: "location";
+                readonly type: "uint256";
+            }, {
+                readonly internalType: "bytes";
+                readonly name: "data";
+                readonly type: "bytes";
+            }];
+            readonly indexed: false;
+            readonly internalType: "struct ComposableCoW.Proof";
+            readonly name: "proof";
+            readonly type: "tuple";
+        }];
+        readonly name: "MerkleRootSet";
+        readonly type: "event";
+    }, {
+        readonly anonymous: false;
+        readonly inputs: readonly [{
+            readonly indexed: true;
+            readonly internalType: "address";
+            readonly name: "owner";
+            readonly type: "address";
+        }, {
+            readonly indexed: false;
+            readonly internalType: "contract ISwapGuard";
+            readonly name: "swapGuard";
+            readonly type: "address";
+        }];
+        readonly name: "SwapGuardSet";
+        readonly type: "event";
+    }, {
+        readonly inputs: readonly [{
+            readonly internalType: "address";
+            readonly name: "";
+            readonly type: "address";
+        }, {
+            readonly internalType: "bytes32";
+            readonly name: "";
+            readonly type: "bytes32";
+        }];
+        readonly name: "cabinet";
+        readonly outputs: readonly [{
+            readonly internalType: "bytes32";
+            readonly name: "";
+            readonly type: "bytes32";
+        }];
+        readonly stateMutability: "view";
+        readonly type: "function";
+    }, {
+        readonly inputs: readonly [{
+            readonly components: readonly [{
+                readonly internalType: "contract IConditionalOrder";
+                readonly name: "handler";
+                readonly type: "address";
+            }, {
+                readonly internalType: "bytes32";
+                readonly name: "salt";
+                readonly type: "bytes32";
+            }, {
+                readonly internalType: "bytes";
+                readonly name: "staticInput";
+                readonly type: "bytes";
+            }];
+            readonly internalType: "struct IConditionalOrder.ConditionalOrderParams";
+            readonly name: "params";
+            readonly type: "tuple";
+        }, {
+            readonly internalType: "bool";
+            readonly name: "dispatch";
+            readonly type: "bool";
+        }];
+        readonly name: "create";
+        readonly outputs: readonly [];
+        readonly stateMutability: "nonpayable";
+        readonly type: "function";
+    }, {
+        readonly inputs: readonly [{
+            readonly components: readonly [{
+                readonly internalType: "contract IConditionalOrder";
+                readonly name: "handler";
+                readonly type: "address";
+            }, {
+                readonly internalType: "bytes32";
+                readonly name: "salt";
+                readonly type: "bytes32";
+            }, {
+                readonly internalType: "bytes";
+                readonly name: "staticInput";
+                readonly type: "bytes";
+            }];
+            readonly internalType: "struct IConditionalOrder.ConditionalOrderParams";
+            readonly name: "params";
+            readonly type: "tuple";
+        }, {
+            readonly internalType: "contract IValueFactory";
+            readonly name: "factory";
+            readonly type: "address";
+        }, {
+            readonly internalType: "bytes";
+            readonly name: "data";
+            readonly type: "bytes";
+        }, {
+            readonly internalType: "bool";
+            readonly name: "dispatch";
+            readonly type: "bool";
+        }];
+        readonly name: "createWithContext";
+        readonly outputs: readonly [];
+        readonly stateMutability: "nonpayable";
+        readonly type: "function";
+    }, {
+        readonly inputs: readonly [];
+        readonly name: "domainSeparator";
+        readonly outputs: readonly [{
+            readonly internalType: "bytes32";
+            readonly name: "";
+            readonly type: "bytes32";
+        }];
+        readonly stateMutability: "view";
+        readonly type: "function";
+    }, {
+        readonly inputs: readonly [{
+            readonly internalType: "address";
+            readonly name: "owner";
+            readonly type: "address";
+        }, {
+            readonly components: readonly [{
+                readonly internalType: "contract IConditionalOrder";
+                readonly name: "handler";
+                readonly type: "address";
+            }, {
+                readonly internalType: "bytes32";
+                readonly name: "salt";
+                readonly type: "bytes32";
+            }, {
+                readonly internalType: "bytes";
+                readonly name: "staticInput";
+                readonly type: "bytes";
+            }];
+            readonly internalType: "struct IConditionalOrder.ConditionalOrderParams";
+            readonly name: "params";
+            readonly type: "tuple";
+        }, {
+            readonly internalType: "bytes";
+            readonly name: "offchainInput";
+            readonly type: "bytes";
+        }, {
+            readonly internalType: "bytes32[]";
+            readonly name: "proof";
+            readonly type: "bytes32[]";
+        }];
+        readonly name: "getTradeableOrderWithSignature";
+        readonly outputs: readonly [{
+            readonly components: readonly [{
+                readonly internalType: "contract IERC20";
+                readonly name: "sellToken";
+                readonly type: "address";
+            }, {
+                readonly internalType: "contract IERC20";
+                readonly name: "buyToken";
+                readonly type: "address";
+            }, {
+                readonly internalType: "address";
+                readonly name: "receiver";
+                readonly type: "address";
+            }, {
+                readonly internalType: "uint256";
+                readonly name: "sellAmount";
+                readonly type: "uint256";
+            }, {
+                readonly internalType: "uint256";
+                readonly name: "buyAmount";
+                readonly type: "uint256";
+            }, {
+                readonly internalType: "uint32";
+                readonly name: "validTo";
+                readonly type: "uint32";
+            }, {
+                readonly internalType: "bytes32";
+                readonly name: "appData";
+                readonly type: "bytes32";
+            }, {
+                readonly internalType: "uint256";
+                readonly name: "feeAmount";
+                readonly type: "uint256";
+            }, {
+                readonly internalType: "bytes32";
+                readonly name: "kind";
+                readonly type: "bytes32";
+            }, {
+                readonly internalType: "bool";
+                readonly name: "partiallyFillable";
+                readonly type: "bool";
+            }, {
+                readonly internalType: "bytes32";
+                readonly name: "sellTokenBalance";
+                readonly type: "bytes32";
+            }, {
+                readonly internalType: "bytes32";
+                readonly name: "buyTokenBalance";
+                readonly type: "bytes32";
+            }];
+            readonly internalType: "struct GPv2Order.Data";
+            readonly name: "order";
+            readonly type: "tuple";
+        }, {
+            readonly internalType: "bytes";
+            readonly name: "signature";
+            readonly type: "bytes";
+        }];
+        readonly stateMutability: "view";
+        readonly type: "function";
+    }, {
+        readonly inputs: readonly [{
+            readonly components: readonly [{
+                readonly internalType: "contract IConditionalOrder";
+                readonly name: "handler";
+                readonly type: "address";
+            }, {
+                readonly internalType: "bytes32";
+                readonly name: "salt";
+                readonly type: "bytes32";
+            }, {
+                readonly internalType: "bytes";
+                readonly name: "staticInput";
+                readonly type: "bytes";
+            }];
+            readonly internalType: "struct IConditionalOrder.ConditionalOrderParams";
+            readonly name: "params";
+            readonly type: "tuple";
+        }];
+        readonly name: "hash";
+        readonly outputs: readonly [{
+            readonly internalType: "bytes32";
+            readonly name: "";
+            readonly type: "bytes32";
+        }];
+        readonly stateMutability: "pure";
+        readonly type: "function";
+    }, {
+        readonly inputs: readonly [{
+            readonly internalType: "contract Safe";
+            readonly name: "safe";
+            readonly type: "address";
+        }, {
+            readonly internalType: "address";
+            readonly name: "sender";
+            readonly type: "address";
+        }, {
+            readonly internalType: "bytes32";
+            readonly name: "_hash";
+            readonly type: "bytes32";
+        }, {
+            readonly internalType: "bytes32";
+            readonly name: "_domainSeparator";
+            readonly type: "bytes32";
+        }, {
+            readonly internalType: "bytes32";
+            readonly name: "";
+            readonly type: "bytes32";
+        }, {
+            readonly internalType: "bytes";
+            readonly name: "encodeData";
+            readonly type: "bytes";
+        }, {
+            readonly internalType: "bytes";
+            readonly name: "payload";
+            readonly type: "bytes";
+        }];
+        readonly name: "isValidSafeSignature";
+        readonly outputs: readonly [{
+            readonly internalType: "bytes4";
+            readonly name: "magic";
+            readonly type: "bytes4";
+        }];
+        readonly stateMutability: "view";
+        readonly type: "function";
+    }, {
+        readonly inputs: readonly [{
+            readonly internalType: "bytes32";
+            readonly name: "singleOrderHash";
+            readonly type: "bytes32";
+        }];
+        readonly name: "remove";
+        readonly outputs: readonly [];
+        readonly stateMutability: "nonpayable";
+        readonly type: "function";
+    }, {
+        readonly inputs: readonly [{
+            readonly internalType: "address";
+            readonly name: "";
+            readonly type: "address";
+        }];
+        readonly name: "roots";
+        readonly outputs: readonly [{
+            readonly internalType: "bytes32";
+            readonly name: "";
+            readonly type: "bytes32";
+        }];
+        readonly stateMutability: "view";
+        readonly type: "function";
+    }, {
+        readonly inputs: readonly [{
+            readonly internalType: "bytes32";
+            readonly name: "root";
+            readonly type: "bytes32";
+        }, {
+            readonly components: readonly [{
+                readonly internalType: "uint256";
+                readonly name: "location";
+                readonly type: "uint256";
+            }, {
+                readonly internalType: "bytes";
+                readonly name: "data";
+                readonly type: "bytes";
+            }];
+            readonly internalType: "struct ComposableCoW.Proof";
+            readonly name: "proof";
+            readonly type: "tuple";
+        }];
+        readonly name: "setRoot";
+        readonly outputs: readonly [];
+        readonly stateMutability: "nonpayable";
+        readonly type: "function";
+    }, {
+        readonly inputs: readonly [{
+            readonly internalType: "bytes32";
+            readonly name: "root";
+            readonly type: "bytes32";
+        }, {
+            readonly components: readonly [{
+                readonly internalType: "uint256";
+                readonly name: "location";
+                readonly type: "uint256";
+            }, {
+                readonly internalType: "bytes";
+                readonly name: "data";
+                readonly type: "bytes";
+            }];
+            readonly internalType: "struct ComposableCoW.Proof";
+            readonly name: "proof";
+            readonly type: "tuple";
+        }, {
+            readonly internalType: "contract IValueFactory";
+            readonly name: "factory";
+            readonly type: "address";
+        }, {
+            readonly internalType: "bytes";
+            readonly name: "data";
+            readonly type: "bytes";
+        }];
+        readonly name: "setRootWithContext";
+        readonly outputs: readonly [];
+        readonly stateMutability: "nonpayable";
+        readonly type: "function";
+    }, {
+        readonly inputs: readonly [{
+            readonly internalType: "contract ISwapGuard";
+            readonly name: "swapGuard";
+            readonly type: "address";
+        }];
+        readonly name: "setSwapGuard";
+        readonly outputs: readonly [];
+        readonly stateMutability: "nonpayable";
+        readonly type: "function";
+    }, {
+        readonly inputs: readonly [{
+            readonly internalType: "address";
+            readonly name: "";
+            readonly type: "address";
+        }, {
+            readonly internalType: "bytes32";
+            readonly name: "";
+            readonly type: "bytes32";
+        }];
+        readonly name: "singleOrders";
+        readonly outputs: readonly [{
+            readonly internalType: "bool";
+            readonly name: "";
+            readonly type: "bool";
+        }];
+        readonly stateMutability: "view";
+        readonly type: "function";
+    }, {
+        readonly inputs: readonly [{
+            readonly internalType: "address";
+            readonly name: "";
+            readonly type: "address";
+        }];
+        readonly name: "swapGuards";
+        readonly outputs: readonly [{
+            readonly internalType: "contract ISwapGuard";
+            readonly name: "";
+            readonly type: "address";
+        }];
+        readonly stateMutability: "view";
+        readonly type: "function";
+    }];
+    static createInterface(): ComposableCoWInterface;
+    static connect(address: string, signerOrProvider: Signer | Provider): ComposableCoW;
+}