@merkl/contracts 1.4.44 → 1.4.46

package/dist/src/MerklVerifier.d.ts

@@ -0,0 +1,285 @@
+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 declare namespace SelfUtils {
+    type UnformattedVerificationConfigV2Struct = {
+        olderThan: PromiseOrValue<BigNumberish>;
+        forbiddenCountries: PromiseOrValue<string>[];
+        ofacEnabled: PromiseOrValue<boolean>;
+    };
+    type UnformattedVerificationConfigV2StructOutput = [
+        BigNumber,
+        string[],
+        boolean
+    ] & {
+        olderThan: BigNumber;
+        forbiddenCountries: string[];
+        ofacEnabled: boolean;
+    };
+}
+export interface MerklVerifierInterface extends utils.Interface {
+    functions: {
+        "DOMAIN_SEPARATOR()": FunctionFragment;
+        "VERIFY_IDENTITY_TYPEHASH()": FunctionFragment;
+        "getConfigId(bytes32,bytes32,bytes)": FunctionFragment;
+        "getUserForNullifier(uint256)": FunctionFragment;
+        "isVerified(bytes32,address)": FunctionFragment;
+        "nullifierToUser(uint256)": FunctionFragment;
+        "onVerificationSuccess(bytes,bytes)": FunctionFragment;
+        "owner()": FunctionFragment;
+        "renounceOwnership()": FunctionFragment;
+        "revokeVerification(bytes32,address)": FunctionFragment;
+        "scope()": FunctionFragment;
+        "transferOwnership(address)": FunctionFragment;
+        "verificationConfig()": FunctionFragment;
+        "verifications(bytes32,address)": FunctionFragment;
+        "verifySelfProof(bytes,bytes)": FunctionFragment;
+    };
+    getFunction(nameOrSignatureOrTopic: "DOMAIN_SEPARATOR" | "VERIFY_IDENTITY_TYPEHASH" | "getConfigId" | "getUserForNullifier" | "isVerified" | "nullifierToUser" | "onVerificationSuccess" | "owner" | "renounceOwnership" | "revokeVerification" | "scope" | "transferOwnership" | "verificationConfig" | "verifications" | "verifySelfProof"): FunctionFragment;
+    encodeFunctionData(functionFragment: "DOMAIN_SEPARATOR", values?: undefined): string;
+    encodeFunctionData(functionFragment: "VERIFY_IDENTITY_TYPEHASH", values?: undefined): string;
+    encodeFunctionData(functionFragment: "getConfigId", values: [
+        PromiseOrValue<BytesLike>,
+        PromiseOrValue<BytesLike>,
+        PromiseOrValue<BytesLike>
+    ]): string;
+    encodeFunctionData(functionFragment: "getUserForNullifier", values: [PromiseOrValue<BigNumberish>]): string;
+    encodeFunctionData(functionFragment: "isVerified", values: [PromiseOrValue<BytesLike>, PromiseOrValue<string>]): string;
+    encodeFunctionData(functionFragment: "nullifierToUser", values: [PromiseOrValue<BigNumberish>]): string;
+    encodeFunctionData(functionFragment: "onVerificationSuccess", values: [PromiseOrValue<BytesLike>, PromiseOrValue<BytesLike>]): string;
+    encodeFunctionData(functionFragment: "owner", values?: undefined): string;
+    encodeFunctionData(functionFragment: "renounceOwnership", values?: undefined): string;
+    encodeFunctionData(functionFragment: "revokeVerification", values: [PromiseOrValue<BytesLike>, PromiseOrValue<string>]): string;
+    encodeFunctionData(functionFragment: "scope", values?: undefined): string;
+    encodeFunctionData(functionFragment: "transferOwnership", values: [PromiseOrValue<string>]): string;
+    encodeFunctionData(functionFragment: "verificationConfig", values?: undefined): string;
+    encodeFunctionData(functionFragment: "verifications", values: [PromiseOrValue<BytesLike>, PromiseOrValue<string>]): string;
+    encodeFunctionData(functionFragment: "verifySelfProof", values: [PromiseOrValue<BytesLike>, PromiseOrValue<BytesLike>]): string;
+    decodeFunctionResult(functionFragment: "DOMAIN_SEPARATOR", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "VERIFY_IDENTITY_TYPEHASH", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getConfigId", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getUserForNullifier", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "isVerified", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "nullifierToUser", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "onVerificationSuccess", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "owner", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "renounceOwnership", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "revokeVerification", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "scope", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "transferOwnership", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "verificationConfig", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "verifications", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "verifySelfProof", data: BytesLike): Result;
+    events: {
+        "OwnershipTransferred(address,address)": EventFragment;
+        "VerificationRevoked(bytes32,address)": EventFragment;
+        "Verified(bytes32,address,uint256)": EventFragment;
+    };
+    getEvent(nameOrSignatureOrTopic: "OwnershipTransferred"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "VerificationRevoked"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "Verified"): EventFragment;
+}
+export interface OwnershipTransferredEventObject {
+    previousOwner: string;
+    newOwner: string;
+}
+export type OwnershipTransferredEvent = TypedEvent<[
+    string,
+    string
+], OwnershipTransferredEventObject>;
+export type OwnershipTransferredEventFilter = TypedEventFilter<OwnershipTransferredEvent>;
+export interface VerificationRevokedEventObject {
+    verificationId: string;
+    user: string;
+}
+export type VerificationRevokedEvent = TypedEvent<[
+    string,
+    string
+], VerificationRevokedEventObject>;
+export type VerificationRevokedEventFilter = TypedEventFilter<VerificationRevokedEvent>;
+export interface VerifiedEventObject {
+    verificationId: string;
+    user: string;
+    nullifier: BigNumber;
+}
+export type VerifiedEvent = TypedEvent<[
+    string,
+    string,
+    BigNumber
+], VerifiedEventObject>;
+export type VerifiedEventFilter = TypedEventFilter<VerifiedEvent>;
+export interface MerklVerifier extends BaseContract {
+    connect(signerOrProvider: Signer | Provider | string): this;
+    attach(addressOrName: string): this;
+    deployed(): Promise<this>;
+    interface: MerklVerifierInterface;
+    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: {
+        DOMAIN_SEPARATOR(overrides?: CallOverrides): Promise<[string]>;
+        VERIFY_IDENTITY_TYPEHASH(overrides?: CallOverrides): Promise<[string]>;
+        getConfigId(arg0: PromiseOrValue<BytesLike>, arg1: PromiseOrValue<BytesLike>, userDefinedData: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<[string]>;
+        getUserForNullifier(nullifier: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<[string]>;
+        isVerified(verificationId: PromiseOrValue<BytesLike>, user: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[boolean]>;
+        nullifierToUser(nullifier: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<[string] & {
+            user: string;
+        }>;
+        onVerificationSuccess(output: PromiseOrValue<BytesLike>, userData: PromiseOrValue<BytesLike>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        owner(overrides?: CallOverrides): Promise<[string]>;
+        renounceOwnership(overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        revokeVerification(verificationId: PromiseOrValue<BytesLike>, user: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        scope(overrides?: CallOverrides): Promise<[BigNumber]>;
+        transferOwnership(newOwner: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        verificationConfig(overrides?: CallOverrides): Promise<[
+            boolean,
+            BigNumber,
+            boolean
+        ] & {
+            olderThanEnabled: boolean;
+            olderThan: BigNumber;
+            forbiddenCountriesEnabled: boolean;
+        }>;
+        verifications(verificationId: PromiseOrValue<BytesLike>, user: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[boolean] & {
+            isVerified: boolean;
+        }>;
+        verifySelfProof(proofPayload: PromiseOrValue<BytesLike>, userContextData: PromiseOrValue<BytesLike>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+    };
+    DOMAIN_SEPARATOR(overrides?: CallOverrides): Promise<string>;
+    VERIFY_IDENTITY_TYPEHASH(overrides?: CallOverrides): Promise<string>;
+    getConfigId(arg0: PromiseOrValue<BytesLike>, arg1: PromiseOrValue<BytesLike>, userDefinedData: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<string>;
+    getUserForNullifier(nullifier: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<string>;
+    isVerified(verificationId: PromiseOrValue<BytesLike>, user: PromiseOrValue<string>, overrides?: CallOverrides): Promise<boolean>;
+    nullifierToUser(nullifier: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<string>;
+    onVerificationSuccess(output: PromiseOrValue<BytesLike>, userData: PromiseOrValue<BytesLike>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    owner(overrides?: CallOverrides): Promise<string>;
+    renounceOwnership(overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    revokeVerification(verificationId: PromiseOrValue<BytesLike>, user: PromiseOrValue<string>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    scope(overrides?: CallOverrides): Promise<BigNumber>;
+    transferOwnership(newOwner: PromiseOrValue<string>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    verificationConfig(overrides?: CallOverrides): Promise<[
+        boolean,
+        BigNumber,
+        boolean
+    ] & {
+        olderThanEnabled: boolean;
+        olderThan: BigNumber;
+        forbiddenCountriesEnabled: boolean;
+    }>;
+    verifications(verificationId: PromiseOrValue<BytesLike>, user: PromiseOrValue<string>, overrides?: CallOverrides): Promise<boolean>;
+    verifySelfProof(proofPayload: PromiseOrValue<BytesLike>, userContextData: PromiseOrValue<BytesLike>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    callStatic: {
+        DOMAIN_SEPARATOR(overrides?: CallOverrides): Promise<string>;
+        VERIFY_IDENTITY_TYPEHASH(overrides?: CallOverrides): Promise<string>;
+        getConfigId(arg0: PromiseOrValue<BytesLike>, arg1: PromiseOrValue<BytesLike>, userDefinedData: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<string>;
+        getUserForNullifier(nullifier: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<string>;
+        isVerified(verificationId: PromiseOrValue<BytesLike>, user: PromiseOrValue<string>, overrides?: CallOverrides): Promise<boolean>;
+        nullifierToUser(nullifier: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<string>;
+        onVerificationSuccess(output: PromiseOrValue<BytesLike>, userData: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<void>;
+        owner(overrides?: CallOverrides): Promise<string>;
+        renounceOwnership(overrides?: CallOverrides): Promise<void>;
+        revokeVerification(verificationId: PromiseOrValue<BytesLike>, user: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
+        scope(overrides?: CallOverrides): Promise<BigNumber>;
+        transferOwnership(newOwner: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
+        verificationConfig(overrides?: CallOverrides): Promise<[
+            boolean,
+            BigNumber,
+            boolean
+        ] & {
+            olderThanEnabled: boolean;
+            olderThan: BigNumber;
+            forbiddenCountriesEnabled: boolean;
+        }>;
+        verifications(verificationId: PromiseOrValue<BytesLike>, user: PromiseOrValue<string>, overrides?: CallOverrides): Promise<boolean>;
+        verifySelfProof(proofPayload: PromiseOrValue<BytesLike>, userContextData: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<void>;
+    };
+    filters: {
+        "OwnershipTransferred(address,address)"(previousOwner?: PromiseOrValue<string> | null, newOwner?: PromiseOrValue<string> | null): OwnershipTransferredEventFilter;
+        OwnershipTransferred(previousOwner?: PromiseOrValue<string> | null, newOwner?: PromiseOrValue<string> | null): OwnershipTransferredEventFilter;
+        "VerificationRevoked(bytes32,address)"(verificationId?: PromiseOrValue<BytesLike> | null, user?: PromiseOrValue<string> | null): VerificationRevokedEventFilter;
+        VerificationRevoked(verificationId?: PromiseOrValue<BytesLike> | null, user?: PromiseOrValue<string> | null): VerificationRevokedEventFilter;
+        "Verified(bytes32,address,uint256)"(verificationId?: PromiseOrValue<BytesLike> | null, user?: PromiseOrValue<string> | null, nullifier?: PromiseOrValue<BigNumberish> | null): VerifiedEventFilter;
+        Verified(verificationId?: PromiseOrValue<BytesLike> | null, user?: PromiseOrValue<string> | null, nullifier?: PromiseOrValue<BigNumberish> | null): VerifiedEventFilter;
+    };
+    estimateGas: {
+        DOMAIN_SEPARATOR(overrides?: CallOverrides): Promise<BigNumber>;
+        VERIFY_IDENTITY_TYPEHASH(overrides?: CallOverrides): Promise<BigNumber>;
+        getConfigId(arg0: PromiseOrValue<BytesLike>, arg1: PromiseOrValue<BytesLike>, userDefinedData: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<BigNumber>;
+        getUserForNullifier(nullifier: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<BigNumber>;
+        isVerified(verificationId: PromiseOrValue<BytesLike>, user: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
+        nullifierToUser(nullifier: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<BigNumber>;
+        onVerificationSuccess(output: PromiseOrValue<BytesLike>, userData: PromiseOrValue<BytesLike>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        owner(overrides?: CallOverrides): Promise<BigNumber>;
+        renounceOwnership(overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        revokeVerification(verificationId: PromiseOrValue<BytesLike>, user: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        scope(overrides?: CallOverrides): Promise<BigNumber>;
+        transferOwnership(newOwner: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        verificationConfig(overrides?: CallOverrides): Promise<BigNumber>;
+        verifications(verificationId: PromiseOrValue<BytesLike>, user: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
+        verifySelfProof(proofPayload: PromiseOrValue<BytesLike>, userContextData: PromiseOrValue<BytesLike>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+    };
+    populateTransaction: {
+        DOMAIN_SEPARATOR(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        VERIFY_IDENTITY_TYPEHASH(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        getConfigId(arg0: PromiseOrValue<BytesLike>, arg1: PromiseOrValue<BytesLike>, userDefinedData: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        getUserForNullifier(nullifier: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        isVerified(verificationId: PromiseOrValue<BytesLike>, user: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        nullifierToUser(nullifier: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        onVerificationSuccess(output: PromiseOrValue<BytesLike>, userData: PromiseOrValue<BytesLike>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        owner(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        renounceOwnership(overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        revokeVerification(verificationId: PromiseOrValue<BytesLike>, user: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        scope(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        transferOwnership(newOwner: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        verificationConfig(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        verifications(verificationId: PromiseOrValue<BytesLike>, user: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        verifySelfProof(proofPayload: PromiseOrValue<BytesLike>, userContextData: PromiseOrValue<BytesLike>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+    };
+}

package/dist/src/MerklVerifier.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=MerklVerifier.js.map

package/dist/src/MerklVerifier.js.map

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

package/dist/src/factories/MerklVerifier__factory.d.ts

@@ -0,0 +1,353 @@
+import { Signer } from "ethers";
+import type { Provider } from "@ethersproject/providers";
+import type { MerklVerifier, MerklVerifierInterface } from "../MerklVerifier";
+export declare class MerklVerifier__factory {
+    static readonly abi: readonly [{
+        readonly inputs: readonly [{
+            readonly internalType: "address";
+            readonly name: "_identityVerificationHubAddress";
+            readonly type: "address";
+        }, {
+            readonly internalType: "string";
+            readonly name: "scope";
+            readonly type: "string";
+        }, {
+            readonly internalType: "address";
+            readonly name: "_owner";
+            readonly type: "address";
+        }, {
+            readonly components: readonly [{
+                readonly internalType: "uint256";
+                readonly name: "olderThan";
+                readonly type: "uint256";
+            }, {
+                readonly internalType: "string[]";
+                readonly name: "forbiddenCountries";
+                readonly type: "string[]";
+            }, {
+                readonly internalType: "bool";
+                readonly name: "ofacEnabled";
+                readonly type: "bool";
+            }];
+            readonly internalType: "struct SelfUtils.UnformattedVerificationConfigV2";
+            readonly name: "_verificationConfig";
+            readonly type: "tuple";
+        }];
+        readonly stateMutability: "nonpayable";
+        readonly type: "constructor";
+    }, {
+        readonly inputs: readonly [];
+        readonly name: "ECDSAInvalidSignature";
+        readonly type: "error";
+    }, {
+        readonly inputs: readonly [{
+            readonly internalType: "uint256";
+            readonly name: "length";
+            readonly type: "uint256";
+        }];
+        readonly name: "ECDSAInvalidSignatureLength";
+        readonly type: "error";
+    }, {
+        readonly inputs: readonly [{
+            readonly internalType: "bytes32";
+            readonly name: "s";
+            readonly type: "bytes32";
+        }];
+        readonly name: "ECDSAInvalidSignatureS";
+        readonly type: "error";
+    }, {
+        readonly inputs: readonly [];
+        readonly name: "InvalidDataFormat";
+        readonly type: "error";
+    }, {
+        readonly inputs: readonly [];
+        readonly name: "InvalidReceiver";
+        readonly type: "error";
+    }, {
+        readonly inputs: readonly [];
+        readonly name: "InvalidSignature";
+        readonly type: "error";
+    }, {
+        readonly inputs: readonly [];
+        readonly name: "InvalidUserData";
+        readonly type: "error";
+    }, {
+        readonly inputs: readonly [];
+        readonly name: "NullifierAlreadyUsedByDifferentUser";
+        readonly type: "error";
+    }, {
+        readonly inputs: readonly [{
+            readonly internalType: "address";
+            readonly name: "owner";
+            readonly type: "address";
+        }];
+        readonly name: "OwnableInvalidOwner";
+        readonly type: "error";
+    }, {
+        readonly inputs: readonly [{
+            readonly internalType: "address";
+            readonly name: "account";
+            readonly type: "address";
+        }];
+        readonly name: "OwnableUnauthorizedAccount";
+        readonly type: "error";
+    }, {
+        readonly inputs: readonly [];
+        readonly name: "UnauthorizedCaller";
+        readonly type: "error";
+    }, {
+        readonly anonymous: false;
+        readonly inputs: readonly [{
+            readonly indexed: true;
+            readonly internalType: "address";
+            readonly name: "previousOwner";
+            readonly type: "address";
+        }, {
+            readonly indexed: true;
+            readonly internalType: "address";
+            readonly name: "newOwner";
+            readonly type: "address";
+        }];
+        readonly name: "OwnershipTransferred";
+        readonly type: "event";
+    }, {
+        readonly anonymous: false;
+        readonly inputs: readonly [{
+            readonly indexed: true;
+            readonly internalType: "bytes32";
+            readonly name: "verificationId";
+            readonly type: "bytes32";
+        }, {
+            readonly indexed: true;
+            readonly internalType: "address";
+            readonly name: "user";
+            readonly type: "address";
+        }];
+        readonly name: "VerificationRevoked";
+        readonly type: "event";
+    }, {
+        readonly anonymous: false;
+        readonly inputs: readonly [{
+            readonly indexed: true;
+            readonly internalType: "bytes32";
+            readonly name: "verificationId";
+            readonly type: "bytes32";
+        }, {
+            readonly indexed: true;
+            readonly internalType: "address";
+            readonly name: "user";
+            readonly type: "address";
+        }, {
+            readonly indexed: true;
+            readonly internalType: "uint256";
+            readonly name: "nullifier";
+            readonly type: "uint256";
+        }];
+        readonly name: "Verified";
+        readonly type: "event";
+    }, {
+        readonly inputs: readonly [];
+        readonly name: "DOMAIN_SEPARATOR";
+        readonly outputs: readonly [{
+            readonly internalType: "bytes32";
+            readonly name: "";
+            readonly type: "bytes32";
+        }];
+        readonly stateMutability: "view";
+        readonly type: "function";
+    }, {
+        readonly inputs: readonly [];
+        readonly name: "VERIFY_IDENTITY_TYPEHASH";
+        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: "";
+            readonly type: "bytes32";
+        }, {
+            readonly internalType: "bytes32";
+            readonly name: "";
+            readonly type: "bytes32";
+        }, {
+            readonly internalType: "bytes";
+            readonly name: "userDefinedData";
+            readonly type: "bytes";
+        }];
+        readonly name: "getConfigId";
+        readonly outputs: readonly [{
+            readonly internalType: "bytes32";
+            readonly name: "";
+            readonly type: "bytes32";
+        }];
+        readonly stateMutability: "pure";
+        readonly type: "function";
+    }, {
+        readonly inputs: readonly [{
+            readonly internalType: "uint256";
+            readonly name: "nullifier";
+            readonly type: "uint256";
+        }];
+        readonly name: "getUserForNullifier";
+        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: "verificationId";
+            readonly type: "bytes32";
+        }, {
+            readonly internalType: "address";
+            readonly name: "user";
+            readonly type: "address";
+        }];
+        readonly name: "isVerified";
+        readonly outputs: readonly [{
+            readonly internalType: "bool";
+            readonly name: "";
+            readonly type: "bool";
+        }];
+        readonly stateMutability: "view";
+        readonly type: "function";
+    }, {
+        readonly inputs: readonly [{
+            readonly internalType: "uint256";
+            readonly name: "nullifier";
+            readonly type: "uint256";
+        }];
+        readonly name: "nullifierToUser";
+        readonly outputs: readonly [{
+            readonly internalType: "address";
+            readonly name: "user";
+            readonly type: "address";
+        }];
+        readonly stateMutability: "view";
+        readonly type: "function";
+    }, {
+        readonly inputs: readonly [{
+            readonly internalType: "bytes";
+            readonly name: "output";
+            readonly type: "bytes";
+        }, {
+            readonly internalType: "bytes";
+            readonly name: "userData";
+            readonly type: "bytes";
+        }];
+        readonly name: "onVerificationSuccess";
+        readonly outputs: readonly [];
+        readonly stateMutability: "nonpayable";
+        readonly type: "function";
+    }, {
+        readonly inputs: readonly [];
+        readonly name: "owner";
+        readonly outputs: readonly [{
+            readonly internalType: "address";
+            readonly name: "";
+            readonly type: "address";
+        }];
+        readonly stateMutability: "view";
+        readonly type: "function";
+    }, {
+        readonly inputs: readonly [];
+        readonly name: "renounceOwnership";
+        readonly outputs: readonly [];
+        readonly stateMutability: "nonpayable";
+        readonly type: "function";
+    }, {
+        readonly inputs: readonly [{
+            readonly internalType: "bytes32";
+            readonly name: "verificationId";
+            readonly type: "bytes32";
+        }, {
+            readonly internalType: "address";
+            readonly name: "user";
+            readonly type: "address";
+        }];
+        readonly name: "revokeVerification";
+        readonly outputs: readonly [];
+        readonly stateMutability: "nonpayable";
+        readonly type: "function";
+    }, {
+        readonly inputs: readonly [];
+        readonly name: "scope";
+        readonly outputs: readonly [{
+            readonly internalType: "uint256";
+            readonly name: "";
+            readonly type: "uint256";
+        }];
+        readonly stateMutability: "view";
+        readonly type: "function";
+    }, {
+        readonly inputs: readonly [{
+            readonly internalType: "address";
+            readonly name: "newOwner";
+            readonly type: "address";
+        }];
+        readonly name: "transferOwnership";
+        readonly outputs: readonly [];
+        readonly stateMutability: "nonpayable";
+        readonly type: "function";
+    }, {
+        readonly inputs: readonly [];
+        readonly name: "verificationConfig";
+        readonly outputs: readonly [{
+            readonly internalType: "bool";
+            readonly name: "olderThanEnabled";
+            readonly type: "bool";
+        }, {
+            readonly internalType: "uint256";
+            readonly name: "olderThan";
+            readonly type: "uint256";
+        }, {
+            readonly internalType: "bool";
+            readonly name: "forbiddenCountriesEnabled";
+            readonly type: "bool";
+        }];
+        readonly stateMutability: "view";
+        readonly type: "function";
+    }, {
+        readonly inputs: readonly [{
+            readonly internalType: "bytes32";
+            readonly name: "verificationId";
+            readonly type: "bytes32";
+        }, {
+            readonly internalType: "address";
+            readonly name: "user";
+            readonly type: "address";
+        }];
+        readonly name: "verifications";
+        readonly outputs: readonly [{
+            readonly internalType: "bool";
+            readonly name: "isVerified";
+            readonly type: "bool";
+        }];
+        readonly stateMutability: "view";
+        readonly type: "function";
+    }, {
+        readonly inputs: readonly [{
+            readonly internalType: "bytes";
+            readonly name: "proofPayload";
+            readonly type: "bytes";
+        }, {
+            readonly internalType: "bytes";
+            readonly name: "userContextData";
+            readonly type: "bytes";
+        }];
+        readonly name: "verifySelfProof";
+        readonly outputs: readonly [];
+        readonly stateMutability: "nonpayable";
+        readonly type: "function";
+    }];
+    static createInterface(): MerklVerifierInterface;
+    static connect(address: string, signerOrProvider: Signer | Provider): MerklVerifier;
+}