@safe-global/protocol-kit 1.0.1 → 1.2.0

package/dist/typechain/src/ethers-v5/v1.4.1/Safe.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=Safe.js.map

package/dist/typechain/src/ethers-v5/v1.4.1/Safe.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Safe.js","sourceRoot":"","sources":["../../../../../typechain/src/ethers-v5/v1.4.1/Safe.ts"],"names":[],"mappings":""}

package/dist/typechain/src/ethers-v5/v1.4.1/Safe_proxy_factory.d.ts

@@ -0,0 +1,126 @@
+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, PromiseOrValue } from "./common";
+export interface Safe_proxy_factoryInterface extends utils.Interface {
+    functions: {
+        "createChainSpecificProxyWithNonce(address,bytes,uint256)": FunctionFragment;
+        "createProxyWithCallback(address,bytes,uint256,address)": FunctionFragment;
+        "createProxyWithNonce(address,bytes,uint256)": FunctionFragment;
+        "getChainId()": FunctionFragment;
+        "proxyCreationCode()": FunctionFragment;
+    };
+    getFunction(nameOrSignatureOrTopic: "createChainSpecificProxyWithNonce" | "createProxyWithCallback" | "createProxyWithNonce" | "getChainId" | "proxyCreationCode"): FunctionFragment;
+    encodeFunctionData(functionFragment: "createChainSpecificProxyWithNonce", values: [
+        PromiseOrValue<string>,
+        PromiseOrValue<BytesLike>,
+        PromiseOrValue<BigNumberish>
+    ]): string;
+    encodeFunctionData(functionFragment: "createProxyWithCallback", values: [
+        PromiseOrValue<string>,
+        PromiseOrValue<BytesLike>,
+        PromiseOrValue<BigNumberish>,
+        PromiseOrValue<string>
+    ]): string;
+    encodeFunctionData(functionFragment: "createProxyWithNonce", values: [
+        PromiseOrValue<string>,
+        PromiseOrValue<BytesLike>,
+        PromiseOrValue<BigNumberish>
+    ]): string;
+    encodeFunctionData(functionFragment: "getChainId", values?: undefined): string;
+    encodeFunctionData(functionFragment: "proxyCreationCode", values?: undefined): string;
+    decodeFunctionResult(functionFragment: "createChainSpecificProxyWithNonce", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "createProxyWithCallback", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "createProxyWithNonce", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getChainId", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "proxyCreationCode", data: BytesLike): Result;
+    events: {
+        "ProxyCreation(address,address)": EventFragment;
+    };
+    getEvent(nameOrSignatureOrTopic: "ProxyCreation"): EventFragment;
+}
+export interface ProxyCreationEventObject {
+    proxy: string;
+    singleton: string;
+}
+export type ProxyCreationEvent = TypedEvent<[
+    string,
+    string
+], ProxyCreationEventObject>;
+export type ProxyCreationEventFilter = TypedEventFilter<ProxyCreationEvent>;
+export interface Safe_proxy_factory extends BaseContract {
+    connect(signerOrProvider: Signer | Provider | string): this;
+    attach(addressOrName: string): this;
+    deployed(): Promise<this>;
+    interface: Safe_proxy_factoryInterface;
+    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: {
+        createChainSpecificProxyWithNonce(_singleton: PromiseOrValue<string>, initializer: PromiseOrValue<BytesLike>, saltNonce: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        createProxyWithCallback(_singleton: PromiseOrValue<string>, initializer: PromiseOrValue<BytesLike>, saltNonce: PromiseOrValue<BigNumberish>, callback: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        createProxyWithNonce(_singleton: PromiseOrValue<string>, initializer: PromiseOrValue<BytesLike>, saltNonce: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        getChainId(overrides?: CallOverrides): Promise<[BigNumber]>;
+        proxyCreationCode(overrides?: CallOverrides): Promise<[string]>;
+    };
+    createChainSpecificProxyWithNonce(_singleton: PromiseOrValue<string>, initializer: PromiseOrValue<BytesLike>, saltNonce: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    createProxyWithCallback(_singleton: PromiseOrValue<string>, initializer: PromiseOrValue<BytesLike>, saltNonce: PromiseOrValue<BigNumberish>, callback: PromiseOrValue<string>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    createProxyWithNonce(_singleton: PromiseOrValue<string>, initializer: PromiseOrValue<BytesLike>, saltNonce: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    getChainId(overrides?: CallOverrides): Promise<BigNumber>;
+    proxyCreationCode(overrides?: CallOverrides): Promise<string>;
+    callStatic: {
+        createChainSpecificProxyWithNonce(_singleton: PromiseOrValue<string>, initializer: PromiseOrValue<BytesLike>, saltNonce: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<string>;
+        createProxyWithCallback(_singleton: PromiseOrValue<string>, initializer: PromiseOrValue<BytesLike>, saltNonce: PromiseOrValue<BigNumberish>, callback: PromiseOrValue<string>, overrides?: CallOverrides): Promise<string>;
+        createProxyWithNonce(_singleton: PromiseOrValue<string>, initializer: PromiseOrValue<BytesLike>, saltNonce: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<string>;
+        getChainId(overrides?: CallOverrides): Promise<BigNumber>;
+        proxyCreationCode(overrides?: CallOverrides): Promise<string>;
+    };
+    filters: {
+        "ProxyCreation(address,address)"(proxy?: PromiseOrValue<string> | null, singleton?: null): ProxyCreationEventFilter;
+        ProxyCreation(proxy?: PromiseOrValue<string> | null, singleton?: null): ProxyCreationEventFilter;
+    };
+    estimateGas: {
+        createChainSpecificProxyWithNonce(_singleton: PromiseOrValue<string>, initializer: PromiseOrValue<BytesLike>, saltNonce: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        createProxyWithCallback(_singleton: PromiseOrValue<string>, initializer: PromiseOrValue<BytesLike>, saltNonce: PromiseOrValue<BigNumberish>, callback: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        createProxyWithNonce(_singleton: PromiseOrValue<string>, initializer: PromiseOrValue<BytesLike>, saltNonce: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        getChainId(overrides?: CallOverrides): Promise<BigNumber>;
+        proxyCreationCode(overrides?: CallOverrides): Promise<BigNumber>;
+    };
+    populateTransaction: {
+        createChainSpecificProxyWithNonce(_singleton: PromiseOrValue<string>, initializer: PromiseOrValue<BytesLike>, saltNonce: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        createProxyWithCallback(_singleton: PromiseOrValue<string>, initializer: PromiseOrValue<BytesLike>, saltNonce: PromiseOrValue<BigNumberish>, callback: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        createProxyWithNonce(_singleton: PromiseOrValue<string>, initializer: PromiseOrValue<BytesLike>, saltNonce: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        getChainId(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        proxyCreationCode(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+    };
+}

package/dist/typechain/src/ethers-v5/v1.4.1/Safe_proxy_factory.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=Safe_proxy_factory.js.map

package/dist/typechain/src/ethers-v5/v1.4.1/Safe_proxy_factory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Safe_proxy_factory.js","sourceRoot":"","sources":["../../../../../typechain/src/ethers-v5/v1.4.1/Safe_proxy_factory.ts"],"names":[],"mappings":""}

package/dist/typechain/src/ethers-v5/v1.4.1/Sign_message_lib.d.ts

@@ -0,0 +1,69 @@
+import type { BaseContract, BigNumber, 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, PromiseOrValue } from "./common";
+export interface Sign_message_libInterface extends utils.Interface {
+    functions: {
+        "getMessageHash(bytes)": FunctionFragment;
+        "signMessage(bytes)": FunctionFragment;
+    };
+    getFunction(nameOrSignatureOrTopic: "getMessageHash" | "signMessage"): FunctionFragment;
+    encodeFunctionData(functionFragment: "getMessageHash", values: [PromiseOrValue<BytesLike>]): string;
+    encodeFunctionData(functionFragment: "signMessage", values: [PromiseOrValue<BytesLike>]): string;
+    decodeFunctionResult(functionFragment: "getMessageHash", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "signMessage", data: BytesLike): Result;
+    events: {
+        "SignMsg(bytes32)": EventFragment;
+    };
+    getEvent(nameOrSignatureOrTopic: "SignMsg"): EventFragment;
+}
+export interface SignMsgEventObject {
+    msgHash: string;
+}
+export type SignMsgEvent = TypedEvent<[string], SignMsgEventObject>;
+export type SignMsgEventFilter = TypedEventFilter<SignMsgEvent>;
+export interface Sign_message_lib extends BaseContract {
+    connect(signerOrProvider: Signer | Provider | string): this;
+    attach(addressOrName: string): this;
+    deployed(): Promise<this>;
+    interface: Sign_message_libInterface;
+    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: {
+        getMessageHash(message: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<[string]>;
+        signMessage(_data: PromiseOrValue<BytesLike>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+    };
+    getMessageHash(message: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<string>;
+    signMessage(_data: PromiseOrValue<BytesLike>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    callStatic: {
+        getMessageHash(message: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<string>;
+        signMessage(_data: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<void>;
+    };
+    filters: {
+        "SignMsg(bytes32)"(msgHash?: PromiseOrValue<BytesLike> | null): SignMsgEventFilter;
+        SignMsg(msgHash?: PromiseOrValue<BytesLike> | null): SignMsgEventFilter;
+    };
+    estimateGas: {
+        getMessageHash(message: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<BigNumber>;
+        signMessage(_data: PromiseOrValue<BytesLike>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+    };
+    populateTransaction: {
+        getMessageHash(message: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        signMessage(_data: PromiseOrValue<BytesLike>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+    };
+}

package/dist/typechain/src/ethers-v5/v1.4.1/Sign_message_lib.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=Sign_message_lib.js.map

package/dist/typechain/src/ethers-v5/v1.4.1/Sign_message_lib.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Sign_message_lib.js","sourceRoot":"","sources":["../../../../../typechain/src/ethers-v5/v1.4.1/Sign_message_lib.ts"],"names":[],"mappings":""}

package/dist/typechain/src/ethers-v5/v1.4.1/Simulate_tx_accessor.d.ts

@@ -0,0 +1,63 @@
+import type { BaseContract, BigNumber, BigNumberish, BytesLike, CallOverrides, ContractTransaction, Overrides, PopulatedTransaction, Signer, utils } from "ethers";
+import type { FunctionFragment, Result } from "@ethersproject/abi";
+import type { Listener, Provider } from "@ethersproject/providers";
+import type { TypedEventFilter, TypedEvent, TypedListener, OnEvent, PromiseOrValue } from "./common";
+export interface Simulate_tx_accessorInterface extends utils.Interface {
+    functions: {
+        "simulate(address,uint256,bytes,uint8)": FunctionFragment;
+    };
+    getFunction(nameOrSignatureOrTopic: "simulate"): FunctionFragment;
+    encodeFunctionData(functionFragment: "simulate", values: [
+        PromiseOrValue<string>,
+        PromiseOrValue<BigNumberish>,
+        PromiseOrValue<BytesLike>,
+        PromiseOrValue<BigNumberish>
+    ]): string;
+    decodeFunctionResult(functionFragment: "simulate", data: BytesLike): Result;
+    events: {};
+}
+export interface Simulate_tx_accessor extends BaseContract {
+    connect(signerOrProvider: Signer | Provider | string): this;
+    attach(addressOrName: string): this;
+    deployed(): Promise<this>;
+    interface: Simulate_tx_accessorInterface;
+    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: {
+        simulate(to: PromiseOrValue<string>, value: PromiseOrValue<BigNumberish>, data: PromiseOrValue<BytesLike>, operation: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+    };
+    simulate(to: PromiseOrValue<string>, value: PromiseOrValue<BigNumberish>, data: PromiseOrValue<BytesLike>, operation: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    callStatic: {
+        simulate(to: PromiseOrValue<string>, value: PromiseOrValue<BigNumberish>, data: PromiseOrValue<BytesLike>, operation: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<[
+            BigNumber,
+            boolean,
+            string
+        ] & {
+            estimate: BigNumber;
+            success: boolean;
+            returnData: string;
+        }>;
+    };
+    filters: {};
+    estimateGas: {
+        simulate(to: PromiseOrValue<string>, value: PromiseOrValue<BigNumberish>, data: PromiseOrValue<BytesLike>, operation: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+    };
+    populateTransaction: {
+        simulate(to: PromiseOrValue<string>, value: PromiseOrValue<BigNumberish>, data: PromiseOrValue<BytesLike>, operation: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+    };
+}

package/dist/typechain/src/ethers-v5/v1.4.1/Simulate_tx_accessor.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=Simulate_tx_accessor.js.map

package/dist/typechain/src/ethers-v5/v1.4.1/Simulate_tx_accessor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Simulate_tx_accessor.js","sourceRoot":"","sources":["../../../../../typechain/src/ethers-v5/v1.4.1/Simulate_tx_accessor.ts"],"names":[],"mappings":""}

package/dist/typechain/src/ethers-v5/v1.4.1/common.d.ts

@@ -0,0 +1,22 @@
+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 type PromiseOrValue<T> = T | Promise<T>;
+export {};

package/dist/typechain/src/ethers-v5/v1.4.1/common.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=common.js.map

package/dist/typechain/src/ethers-v5/v1.4.1/common.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"common.js","sourceRoot":"","sources":["../../../../../typechain/src/ethers-v5/v1.4.1/common.ts"],"names":[],"mappings":""}

package/dist/typechain/src/ethers-v5/v1.4.1/factories/Compatibility_fallback_handler__factory.d.ts

@@ -0,0 +1,252 @@
+import { Signer } from "ethers";
+import type { Provider } from "@ethersproject/providers";
+import type { Compatibility_fallback_handler, Compatibility_fallback_handlerInterface } from "../Compatibility_fallback_handler";
+export declare class Compatibility_fallback_handler__factory {
+    static readonly abi: readonly [{
+        readonly inputs: readonly [{
+            readonly internalType: "contract Safe";
+            readonly name: "safe";
+            readonly type: "address";
+        }, {
+            readonly internalType: "bytes";
+            readonly name: "message";
+            readonly type: "bytes";
+        }];
+        readonly name: "encodeMessageDataForSafe";
+        readonly outputs: readonly [{
+            readonly internalType: "bytes";
+            readonly name: "";
+            readonly type: "bytes";
+        }];
+        readonly stateMutability: "view";
+        readonly type: "function";
+    }, {
+        readonly inputs: readonly [{
+            readonly internalType: "bytes";
+            readonly name: "message";
+            readonly type: "bytes";
+        }];
+        readonly name: "getMessageHash";
+        readonly outputs: readonly [{
+            readonly internalType: "bytes32";
+            readonly name: "";
+            readonly type: "bytes32";
+        }];
+        readonly stateMutability: "view";
+        readonly type: "function";
+    }, {
+        readonly inputs: readonly [{
+            readonly internalType: "contract Safe";
+            readonly name: "safe";
+            readonly type: "address";
+        }, {
+            readonly internalType: "bytes";
+            readonly name: "message";
+            readonly type: "bytes";
+        }];
+        readonly name: "getMessageHashForSafe";
+        readonly outputs: readonly [{
+            readonly internalType: "bytes32";
+            readonly name: "";
+            readonly type: "bytes32";
+        }];
+        readonly stateMutability: "view";
+        readonly type: "function";
+    }, {
+        readonly inputs: readonly [];
+        readonly name: "getModules";
+        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: "_dataHash";
+            readonly type: "bytes32";
+        }, {
+            readonly internalType: "bytes";
+            readonly name: "_signature";
+            readonly type: "bytes";
+        }];
+        readonly name: "isValidSignature";
+        readonly outputs: readonly [{
+            readonly internalType: "bytes4";
+            readonly name: "";
+            readonly type: "bytes4";
+        }];
+        readonly stateMutability: "view";
+        readonly type: "function";
+    }, {
+        readonly inputs: readonly [{
+            readonly internalType: "bytes";
+            readonly name: "_data";
+            readonly type: "bytes";
+        }, {
+            readonly internalType: "bytes";
+            readonly name: "_signature";
+            readonly type: "bytes";
+        }];
+        readonly name: "isValidSignature";
+        readonly outputs: readonly [{
+            readonly internalType: "bytes4";
+            readonly name: "";
+            readonly type: "bytes4";
+        }];
+        readonly stateMutability: "view";
+        readonly type: "function";
+    }, {
+        readonly inputs: readonly [{
+            readonly internalType: "address";
+            readonly name: "";
+            readonly type: "address";
+        }, {
+            readonly internalType: "address";
+            readonly name: "";
+            readonly type: "address";
+        }, {
+            readonly internalType: "uint256[]";
+            readonly name: "";
+            readonly type: "uint256[]";
+        }, {
+            readonly internalType: "uint256[]";
+            readonly name: "";
+            readonly type: "uint256[]";
+        }, {
+            readonly internalType: "bytes";
+            readonly name: "";
+            readonly type: "bytes";
+        }];
+        readonly name: "onERC1155BatchReceived";
+        readonly outputs: readonly [{
+            readonly internalType: "bytes4";
+            readonly name: "";
+            readonly type: "bytes4";
+        }];
+        readonly stateMutability: "pure";
+        readonly type: "function";
+    }, {
+        readonly inputs: readonly [{
+            readonly internalType: "address";
+            readonly name: "";
+            readonly type: "address";
+        }, {
+            readonly internalType: "address";
+            readonly name: "";
+            readonly type: "address";
+        }, {
+            readonly internalType: "uint256";
+            readonly name: "";
+            readonly type: "uint256";
+        }, {
+            readonly internalType: "uint256";
+            readonly name: "";
+            readonly type: "uint256";
+        }, {
+            readonly internalType: "bytes";
+            readonly name: "";
+            readonly type: "bytes";
+        }];
+        readonly name: "onERC1155Received";
+        readonly outputs: readonly [{
+            readonly internalType: "bytes4";
+            readonly name: "";
+            readonly type: "bytes4";
+        }];
+        readonly stateMutability: "pure";
+        readonly type: "function";
+    }, {
+        readonly inputs: readonly [{
+            readonly internalType: "address";
+            readonly name: "";
+            readonly type: "address";
+        }, {
+            readonly internalType: "address";
+            readonly name: "";
+            readonly type: "address";
+        }, {
+            readonly internalType: "uint256";
+            readonly name: "";
+            readonly type: "uint256";
+        }, {
+            readonly internalType: "bytes";
+            readonly name: "";
+            readonly type: "bytes";
+        }];
+        readonly name: "onERC721Received";
+        readonly outputs: readonly [{
+            readonly internalType: "bytes4";
+            readonly name: "";
+            readonly type: "bytes4";
+        }];
+        readonly stateMutability: "pure";
+        readonly type: "function";
+    }, {
+        readonly inputs: readonly [{
+            readonly internalType: "address";
+            readonly name: "targetContract";
+            readonly type: "address";
+        }, {
+            readonly internalType: "bytes";
+            readonly name: "calldataPayload";
+            readonly type: "bytes";
+        }];
+        readonly name: "simulate";
+        readonly outputs: readonly [{
+            readonly internalType: "bytes";
+            readonly name: "response";
+            readonly type: "bytes";
+        }];
+        readonly stateMutability: "nonpayable";
+        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: "view";
+        readonly type: "function";
+    }, {
+        readonly inputs: readonly [{
+            readonly internalType: "address";
+            readonly name: "";
+            readonly type: "address";
+        }, {
+            readonly internalType: "address";
+            readonly name: "";
+            readonly type: "address";
+        }, {
+            readonly internalType: "address";
+            readonly name: "";
+            readonly type: "address";
+        }, {
+            readonly internalType: "uint256";
+            readonly name: "";
+            readonly type: "uint256";
+        }, {
+            readonly internalType: "bytes";
+            readonly name: "";
+            readonly type: "bytes";
+        }, {
+            readonly internalType: "bytes";
+            readonly name: "";
+            readonly type: "bytes";
+        }];
+        readonly name: "tokensReceived";
+        readonly outputs: readonly [];
+        readonly stateMutability: "pure";
+        readonly type: "function";
+    }];
+    static createInterface(): Compatibility_fallback_handlerInterface;
+    static connect(address: string, signerOrProvider: Signer | Provider): Compatibility_fallback_handler;
+}