@safe-global/protocol-kit 1.0.1 → 1.2.0

package/dist/typechain/src/web3-v1/v1.4.1/types.d.ts

@@ -0,0 +1,54 @@
+/// <reference types="node" />
+import type BN from "bn.js";
+import type { EventEmitter } from "events";
+import type { EventLog, PromiEvent, TransactionReceipt } from "web3-core/types";
+import type { Contract } from "web3-eth-contract";
+export interface EstimateGasOptions {
+    from?: string;
+    gas?: number;
+    value?: number | string | BN;
+}
+export interface EventOptions {
+    filter?: object;
+    fromBlock?: BlockType;
+    topics?: string[];
+}
+export type Callback<T> = (error: Error, result: T) => void;
+export interface ContractEventLog<T> extends EventLog {
+    returnValues: T;
+}
+export interface ContractEventEmitter<T> extends EventEmitter {
+    on(event: "connected", listener: (subscriptionId: string) => void): this;
+    on(event: "data" | "changed", listener: (event: ContractEventLog<T>) => void): this;
+    on(event: "error", listener: (error: Error) => void): this;
+}
+export interface NonPayableTx {
+    nonce?: string | number | BN;
+    chainId?: string | number | BN;
+    from?: string;
+    to?: string;
+    data?: string;
+    gas?: string | number | BN;
+    maxPriorityFeePerGas?: string | number | BN;
+    maxFeePerGas?: string | number | BN;
+    gasPrice?: string | number | BN;
+}
+export interface PayableTx extends NonPayableTx {
+    value?: string | number | BN;
+}
+export interface NonPayableTransactionObject<T> {
+    arguments: any[];
+    call(tx?: NonPayableTx, block?: BlockType): Promise<T>;
+    send(tx?: NonPayableTx): PromiEvent<TransactionReceipt>;
+    estimateGas(tx?: NonPayableTx): Promise<number>;
+    encodeABI(): string;
+}
+export interface PayableTransactionObject<T> {
+    arguments: any[];
+    call(tx?: PayableTx, block?: BlockType): Promise<T>;
+    send(tx?: PayableTx): PromiEvent<TransactionReceipt>;
+    estimateGas(tx?: PayableTx): Promise<number>;
+    encodeABI(): string;
+}
+export type BlockType = "latest" | "pending" | "genesis" | "earliest" | number | BN;
+export type BaseContract = Omit<Contract, "clone" | "once">;

package/dist/typechain/src/web3-v1/v1.4.1/types.js

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

package/dist/typechain/src/web3-v1/v1.4.1/types.js.map

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

package/dist/typechain/tests/ethers-v5/v1.4.1/DebugTransactionGuard.d.ts

@@ -0,0 +1,144 @@
+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 DebugTransactionGuardInterface extends utils.Interface {
+    functions: {
+        "checkAfterExecution(bytes32,bool)": FunctionFragment;
+        "checkTransaction(address,uint256,bytes,uint8,uint256,uint256,uint256,address,address,bytes,address)": FunctionFragment;
+        "supportsInterface(bytes4)": FunctionFragment;
+        "txNonces(bytes32)": FunctionFragment;
+    };
+    getFunction(nameOrSignatureOrTopic: "checkAfterExecution" | "checkTransaction" | "supportsInterface" | "txNonces"): FunctionFragment;
+    encodeFunctionData(functionFragment: "checkAfterExecution", values: [PromiseOrValue<BytesLike>, PromiseOrValue<boolean>]): string;
+    encodeFunctionData(functionFragment: "checkTransaction", values: [
+        PromiseOrValue<string>,
+        PromiseOrValue<BigNumberish>,
+        PromiseOrValue<BytesLike>,
+        PromiseOrValue<BigNumberish>,
+        PromiseOrValue<BigNumberish>,
+        PromiseOrValue<BigNumberish>,
+        PromiseOrValue<BigNumberish>,
+        PromiseOrValue<string>,
+        PromiseOrValue<string>,
+        PromiseOrValue<BytesLike>,
+        PromiseOrValue<string>
+    ]): string;
+    encodeFunctionData(functionFragment: "supportsInterface", values: [PromiseOrValue<BytesLike>]): string;
+    encodeFunctionData(functionFragment: "txNonces", values: [PromiseOrValue<BytesLike>]): string;
+    decodeFunctionResult(functionFragment: "checkAfterExecution", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "checkTransaction", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "supportsInterface", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "txNonces", data: BytesLike): Result;
+    events: {
+        "GasUsage(address,bytes32,uint256,bool)": EventFragment;
+        "TransactionDetails(address,bytes32,address,uint256,bytes,uint8,uint256,bool,uint256,bytes,address)": EventFragment;
+    };
+    getEvent(nameOrSignatureOrTopic: "GasUsage"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "TransactionDetails"): EventFragment;
+}
+export interface GasUsageEventObject {
+    safe: string;
+    txHash: string;
+    nonce: BigNumber;
+    success: boolean;
+}
+export type GasUsageEvent = TypedEvent<[
+    string,
+    string,
+    BigNumber,
+    boolean
+], GasUsageEventObject>;
+export type GasUsageEventFilter = TypedEventFilter<GasUsageEvent>;
+export interface TransactionDetailsEventObject {
+    safe: string;
+    txHash: string;
+    to: string;
+    value: BigNumber;
+    data: string;
+    operation: number;
+    safeTxGas: BigNumber;
+    usesRefund: boolean;
+    nonce: BigNumber;
+    signatures: string;
+    executor: string;
+}
+export type TransactionDetailsEvent = TypedEvent<[
+    string,
+    string,
+    string,
+    BigNumber,
+    string,
+    number,
+    BigNumber,
+    boolean,
+    BigNumber,
+    string,
+    string
+], TransactionDetailsEventObject>;
+export type TransactionDetailsEventFilter = TypedEventFilter<TransactionDetailsEvent>;
+export interface DebugTransactionGuard extends BaseContract {
+    connect(signerOrProvider: Signer | Provider | string): this;
+    attach(addressOrName: string): this;
+    deployed(): Promise<this>;
+    interface: DebugTransactionGuardInterface;
+    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: {
+        checkAfterExecution(txHash: PromiseOrValue<BytesLike>, success: PromiseOrValue<boolean>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        checkTransaction(to: PromiseOrValue<string>, value: PromiseOrValue<BigNumberish>, data: PromiseOrValue<BytesLike>, operation: PromiseOrValue<BigNumberish>, safeTxGas: PromiseOrValue<BigNumberish>, baseGas: PromiseOrValue<BigNumberish>, gasPrice: PromiseOrValue<BigNumberish>, gasToken: PromiseOrValue<string>, refundReceiver: PromiseOrValue<string>, signatures: PromiseOrValue<BytesLike>, executor: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        supportsInterface(interfaceId: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<[boolean]>;
+        txNonces(arg0: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<[BigNumber]>;
+    };
+    checkAfterExecution(txHash: PromiseOrValue<BytesLike>, success: PromiseOrValue<boolean>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    checkTransaction(to: PromiseOrValue<string>, value: PromiseOrValue<BigNumberish>, data: PromiseOrValue<BytesLike>, operation: PromiseOrValue<BigNumberish>, safeTxGas: PromiseOrValue<BigNumberish>, baseGas: PromiseOrValue<BigNumberish>, gasPrice: PromiseOrValue<BigNumberish>, gasToken: PromiseOrValue<string>, refundReceiver: PromiseOrValue<string>, signatures: PromiseOrValue<BytesLike>, executor: PromiseOrValue<string>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    supportsInterface(interfaceId: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<boolean>;
+    txNonces(arg0: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<BigNumber>;
+    callStatic: {
+        checkAfterExecution(txHash: PromiseOrValue<BytesLike>, success: PromiseOrValue<boolean>, overrides?: CallOverrides): Promise<void>;
+        checkTransaction(to: PromiseOrValue<string>, value: PromiseOrValue<BigNumberish>, data: PromiseOrValue<BytesLike>, operation: PromiseOrValue<BigNumberish>, safeTxGas: PromiseOrValue<BigNumberish>, baseGas: PromiseOrValue<BigNumberish>, gasPrice: PromiseOrValue<BigNumberish>, gasToken: PromiseOrValue<string>, refundReceiver: PromiseOrValue<string>, signatures: PromiseOrValue<BytesLike>, executor: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
+        supportsInterface(interfaceId: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<boolean>;
+        txNonces(arg0: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<BigNumber>;
+    };
+    filters: {
+        "GasUsage(address,bytes32,uint256,bool)"(safe?: PromiseOrValue<string> | null, txHash?: PromiseOrValue<BytesLike> | null, nonce?: PromiseOrValue<BigNumberish> | null, success?: null): GasUsageEventFilter;
+        GasUsage(safe?: PromiseOrValue<string> | null, txHash?: PromiseOrValue<BytesLike> | null, nonce?: PromiseOrValue<BigNumberish> | null, success?: null): GasUsageEventFilter;
+        "TransactionDetails(address,bytes32,address,uint256,bytes,uint8,uint256,bool,uint256,bytes,address)"(safe?: PromiseOrValue<string> | null, txHash?: PromiseOrValue<BytesLike> | null, to?: null, value?: null, data?: null, operation?: null, safeTxGas?: null, usesRefund?: null, nonce?: null, signatures?: null, executor?: null): TransactionDetailsEventFilter;
+        TransactionDetails(safe?: PromiseOrValue<string> | null, txHash?: PromiseOrValue<BytesLike> | null, to?: null, value?: null, data?: null, operation?: null, safeTxGas?: null, usesRefund?: null, nonce?: null, signatures?: null, executor?: null): TransactionDetailsEventFilter;
+    };
+    estimateGas: {
+        checkAfterExecution(txHash: PromiseOrValue<BytesLike>, success: PromiseOrValue<boolean>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        checkTransaction(to: PromiseOrValue<string>, value: PromiseOrValue<BigNumberish>, data: PromiseOrValue<BytesLike>, operation: PromiseOrValue<BigNumberish>, safeTxGas: PromiseOrValue<BigNumberish>, baseGas: PromiseOrValue<BigNumberish>, gasPrice: PromiseOrValue<BigNumberish>, gasToken: PromiseOrValue<string>, refundReceiver: PromiseOrValue<string>, signatures: PromiseOrValue<BytesLike>, executor: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        supportsInterface(interfaceId: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<BigNumber>;
+        txNonces(arg0: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<BigNumber>;
+    };
+    populateTransaction: {
+        checkAfterExecution(txHash: PromiseOrValue<BytesLike>, success: PromiseOrValue<boolean>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        checkTransaction(to: PromiseOrValue<string>, value: PromiseOrValue<BigNumberish>, data: PromiseOrValue<BytesLike>, operation: PromiseOrValue<BigNumberish>, safeTxGas: PromiseOrValue<BigNumberish>, baseGas: PromiseOrValue<BigNumberish>, gasPrice: PromiseOrValue<BigNumberish>, gasToken: PromiseOrValue<string>, refundReceiver: PromiseOrValue<string>, signatures: PromiseOrValue<BytesLike>, executor: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        supportsInterface(interfaceId: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        txNonces(arg0: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+    };
+}

package/dist/typechain/tests/ethers-v5/v1.4.1/DebugTransactionGuard.js

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

package/dist/typechain/tests/ethers-v5/v1.4.1/DebugTransactionGuard.js.map

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

package/dist/typechain/tests/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/tests/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/tests/ethers-v5/v1.4.1/common.js.map

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

package/dist/typechain/tests/ethers-v5/v1.4.1/factories/DebugTransactionGuard__factory.d.ts

@@ -0,0 +1,201 @@
+import { Signer, ContractFactory, Overrides } from "ethers";
+import type { Provider, TransactionRequest } from "@ethersproject/providers";
+import type { PromiseOrValue } from "../common";
+import type { DebugTransactionGuard, DebugTransactionGuardInterface } from "../DebugTransactionGuard";
+type DebugTransactionGuardConstructorParams = [signer?: Signer] | ConstructorParameters<typeof ContractFactory>;
+export declare class DebugTransactionGuard__factory extends ContractFactory {
+    constructor(...args: DebugTransactionGuardConstructorParams);
+    deploy(overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<DebugTransactionGuard>;
+    getDeployTransaction(overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): TransactionRequest;
+    attach(address: string): DebugTransactionGuard;
+    connect(signer: Signer): DebugTransactionGuard__factory;
+    static readonly bytecode = "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";
+    static readonly abi: readonly [{
+        readonly anonymous: false;
+        readonly inputs: readonly [{
+            readonly indexed: true;
+            readonly internalType: "address";
+            readonly name: "safe";
+            readonly type: "address";
+        }, {
+            readonly indexed: true;
+            readonly internalType: "bytes32";
+            readonly name: "txHash";
+            readonly type: "bytes32";
+        }, {
+            readonly indexed: true;
+            readonly internalType: "uint256";
+            readonly name: "nonce";
+            readonly type: "uint256";
+        }, {
+            readonly indexed: false;
+            readonly internalType: "bool";
+            readonly name: "success";
+            readonly type: "bool";
+        }];
+        readonly name: "GasUsage";
+        readonly type: "event";
+    }, {
+        readonly anonymous: false;
+        readonly inputs: readonly [{
+            readonly indexed: true;
+            readonly internalType: "address";
+            readonly name: "safe";
+            readonly type: "address";
+        }, {
+            readonly indexed: true;
+            readonly internalType: "bytes32";
+            readonly name: "txHash";
+            readonly type: "bytes32";
+        }, {
+            readonly indexed: false;
+            readonly internalType: "address";
+            readonly name: "to";
+            readonly type: "address";
+        }, {
+            readonly indexed: false;
+            readonly internalType: "uint256";
+            readonly name: "value";
+            readonly type: "uint256";
+        }, {
+            readonly indexed: false;
+            readonly internalType: "bytes";
+            readonly name: "data";
+            readonly type: "bytes";
+        }, {
+            readonly indexed: false;
+            readonly internalType: "enum Enum.Operation";
+            readonly name: "operation";
+            readonly type: "uint8";
+        }, {
+            readonly indexed: false;
+            readonly internalType: "uint256";
+            readonly name: "safeTxGas";
+            readonly type: "uint256";
+        }, {
+            readonly indexed: false;
+            readonly internalType: "bool";
+            readonly name: "usesRefund";
+            readonly type: "bool";
+        }, {
+            readonly indexed: false;
+            readonly internalType: "uint256";
+            readonly name: "nonce";
+            readonly type: "uint256";
+        }, {
+            readonly indexed: false;
+            readonly internalType: "bytes";
+            readonly name: "signatures";
+            readonly type: "bytes";
+        }, {
+            readonly indexed: false;
+            readonly internalType: "address";
+            readonly name: "executor";
+            readonly type: "address";
+        }];
+        readonly name: "TransactionDetails";
+        readonly type: "event";
+    }, {
+        readonly stateMutability: "nonpayable";
+        readonly type: "fallback";
+    }, {
+        readonly inputs: readonly [{
+            readonly internalType: "bytes32";
+            readonly name: "txHash";
+            readonly type: "bytes32";
+        }, {
+            readonly internalType: "bool";
+            readonly name: "success";
+            readonly type: "bool";
+        }];
+        readonly name: "checkAfterExecution";
+        readonly outputs: readonly [];
+        readonly stateMutability: "nonpayable";
+        readonly type: "function";
+    }, {
+        readonly inputs: readonly [{
+            readonly internalType: "address";
+            readonly name: "to";
+            readonly type: "address";
+        }, {
+            readonly internalType: "uint256";
+            readonly name: "value";
+            readonly type: "uint256";
+        }, {
+            readonly internalType: "bytes";
+            readonly name: "data";
+            readonly type: "bytes";
+        }, {
+            readonly internalType: "enum Enum.Operation";
+            readonly name: "operation";
+            readonly type: "uint8";
+        }, {
+            readonly internalType: "uint256";
+            readonly name: "safeTxGas";
+            readonly type: "uint256";
+        }, {
+            readonly internalType: "uint256";
+            readonly name: "baseGas";
+            readonly type: "uint256";
+        }, {
+            readonly internalType: "uint256";
+            readonly name: "gasPrice";
+            readonly type: "uint256";
+        }, {
+            readonly internalType: "address";
+            readonly name: "gasToken";
+            readonly type: "address";
+        }, {
+            readonly internalType: "address payable";
+            readonly name: "refundReceiver";
+            readonly type: "address";
+        }, {
+            readonly internalType: "bytes";
+            readonly name: "signatures";
+            readonly type: "bytes";
+        }, {
+            readonly internalType: "address";
+            readonly name: "executor";
+            readonly type: "address";
+        }];
+        readonly name: "checkTransaction";
+        readonly outputs: readonly [];
+        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: "bytes32";
+            readonly name: "";
+            readonly type: "bytes32";
+        }];
+        readonly name: "txNonces";
+        readonly outputs: readonly [{
+            readonly internalType: "uint256";
+            readonly name: "";
+            readonly type: "uint256";
+        }];
+        readonly stateMutability: "view";
+        readonly type: "function";
+    }];
+    static createInterface(): DebugTransactionGuardInterface;
+    static connect(address: string, signerOrProvider: Signer | Provider): DebugTransactionGuard;
+}
+export {};