@cowprotocol/cow-sdk 5.4.1-RC.0 → 5.5.1

package/dist/common/consts.d.ts

@@ -2,6 +2,8 @@ import { SupportedChainId } from './chains';
 export declare const BUY_ETH_ADDRESS = "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE";
 export declare const EXTENSIBLE_FALLBACK_HANDLER = "0x2f55e8b20D0B9FEFA187AA7d00B6Cbe563605bF5";
 export declare const COMPOSABLE_COW = "0xfdaFc9d1902f4e0b84f65F49f244b32b31013b74";
+export declare const COW_SHED_FACTORY = "0x00E989b87700514118Fa55326CD1cCE82faebEF6";
+export declare const COW_SHED_IMPLEMENTATION = "0x2CFFA8cf11B90C9F437567b86352169dF4009F73";
 /**
  * The list of supported chains.
  */

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

@@ -0,0 +1,219 @@
+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 type CallStruct = {
+    target: string;
+    value: BigNumberish;
+    callData: BytesLike;
+    allowFailure: boolean;
+    isDelegateCall: boolean;
+};
+export type CallStructOutput = [string, BigNumber, string, boolean, boolean] & {
+    target: string;
+    value: BigNumber;
+    callData: string;
+    allowFailure: boolean;
+    isDelegateCall: boolean;
+};
+export interface CoWShedInterface extends utils.Interface {
+    functions: {
+        "claimWithResolver(address)": FunctionFragment;
+        "domainSeparator()": FunctionFragment;
+        "executeHooks((address,uint256,bytes,bool,bool)[],bytes32,uint256,bytes)": FunctionFragment;
+        "initialize(address,bool)": FunctionFragment;
+        "nonces(bytes32)": FunctionFragment;
+        "revokeNonce(bytes32)": FunctionFragment;
+        "trustedExecuteHooks((address,uint256,bytes,bool,bool)[])": FunctionFragment;
+        "trustedExecutor()": FunctionFragment;
+        "updateImplementation(address)": FunctionFragment;
+        "updateTrustedExecutor(address)": FunctionFragment;
+    };
+    getFunction(nameOrSignatureOrTopic: "claimWithResolver" | "domainSeparator" | "executeHooks" | "initialize" | "nonces" | "revokeNonce" | "trustedExecuteHooks" | "trustedExecutor" | "updateImplementation" | "updateTrustedExecutor"): FunctionFragment;
+    encodeFunctionData(functionFragment: "claimWithResolver", values: [string]): string;
+    encodeFunctionData(functionFragment: "domainSeparator", values?: undefined): string;
+    encodeFunctionData(functionFragment: "executeHooks", values: [CallStruct[], BytesLike, BigNumberish, BytesLike]): string;
+    encodeFunctionData(functionFragment: "initialize", values: [string, boolean]): string;
+    encodeFunctionData(functionFragment: "nonces", values: [BytesLike]): string;
+    encodeFunctionData(functionFragment: "revokeNonce", values: [BytesLike]): string;
+    encodeFunctionData(functionFragment: "trustedExecuteHooks", values: [CallStruct[]]): string;
+    encodeFunctionData(functionFragment: "trustedExecutor", values?: undefined): string;
+    encodeFunctionData(functionFragment: "updateImplementation", values: [string]): string;
+    encodeFunctionData(functionFragment: "updateTrustedExecutor", values: [string]): string;
+    decodeFunctionResult(functionFragment: "claimWithResolver", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "domainSeparator", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "executeHooks", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "initialize", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "nonces", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "revokeNonce", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "trustedExecuteHooks", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "trustedExecutor", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "updateImplementation", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "updateTrustedExecutor", data: BytesLike): Result;
+    events: {
+        "RSV(bytes32,bytes32,uint8)": EventFragment;
+        "TrustedExecutorChanged(address,address)": EventFragment;
+        "Upgraded(address)": EventFragment;
+    };
+    getEvent(nameOrSignatureOrTopic: "RSV"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "TrustedExecutorChanged"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "Upgraded"): EventFragment;
+}
+export interface RSVEventObject {
+    r: string;
+    s: string;
+    v: number;
+}
+export type RSVEvent = TypedEvent<[string, string, number], RSVEventObject>;
+export type RSVEventFilter = TypedEventFilter<RSVEvent>;
+export interface TrustedExecutorChangedEventObject {
+    previousExecutor: string;
+    newExecutor: string;
+}
+export type TrustedExecutorChangedEvent = TypedEvent<[
+    string,
+    string
+], TrustedExecutorChangedEventObject>;
+export type TrustedExecutorChangedEventFilter = TypedEventFilter<TrustedExecutorChangedEvent>;
+export interface UpgradedEventObject {
+    implementation: string;
+}
+export type UpgradedEvent = TypedEvent<[string], UpgradedEventObject>;
+export type UpgradedEventFilter = TypedEventFilter<UpgradedEvent>;
+export interface CoWShed extends BaseContract {
+    connect(signerOrProvider: Signer | Provider | string): this;
+    attach(addressOrName: string): this;
+    deployed(): Promise<this>;
+    interface: CoWShedInterface;
+    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: {
+        claimWithResolver(resolver: string, overrides?: Overrides & {
+            from?: string;
+        }): Promise<ContractTransaction>;
+        domainSeparator(overrides?: CallOverrides): Promise<[string]>;
+        executeHooks(calls: CallStruct[], nonce: BytesLike, deadline: BigNumberish, signature: BytesLike, overrides?: Overrides & {
+            from?: string;
+        }): Promise<ContractTransaction>;
+        initialize(factory: string, claimResolver: boolean, overrides?: Overrides & {
+            from?: string;
+        }): Promise<ContractTransaction>;
+        nonces(nonce: BytesLike, overrides?: CallOverrides): Promise<[boolean]>;
+        revokeNonce(nonce: BytesLike, overrides?: Overrides & {
+            from?: string;
+        }): Promise<ContractTransaction>;
+        trustedExecuteHooks(calls: CallStruct[], overrides?: Overrides & {
+            from?: string;
+        }): Promise<ContractTransaction>;
+        trustedExecutor(overrides?: CallOverrides): Promise<[string]>;
+        updateImplementation(newImplementation: string, overrides?: Overrides & {
+            from?: string;
+        }): Promise<ContractTransaction>;
+        updateTrustedExecutor(who: string, overrides?: Overrides & {
+            from?: string;
+        }): Promise<ContractTransaction>;
+    };
+    claimWithResolver(resolver: string, overrides?: Overrides & {
+        from?: string;
+    }): Promise<ContractTransaction>;
+    domainSeparator(overrides?: CallOverrides): Promise<string>;
+    executeHooks(calls: CallStruct[], nonce: BytesLike, deadline: BigNumberish, signature: BytesLike, overrides?: Overrides & {
+        from?: string;
+    }): Promise<ContractTransaction>;
+    initialize(factory: string, claimResolver: boolean, overrides?: Overrides & {
+        from?: string;
+    }): Promise<ContractTransaction>;
+    nonces(nonce: BytesLike, overrides?: CallOverrides): Promise<boolean>;
+    revokeNonce(nonce: BytesLike, overrides?: Overrides & {
+        from?: string;
+    }): Promise<ContractTransaction>;
+    trustedExecuteHooks(calls: CallStruct[], overrides?: Overrides & {
+        from?: string;
+    }): Promise<ContractTransaction>;
+    trustedExecutor(overrides?: CallOverrides): Promise<string>;
+    updateImplementation(newImplementation: string, overrides?: Overrides & {
+        from?: string;
+    }): Promise<ContractTransaction>;
+    updateTrustedExecutor(who: string, overrides?: Overrides & {
+        from?: string;
+    }): Promise<ContractTransaction>;
+    callStatic: {
+        claimWithResolver(resolver: string, overrides?: CallOverrides): Promise<void>;
+        domainSeparator(overrides?: CallOverrides): Promise<string>;
+        executeHooks(calls: CallStruct[], nonce: BytesLike, deadline: BigNumberish, signature: BytesLike, overrides?: CallOverrides): Promise<void>;
+        initialize(factory: string, claimResolver: boolean, overrides?: CallOverrides): Promise<void>;
+        nonces(nonce: BytesLike, overrides?: CallOverrides): Promise<boolean>;
+        revokeNonce(nonce: BytesLike, overrides?: CallOverrides): Promise<void>;
+        trustedExecuteHooks(calls: CallStruct[], overrides?: CallOverrides): Promise<void>;
+        trustedExecutor(overrides?: CallOverrides): Promise<string>;
+        updateImplementation(newImplementation: string, overrides?: CallOverrides): Promise<void>;
+        updateTrustedExecutor(who: string, overrides?: CallOverrides): Promise<void>;
+    };
+    filters: {
+        "RSV(bytes32,bytes32,uint8)"(r?: null, s?: null, v?: null): RSVEventFilter;
+        RSV(r?: null, s?: null, v?: null): RSVEventFilter;
+        "TrustedExecutorChanged(address,address)"(previousExecutor?: null, newExecutor?: null): TrustedExecutorChangedEventFilter;
+        TrustedExecutorChanged(previousExecutor?: null, newExecutor?: null): TrustedExecutorChangedEventFilter;
+        "Upgraded(address)"(implementation?: string | null): UpgradedEventFilter;
+        Upgraded(implementation?: string | null): UpgradedEventFilter;
+    };
+    estimateGas: {
+        claimWithResolver(resolver: string, overrides?: Overrides & {
+            from?: string;
+        }): Promise<BigNumber>;
+        domainSeparator(overrides?: CallOverrides): Promise<BigNumber>;
+        executeHooks(calls: CallStruct[], nonce: BytesLike, deadline: BigNumberish, signature: BytesLike, overrides?: Overrides & {
+            from?: string;
+        }): Promise<BigNumber>;
+        initialize(factory: string, claimResolver: boolean, overrides?: Overrides & {
+            from?: string;
+        }): Promise<BigNumber>;
+        nonces(nonce: BytesLike, overrides?: CallOverrides): Promise<BigNumber>;
+        revokeNonce(nonce: BytesLike, overrides?: Overrides & {
+            from?: string;
+        }): Promise<BigNumber>;
+        trustedExecuteHooks(calls: CallStruct[], overrides?: Overrides & {
+            from?: string;
+        }): Promise<BigNumber>;
+        trustedExecutor(overrides?: CallOverrides): Promise<BigNumber>;
+        updateImplementation(newImplementation: string, overrides?: Overrides & {
+            from?: string;
+        }): Promise<BigNumber>;
+        updateTrustedExecutor(who: string, overrides?: Overrides & {
+            from?: string;
+        }): Promise<BigNumber>;
+    };
+    populateTransaction: {
+        claimWithResolver(resolver: string, overrides?: Overrides & {
+            from?: string;
+        }): Promise<PopulatedTransaction>;
+        domainSeparator(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        executeHooks(calls: CallStruct[], nonce: BytesLike, deadline: BigNumberish, signature: BytesLike, overrides?: Overrides & {
+            from?: string;
+        }): Promise<PopulatedTransaction>;
+        initialize(factory: string, claimResolver: boolean, overrides?: Overrides & {
+            from?: string;
+        }): Promise<PopulatedTransaction>;
+        nonces(nonce: BytesLike, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        revokeNonce(nonce: BytesLike, overrides?: Overrides & {
+            from?: string;
+        }): Promise<PopulatedTransaction>;
+        trustedExecuteHooks(calls: CallStruct[], overrides?: Overrides & {
+            from?: string;
+        }): Promise<PopulatedTransaction>;
+        trustedExecutor(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        updateImplementation(newImplementation: string, overrides?: Overrides & {
+            from?: string;
+        }): Promise<PopulatedTransaction>;
+        updateTrustedExecutor(who: string, overrides?: Overrides & {
+            from?: string;
+        }): Promise<PopulatedTransaction>;
+    };
+}

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

@@ -0,0 +1,191 @@
+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 type CallStruct = {
+    target: string;
+    value: BigNumberish;
+    callData: BytesLike;
+    allowFailure: boolean;
+    isDelegateCall: boolean;
+};
+export type CallStructOutput = [string, BigNumber, string, boolean, boolean] & {
+    target: string;
+    value: BigNumber;
+    callData: string;
+    allowFailure: boolean;
+    isDelegateCall: boolean;
+};
+export interface CoWShedFactoryInterface extends utils.Interface {
+    functions: {
+        "addr(bytes32)": FunctionFragment;
+        "baseName()": FunctionFragment;
+        "baseNode()": FunctionFragment;
+        "executeHooks((address,uint256,bytes,bool,bool)[],bytes32,uint256,address,bytes)": FunctionFragment;
+        "forwardResolutionNodeToAddress(bytes32)": FunctionFragment;
+        "implementation()": FunctionFragment;
+        "initializeEns(address)": FunctionFragment;
+        "initializeProxy(address,bool)": FunctionFragment;
+        "name(bytes32)": FunctionFragment;
+        "ownerOf(address)": FunctionFragment;
+        "proxyOf(address)": FunctionFragment;
+        "reverseResolutionNodeToAddress(bytes32)": FunctionFragment;
+        "supportsInterface(bytes4)": FunctionFragment;
+    };
+    getFunction(nameOrSignatureOrTopic: "addr" | "baseName" | "baseNode" | "executeHooks" | "forwardResolutionNodeToAddress" | "implementation" | "initializeEns" | "initializeProxy" | "name" | "ownerOf" | "proxyOf" | "reverseResolutionNodeToAddress" | "supportsInterface"): FunctionFragment;
+    encodeFunctionData(functionFragment: "addr", values: [BytesLike]): string;
+    encodeFunctionData(functionFragment: "baseName", values?: undefined): string;
+    encodeFunctionData(functionFragment: "baseNode", values?: undefined): string;
+    encodeFunctionData(functionFragment: "executeHooks", values: [CallStruct[], BytesLike, BigNumberish, string, BytesLike]): string;
+    encodeFunctionData(functionFragment: "forwardResolutionNodeToAddress", values: [BytesLike]): string;
+    encodeFunctionData(functionFragment: "implementation", values?: undefined): string;
+    encodeFunctionData(functionFragment: "initializeEns", values: [string]): string;
+    encodeFunctionData(functionFragment: "initializeProxy", values: [string, boolean]): string;
+    encodeFunctionData(functionFragment: "name", values: [BytesLike]): string;
+    encodeFunctionData(functionFragment: "ownerOf", values: [string]): string;
+    encodeFunctionData(functionFragment: "proxyOf", values: [string]): string;
+    encodeFunctionData(functionFragment: "reverseResolutionNodeToAddress", values: [BytesLike]): string;
+    encodeFunctionData(functionFragment: "supportsInterface", values: [BytesLike]): string;
+    decodeFunctionResult(functionFragment: "addr", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "baseName", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "baseNode", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "executeHooks", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "forwardResolutionNodeToAddress", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "implementation", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "initializeEns", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "initializeProxy", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "name", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "ownerOf", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "proxyOf", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "reverseResolutionNodeToAddress", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "supportsInterface", data: BytesLike): Result;
+    events: {
+        "COWShedBuilt(address,address)": EventFragment;
+    };
+    getEvent(nameOrSignatureOrTopic: "COWShedBuilt"): EventFragment;
+}
+export interface COWShedBuiltEventObject {
+    user: string;
+    shed: string;
+}
+export type COWShedBuiltEvent = TypedEvent<[
+    string,
+    string
+], COWShedBuiltEventObject>;
+export type COWShedBuiltEventFilter = TypedEventFilter<COWShedBuiltEvent>;
+export interface CoWShedFactory extends BaseContract {
+    connect(signerOrProvider: Signer | Provider | string): this;
+    attach(addressOrName: string): this;
+    deployed(): Promise<this>;
+    interface: CoWShedFactoryInterface;
+    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: {
+        addr(node: BytesLike, overrides?: CallOverrides): Promise<[string]>;
+        baseName(overrides?: CallOverrides): Promise<[string]>;
+        baseNode(overrides?: CallOverrides): Promise<[string]>;
+        executeHooks(calls: CallStruct[], nonce: BytesLike, deadline: BigNumberish, user: string, signature: BytesLike, overrides?: Overrides & {
+            from?: string;
+        }): Promise<ContractTransaction>;
+        forwardResolutionNodeToAddress(arg0: BytesLike, overrides?: CallOverrides): Promise<[string]>;
+        implementation(overrides?: CallOverrides): Promise<[string]>;
+        initializeEns(user: string, overrides?: Overrides & {
+            from?: string;
+        }): Promise<ContractTransaction>;
+        initializeProxy(user: string, withEns: boolean, overrides?: Overrides & {
+            from?: string;
+        }): Promise<ContractTransaction>;
+        name(node: BytesLike, overrides?: CallOverrides): Promise<[string]>;
+        ownerOf(arg0: string, overrides?: CallOverrides): Promise<[string]>;
+        proxyOf(who: string, overrides?: CallOverrides): Promise<[string]>;
+        reverseResolutionNodeToAddress(arg0: BytesLike, overrides?: CallOverrides): Promise<[string]>;
+        supportsInterface(interfaceId: BytesLike, overrides?: CallOverrides): Promise<[boolean]>;
+    };
+    addr(node: BytesLike, overrides?: CallOverrides): Promise<string>;
+    baseName(overrides?: CallOverrides): Promise<string>;
+    baseNode(overrides?: CallOverrides): Promise<string>;
+    executeHooks(calls: CallStruct[], nonce: BytesLike, deadline: BigNumberish, user: string, signature: BytesLike, overrides?: Overrides & {
+        from?: string;
+    }): Promise<ContractTransaction>;
+    forwardResolutionNodeToAddress(arg0: BytesLike, overrides?: CallOverrides): Promise<string>;
+    implementation(overrides?: CallOverrides): Promise<string>;
+    initializeEns(user: string, overrides?: Overrides & {
+        from?: string;
+    }): Promise<ContractTransaction>;
+    initializeProxy(user: string, withEns: boolean, overrides?: Overrides & {
+        from?: string;
+    }): Promise<ContractTransaction>;
+    name(node: BytesLike, overrides?: CallOverrides): Promise<string>;
+    ownerOf(arg0: string, overrides?: CallOverrides): Promise<string>;
+    proxyOf(who: string, overrides?: CallOverrides): Promise<string>;
+    reverseResolutionNodeToAddress(arg0: BytesLike, overrides?: CallOverrides): Promise<string>;
+    supportsInterface(interfaceId: BytesLike, overrides?: CallOverrides): Promise<boolean>;
+    callStatic: {
+        addr(node: BytesLike, overrides?: CallOverrides): Promise<string>;
+        baseName(overrides?: CallOverrides): Promise<string>;
+        baseNode(overrides?: CallOverrides): Promise<string>;
+        executeHooks(calls: CallStruct[], nonce: BytesLike, deadline: BigNumberish, user: string, signature: BytesLike, overrides?: CallOverrides): Promise<void>;
+        forwardResolutionNodeToAddress(arg0: BytesLike, overrides?: CallOverrides): Promise<string>;
+        implementation(overrides?: CallOverrides): Promise<string>;
+        initializeEns(user: string, overrides?: CallOverrides): Promise<void>;
+        initializeProxy(user: string, withEns: boolean, overrides?: CallOverrides): Promise<void>;
+        name(node: BytesLike, overrides?: CallOverrides): Promise<string>;
+        ownerOf(arg0: string, overrides?: CallOverrides): Promise<string>;
+        proxyOf(who: string, overrides?: CallOverrides): Promise<string>;
+        reverseResolutionNodeToAddress(arg0: BytesLike, overrides?: CallOverrides): Promise<string>;
+        supportsInterface(interfaceId: BytesLike, overrides?: CallOverrides): Promise<boolean>;
+    };
+    filters: {
+        "COWShedBuilt(address,address)"(user?: null, shed?: null): COWShedBuiltEventFilter;
+        COWShedBuilt(user?: null, shed?: null): COWShedBuiltEventFilter;
+    };
+    estimateGas: {
+        addr(node: BytesLike, overrides?: CallOverrides): Promise<BigNumber>;
+        baseName(overrides?: CallOverrides): Promise<BigNumber>;
+        baseNode(overrides?: CallOverrides): Promise<BigNumber>;
+        executeHooks(calls: CallStruct[], nonce: BytesLike, deadline: BigNumberish, user: string, signature: BytesLike, overrides?: Overrides & {
+            from?: string;
+        }): Promise<BigNumber>;
+        forwardResolutionNodeToAddress(arg0: BytesLike, overrides?: CallOverrides): Promise<BigNumber>;
+        implementation(overrides?: CallOverrides): Promise<BigNumber>;
+        initializeEns(user: string, overrides?: Overrides & {
+            from?: string;
+        }): Promise<BigNumber>;
+        initializeProxy(user: string, withEns: boolean, overrides?: Overrides & {
+            from?: string;
+        }): Promise<BigNumber>;
+        name(node: BytesLike, overrides?: CallOverrides): Promise<BigNumber>;
+        ownerOf(arg0: string, overrides?: CallOverrides): Promise<BigNumber>;
+        proxyOf(who: string, overrides?: CallOverrides): Promise<BigNumber>;
+        reverseResolutionNodeToAddress(arg0: BytesLike, overrides?: CallOverrides): Promise<BigNumber>;
+        supportsInterface(interfaceId: BytesLike, overrides?: CallOverrides): Promise<BigNumber>;
+    };
+    populateTransaction: {
+        addr(node: BytesLike, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        baseName(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        baseNode(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        executeHooks(calls: CallStruct[], nonce: BytesLike, deadline: BigNumberish, user: string, signature: BytesLike, overrides?: Overrides & {
+            from?: string;
+        }): Promise<PopulatedTransaction>;
+        forwardResolutionNodeToAddress(arg0: BytesLike, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        implementation(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        initializeEns(user: string, overrides?: Overrides & {
+            from?: string;
+        }): Promise<PopulatedTransaction>;
+        initializeProxy(user: string, withEns: boolean, overrides?: Overrides & {
+            from?: string;
+        }): Promise<PopulatedTransaction>;
+        name(node: BytesLike, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        ownerOf(arg0: string, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        proxyOf(who: string, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        reverseResolutionNodeToAddress(arg0: BytesLike, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        supportsInterface(interfaceId: BytesLike, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+    };
+}

package/dist/common/generated/factories/CoWShedFactory__factory.d.ts

@@ -0,0 +1,250 @@
+import { Signer } from "ethers";
+import type { Provider } from "@ethersproject/providers";
+import type { CoWShedFactory, CoWShedFactoryInterface } from "../CoWShedFactory";
+export declare class CoWShedFactory__factory {
+    static readonly abi: readonly [{
+        readonly inputs: readonly [{
+            readonly internalType: "address";
+            readonly name: "impl";
+            readonly type: "address";
+        }, {
+            readonly internalType: "bytes32";
+            readonly name: "bName";
+            readonly type: "bytes32";
+        }, {
+            readonly internalType: "bytes32";
+            readonly name: "bNode";
+            readonly type: "bytes32";
+        }];
+        readonly stateMutability: "nonpayable";
+        readonly type: "constructor";
+    }, {
+        readonly inputs: readonly [];
+        readonly name: "InvalidSignature";
+        readonly type: "error";
+    }, {
+        readonly inputs: readonly [];
+        readonly name: "NonceAlreadyUsed";
+        readonly type: "error";
+    }, {
+        readonly inputs: readonly [];
+        readonly name: "SettingEnsRecordsFailed";
+        readonly type: "error";
+    }, {
+        readonly anonymous: false;
+        readonly inputs: readonly [{
+            readonly indexed: false;
+            readonly internalType: "address";
+            readonly name: "user";
+            readonly type: "address";
+        }, {
+            readonly indexed: false;
+            readonly internalType: "address";
+            readonly name: "shed";
+            readonly type: "address";
+        }];
+        readonly name: "COWShedBuilt";
+        readonly type: "event";
+    }, {
+        readonly inputs: readonly [{
+            readonly internalType: "bytes32";
+            readonly name: "node";
+            readonly type: "bytes32";
+        }];
+        readonly name: "addr";
+        readonly outputs: readonly [{
+            readonly internalType: "address";
+            readonly name: "";
+            readonly type: "address";
+        }];
+        readonly stateMutability: "view";
+        readonly type: "function";
+    }, {
+        readonly inputs: readonly [];
+        readonly name: "baseName";
+        readonly outputs: readonly [{
+            readonly internalType: "string";
+            readonly name: "";
+            readonly type: "string";
+        }];
+        readonly stateMutability: "view";
+        readonly type: "function";
+    }, {
+        readonly inputs: readonly [];
+        readonly name: "baseNode";
+        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: "address";
+                readonly name: "target";
+                readonly type: "address";
+            }, {
+                readonly internalType: "uint256";
+                readonly name: "value";
+                readonly type: "uint256";
+            }, {
+                readonly internalType: "bytes";
+                readonly name: "callData";
+                readonly type: "bytes";
+            }, {
+                readonly internalType: "bool";
+                readonly name: "allowFailure";
+                readonly type: "bool";
+            }, {
+                readonly internalType: "bool";
+                readonly name: "isDelegateCall";
+                readonly type: "bool";
+            }];
+            readonly internalType: "struct Call[]";
+            readonly name: "calls";
+            readonly type: "tuple[]";
+        }, {
+            readonly internalType: "bytes32";
+            readonly name: "nonce";
+            readonly type: "bytes32";
+        }, {
+            readonly internalType: "uint256";
+            readonly name: "deadline";
+            readonly type: "uint256";
+        }, {
+            readonly internalType: "address";
+            readonly name: "user";
+            readonly type: "address";
+        }, {
+            readonly internalType: "bytes";
+            readonly name: "signature";
+            readonly type: "bytes";
+        }];
+        readonly name: "executeHooks";
+        readonly outputs: readonly [];
+        readonly stateMutability: "nonpayable";
+        readonly type: "function";
+    }, {
+        readonly inputs: readonly [{
+            readonly internalType: "bytes32";
+            readonly name: "";
+            readonly type: "bytes32";
+        }];
+        readonly name: "forwardResolutionNodeToAddress";
+        readonly outputs: readonly [{
+            readonly internalType: "address";
+            readonly name: "";
+            readonly type: "address";
+        }];
+        readonly stateMutability: "view";
+        readonly type: "function";
+    }, {
+        readonly inputs: readonly [];
+        readonly name: "implementation";
+        readonly outputs: readonly [{
+            readonly internalType: "address";
+            readonly name: "";
+            readonly type: "address";
+        }];
+        readonly stateMutability: "view";
+        readonly type: "function";
+    }, {
+        readonly inputs: readonly [{
+            readonly internalType: "address";
+            readonly name: "user";
+            readonly type: "address";
+        }];
+        readonly name: "initializeEns";
+        readonly outputs: readonly [];
+        readonly stateMutability: "nonpayable";
+        readonly type: "function";
+    }, {
+        readonly inputs: readonly [{
+            readonly internalType: "address";
+            readonly name: "user";
+            readonly type: "address";
+        }, {
+            readonly internalType: "bool";
+            readonly name: "withEns";
+            readonly type: "bool";
+        }];
+        readonly name: "initializeProxy";
+        readonly outputs: readonly [];
+        readonly stateMutability: "nonpayable";
+        readonly type: "function";
+    }, {
+        readonly inputs: readonly [{
+            readonly internalType: "bytes32";
+            readonly name: "node";
+            readonly type: "bytes32";
+        }];
+        readonly name: "name";
+        readonly outputs: readonly [{
+            readonly internalType: "string";
+            readonly name: "";
+            readonly type: "string";
+        }];
+        readonly stateMutability: "view";
+        readonly type: "function";
+    }, {
+        readonly inputs: readonly [{
+            readonly internalType: "address";
+            readonly name: "";
+            readonly type: "address";
+        }];
+        readonly name: "ownerOf";
+        readonly outputs: readonly [{
+            readonly internalType: "address";
+            readonly name: "";
+            readonly type: "address";
+        }];
+        readonly stateMutability: "view";
+        readonly type: "function";
+    }, {
+        readonly inputs: readonly [{
+            readonly internalType: "address";
+            readonly name: "who";
+            readonly type: "address";
+        }];
+        readonly name: "proxyOf";
+        readonly outputs: readonly [{
+            readonly internalType: "address";
+            readonly name: "";
+            readonly type: "address";
+        }];
+        readonly stateMutability: "view";
+        readonly type: "function";
+    }, {
+        readonly inputs: readonly [{
+            readonly internalType: "bytes32";
+            readonly name: "";
+            readonly type: "bytes32";
+        }];
+        readonly name: "reverseResolutionNodeToAddress";
+        readonly outputs: readonly [{
+            readonly internalType: "address";
+            readonly name: "";
+            readonly type: "address";
+        }];
+        readonly stateMutability: "view";
+        readonly type: "function";
+    }, {
+        readonly inputs: readonly [{
+            readonly internalType: "bytes4";
+            readonly name: "interfaceId";
+            readonly type: "bytes4";
+        }];
+        readonly name: "supportsInterface";
+        readonly outputs: readonly [{
+            readonly internalType: "bool";
+            readonly name: "";
+            readonly type: "bool";
+        }];
+        readonly stateMutability: "pure";
+        readonly type: "function";
+    }];
+    static createInterface(): CoWShedFactoryInterface;
+    static connect(address: string, signerOrProvider: Signer | Provider): CoWShedFactory;
+}