/* Autogenerated file. Do not edit manually. */
/* tslint:disable */
/* eslint-disable */
import type {
  BaseContract,
  BigNumber,
  BigNumberish,
  BytesLike,
  CallOverrides,
  ContractTransaction,
  Overrides,
  PayableOverrides,
  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 type CommonExtDataStruct = {
  recipient: PromiseOrValue<string>;
  extAmount: PromiseOrValue<BigNumberish>;
  relayer: PromiseOrValue<string>;
  fee: PromiseOrValue<BigNumberish>;
  refund: PromiseOrValue<BigNumberish>;
  token: PromiseOrValue<string>;
};

export type CommonExtDataStructOutput = [
  string,
  BigNumber,
  string,
  BigNumber,
  BigNumber,
  string
] & {
  recipient: string;
  extAmount: BigNumber;
  relayer: string;
  fee: BigNumber;
  refund: BigNumber;
  token: string;
};

export type EncryptionsStruct = {
  encryptedOutput1: PromiseOrValue<BytesLike>;
  encryptedOutput2: PromiseOrValue<BytesLike>;
};

export type EncryptionsStructOutput = [string, string] & {
  encryptedOutput1: string;
  encryptedOutput2: string;
};

export type EdgeStruct = {
  chainID: PromiseOrValue<BigNumberish>;
  root: PromiseOrValue<BigNumberish>;
  latestLeafIndex: PromiseOrValue<BigNumberish>;
  srcResourceID: PromiseOrValue<BytesLike>;
};

export type EdgeStructOutput = [BigNumber, BigNumber, BigNumber, string] & {
  chainID: BigNumber;
  root: BigNumber;
  latestLeafIndex: BigNumber;
  srcResourceID: string;
};

export type PublicInputsStruct = {
  roots: PromiseOrValue<BytesLike>;
  extensionRoots: PromiseOrValue<BytesLike>;
  inputNullifiers: PromiseOrValue<BigNumberish>[];
  outputCommitments: [
    PromiseOrValue<BigNumberish>,
    PromiseOrValue<BigNumberish>
  ];
  publicAmount: PromiseOrValue<BigNumberish>;
  extDataHash: PromiseOrValue<BigNumberish>;
};

export type PublicInputsStructOutput = [
  string,
  string,
  BigNumber[],
  [BigNumber, BigNumber],
  BigNumber,
  BigNumber
] & {
  roots: string;
  extensionRoots: string;
  inputNullifiers: BigNumber[];
  outputCommitments: [BigNumber, BigNumber];
  publicAmount: BigNumber;
  extDataHash: BigNumber;
};

export declare namespace VAnchorBase {
  export type AccountStruct = {
    owner: PromiseOrValue<string>;
    keyData: PromiseOrValue<BytesLike>;
  };

  export type AccountStructOutput = [string, string] & {
    owner: string;
    keyData: string;
  };
}

export interface VAnchorInterface extends utils.Interface {
  functions: {
    "EVM_CHAIN_ID_TYPE()": FunctionFragment;
    "FIELD_SIZE()": FunctionFragment;
    "MAX_EXT_AMOUNT()": FunctionFragment;
    "MAX_FEE()": FunctionFragment;
    "ROOT_HISTORY_SIZE()": FunctionFragment;
    "ZERO_VALUE()": FunctionFragment;
    "_executeWrapping(address,address,uint256)": FunctionFragment;
    "_genExtDataHash(bytes,(address,int256,address,uint256,uint256,address),(bytes,bytes))": FunctionFragment;
    "_withdrawAndUnwrap(address,address,address,uint256)": FunctionFragment;
    "calculatePublicAmount(int256,uint256)": FunctionFragment;
    "commitments(uint256)": FunctionFragment;
    "configureMaximumDepositLimit(uint256,uint32)": FunctionFragment;
    "configureMinimalWithdrawalLimit(uint256,uint32)": FunctionFragment;
    "currentNeighborRootIndex(uint256)": FunctionFragment;
    "edgeExistsForChain(uint256)": FunctionFragment;
    "edgeIndex(uint256)": FunctionFragment;
    "edgeList(uint256)": FunctionFragment;
    "filledSubtrees(uint256)": FunctionFragment;
    "getChainId()": FunctionFragment;
    "getChainIdType()": FunctionFragment;
    "getHasher()": FunctionFragment;
    "getLastRoot()": FunctionFragment;
    "getLatestNeighborEdges()": FunctionFragment;
    "getLatestNeighborRoots()": FunctionFragment;
    "getLevels()": FunctionFragment;
    "getNextIndex()": FunctionFragment;
    "getProposalNonce()": FunctionFragment;
    "getZeroHash(uint32)": FunctionFragment;
    "handler()": FunctionFragment;
    "hasEdge(uint256)": FunctionFragment;
    "hashLeftRight(uint256,uint256)": FunctionFragment;
    "initialize(uint256,uint256)": FunctionFragment;
    "initialized()": FunctionFragment;
    "isCorrectExecutionChain(bytes32)": FunctionFragment;
    "isCorrectExecutionContext(bytes32)": FunctionFragment;
    "isKnownNeighborRoot(uint256,uint256)": FunctionFragment;
    "isKnownRoot(uint256)": FunctionFragment;
    "isSpent(uint256)": FunctionFragment;
    "isSpentArray(uint256[])": FunctionFragment;
    "isValidRoots(uint256[])": FunctionFragment;
    "lastBalance()": FunctionFragment;
    "maxEdges()": FunctionFragment;
    "maximumDepositAmount()": FunctionFragment;
    "minimalWithdrawalAmount()": FunctionFragment;
    "neighborRoots(uint256,uint32)": FunctionFragment;
    "nullifierHashes(uint256)": FunctionFragment;
    "outerLevels()": FunctionFragment;
    "parseChainIdFromResourceId(bytes32)": FunctionFragment;
    "proposalNonce()": FunctionFragment;
    "register((address,bytes))": FunctionFragment;
    "registerAndTransact((address,bytes),bytes,bytes,(address,int256,address,uint256,uint256,address),(bytes,bytes,uint256[],uint256[2],uint256,uint256),(bytes,bytes))": FunctionFragment;
    "roots(uint256)": FunctionFragment;
    "setHandler(address,uint32)": FunctionFragment;
    "setVerifier(address,uint32)": FunctionFragment;
    "token()": FunctionFragment;
    "transact(bytes,bytes,(address,int256,address,uint256,uint256,address),(bytes,bytes,uint256[],uint256[2],uint256,uint256),(bytes,bytes))": FunctionFragment;
    "unpackProof(uint256[8])": FunctionFragment;
    "updateEdge(uint256,uint32,bytes32)": FunctionFragment;
    "verifier()": FunctionFragment;
  };

  getFunction(
    nameOrSignatureOrTopic:
      | "EVM_CHAIN_ID_TYPE"
      | "FIELD_SIZE"
      | "MAX_EXT_AMOUNT"
      | "MAX_FEE"
      | "ROOT_HISTORY_SIZE"
      | "ZERO_VALUE"
      | "_executeWrapping"
      | "_genExtDataHash"
      | "_withdrawAndUnwrap"
      | "calculatePublicAmount"
      | "commitments"
      | "configureMaximumDepositLimit"
      | "configureMinimalWithdrawalLimit"
      | "currentNeighborRootIndex"
      | "edgeExistsForChain"
      | "edgeIndex"
      | "edgeList"
      | "filledSubtrees"
      | "getChainId"
      | "getChainIdType"
      | "getHasher"
      | "getLastRoot"
      | "getLatestNeighborEdges"
      | "getLatestNeighborRoots"
      | "getLevels"
      | "getNextIndex"
      | "getProposalNonce"
      | "getZeroHash"
      | "handler"
      | "hasEdge"
      | "hashLeftRight"
      | "initialize"
      | "initialized"
      | "isCorrectExecutionChain"
      | "isCorrectExecutionContext"
      | "isKnownNeighborRoot"
      | "isKnownRoot"
      | "isSpent"
      | "isSpentArray"
      | "isValidRoots"
      | "lastBalance"
      | "maxEdges"
      | "maximumDepositAmount"
      | "minimalWithdrawalAmount"
      | "neighborRoots"
      | "nullifierHashes"
      | "outerLevels"
      | "parseChainIdFromResourceId"
      | "proposalNonce"
      | "register"
      | "registerAndTransact"
      | "roots"
      | "setHandler"
      | "setVerifier"
      | "token"
      | "transact"
      | "unpackProof"
      | "updateEdge"
      | "verifier"
  ): FunctionFragment;

  encodeFunctionData(
    functionFragment: "EVM_CHAIN_ID_TYPE",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "FIELD_SIZE",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "MAX_EXT_AMOUNT",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "MAX_FEE", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "ROOT_HISTORY_SIZE",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "ZERO_VALUE",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "_executeWrapping",
    values: [
      PromiseOrValue<string>,
      PromiseOrValue<string>,
      PromiseOrValue<BigNumberish>
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "_genExtDataHash",
    values: [PromiseOrValue<BytesLike>, CommonExtDataStruct, EncryptionsStruct]
  ): string;
  encodeFunctionData(
    functionFragment: "_withdrawAndUnwrap",
    values: [
      PromiseOrValue<string>,
      PromiseOrValue<string>,
      PromiseOrValue<string>,
      PromiseOrValue<BigNumberish>
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "calculatePublicAmount",
    values: [PromiseOrValue<BigNumberish>, PromiseOrValue<BigNumberish>]
  ): string;
  encodeFunctionData(
    functionFragment: "commitments",
    values: [PromiseOrValue<BigNumberish>]
  ): string;
  encodeFunctionData(
    functionFragment: "configureMaximumDepositLimit",
    values: [PromiseOrValue<BigNumberish>, PromiseOrValue<BigNumberish>]
  ): string;
  encodeFunctionData(
    functionFragment: "configureMinimalWithdrawalLimit",
    values: [PromiseOrValue<BigNumberish>, PromiseOrValue<BigNumberish>]
  ): string;
  encodeFunctionData(
    functionFragment: "currentNeighborRootIndex",
    values: [PromiseOrValue<BigNumberish>]
  ): string;
  encodeFunctionData(
    functionFragment: "edgeExistsForChain",
    values: [PromiseOrValue<BigNumberish>]
  ): string;
  encodeFunctionData(
    functionFragment: "edgeIndex",
    values: [PromiseOrValue<BigNumberish>]
  ): string;
  encodeFunctionData(
    functionFragment: "edgeList",
    values: [PromiseOrValue<BigNumberish>]
  ): string;
  encodeFunctionData(
    functionFragment: "filledSubtrees",
    values: [PromiseOrValue<BigNumberish>]
  ): string;
  encodeFunctionData(
    functionFragment: "getChainId",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "getChainIdType",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "getHasher", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "getLastRoot",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "getLatestNeighborEdges",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "getLatestNeighborRoots",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "getLevels", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "getNextIndex",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "getProposalNonce",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "getZeroHash",
    values: [PromiseOrValue<BigNumberish>]
  ): string;
  encodeFunctionData(functionFragment: "handler", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "hasEdge",
    values: [PromiseOrValue<BigNumberish>]
  ): string;
  encodeFunctionData(
    functionFragment: "hashLeftRight",
    values: [PromiseOrValue<BigNumberish>, PromiseOrValue<BigNumberish>]
  ): string;
  encodeFunctionData(
    functionFragment: "initialize",
    values: [PromiseOrValue<BigNumberish>, PromiseOrValue<BigNumberish>]
  ): string;
  encodeFunctionData(
    functionFragment: "initialized",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "isCorrectExecutionChain",
    values: [PromiseOrValue<BytesLike>]
  ): string;
  encodeFunctionData(
    functionFragment: "isCorrectExecutionContext",
    values: [PromiseOrValue<BytesLike>]
  ): string;
  encodeFunctionData(
    functionFragment: "isKnownNeighborRoot",
    values: [PromiseOrValue<BigNumberish>, PromiseOrValue<BigNumberish>]
  ): string;
  encodeFunctionData(
    functionFragment: "isKnownRoot",
    values: [PromiseOrValue<BigNumberish>]
  ): string;
  encodeFunctionData(
    functionFragment: "isSpent",
    values: [PromiseOrValue<BigNumberish>]
  ): string;
  encodeFunctionData(
    functionFragment: "isSpentArray",
    values: [PromiseOrValue<BigNumberish>[]]
  ): string;
  encodeFunctionData(
    functionFragment: "isValidRoots",
    values: [PromiseOrValue<BigNumberish>[]]
  ): string;
  encodeFunctionData(
    functionFragment: "lastBalance",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "maxEdges", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "maximumDepositAmount",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "minimalWithdrawalAmount",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "neighborRoots",
    values: [PromiseOrValue<BigNumberish>, PromiseOrValue<BigNumberish>]
  ): string;
  encodeFunctionData(
    functionFragment: "nullifierHashes",
    values: [PromiseOrValue<BigNumberish>]
  ): string;
  encodeFunctionData(
    functionFragment: "outerLevels",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "parseChainIdFromResourceId",
    values: [PromiseOrValue<BytesLike>]
  ): string;
  encodeFunctionData(
    functionFragment: "proposalNonce",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "register",
    values: [VAnchorBase.AccountStruct]
  ): string;
  encodeFunctionData(
    functionFragment: "registerAndTransact",
    values: [
      VAnchorBase.AccountStruct,
      PromiseOrValue<BytesLike>,
      PromiseOrValue<BytesLike>,
      CommonExtDataStruct,
      PublicInputsStruct,
      EncryptionsStruct
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "roots",
    values: [PromiseOrValue<BigNumberish>]
  ): string;
  encodeFunctionData(
    functionFragment: "setHandler",
    values: [PromiseOrValue<string>, PromiseOrValue<BigNumberish>]
  ): string;
  encodeFunctionData(
    functionFragment: "setVerifier",
    values: [PromiseOrValue<string>, PromiseOrValue<BigNumberish>]
  ): string;
  encodeFunctionData(functionFragment: "token", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "transact",
    values: [
      PromiseOrValue<BytesLike>,
      PromiseOrValue<BytesLike>,
      CommonExtDataStruct,
      PublicInputsStruct,
      EncryptionsStruct
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "unpackProof",
    values: [PromiseOrValue<BigNumberish>[]]
  ): string;
  encodeFunctionData(
    functionFragment: "updateEdge",
    values: [
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<BytesLike>
    ]
  ): string;
  encodeFunctionData(functionFragment: "verifier", values?: undefined): string;

  decodeFunctionResult(
    functionFragment: "EVM_CHAIN_ID_TYPE",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "FIELD_SIZE", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "MAX_EXT_AMOUNT",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "MAX_FEE", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "ROOT_HISTORY_SIZE",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "ZERO_VALUE", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "_executeWrapping",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "_genExtDataHash",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "_withdrawAndUnwrap",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "calculatePublicAmount",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "commitments",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "configureMaximumDepositLimit",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "configureMinimalWithdrawalLimit",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "currentNeighborRootIndex",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "edgeExistsForChain",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "edgeIndex", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "edgeList", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "filledSubtrees",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "getChainId", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "getChainIdType",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "getHasher", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "getLastRoot",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getLatestNeighborEdges",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getLatestNeighborRoots",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "getLevels", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "getNextIndex",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getProposalNonce",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getZeroHash",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "handler", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "hasEdge", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "hashLeftRight",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "initialize", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "initialized",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "isCorrectExecutionChain",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "isCorrectExecutionContext",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "isKnownNeighborRoot",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "isKnownRoot",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "isSpent", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "isSpentArray",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "isValidRoots",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "lastBalance",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "maxEdges", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "maximumDepositAmount",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "minimalWithdrawalAmount",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "neighborRoots",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "nullifierHashes",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "outerLevels",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "parseChainIdFromResourceId",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "proposalNonce",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "register", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "registerAndTransact",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "roots", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "setHandler", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "setVerifier",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "token", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "transact", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "unpackProof",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "updateEdge", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "verifier", data: BytesLike): Result;

  events: {
    "EdgeAddition(uint256,uint256,uint256)": EventFragment;
    "EdgeUpdate(uint256,uint256,uint256)": EventFragment;
    "Insertion(uint256,uint32,uint256,uint256)": EventFragment;
    "NewCommitment(uint256,uint256,uint256,bytes)": EventFragment;
    "NewNullifier(uint256)": EventFragment;
    "PublicKey(address,bytes)": EventFragment;
  };

  getEvent(nameOrSignatureOrTopic: "EdgeAddition"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "EdgeUpdate"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "Insertion"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "NewCommitment"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "NewNullifier"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "PublicKey"): EventFragment;
}

export interface EdgeAdditionEventObject {
  chainID: BigNumber;
  latestLeafIndex: BigNumber;
  merkleRoot: BigNumber;
}
export type EdgeAdditionEvent = TypedEvent<
  [BigNumber, BigNumber, BigNumber],
  EdgeAdditionEventObject
>;

export type EdgeAdditionEventFilter = TypedEventFilter<EdgeAdditionEvent>;

export interface EdgeUpdateEventObject {
  chainID: BigNumber;
  latestLeafIndex: BigNumber;
  merkleRoot: BigNumber;
}
export type EdgeUpdateEvent = TypedEvent<
  [BigNumber, BigNumber, BigNumber],
  EdgeUpdateEventObject
>;

export type EdgeUpdateEventFilter = TypedEventFilter<EdgeUpdateEvent>;

export interface InsertionEventObject {
  commitment: BigNumber;
  leafIndex: number;
  timestamp: BigNumber;
  newMerkleRoot: BigNumber;
}
export type InsertionEvent = TypedEvent<
  [BigNumber, number, BigNumber, BigNumber],
  InsertionEventObject
>;

export type InsertionEventFilter = TypedEventFilter<InsertionEvent>;

export interface NewCommitmentEventObject {
  commitment: BigNumber;
  subTreeIndex: BigNumber;
  leafIndex: BigNumber;
  encryptedOutput: string;
}
export type NewCommitmentEvent = TypedEvent<
  [BigNumber, BigNumber, BigNumber, string],
  NewCommitmentEventObject
>;

export type NewCommitmentEventFilter = TypedEventFilter<NewCommitmentEvent>;

export interface NewNullifierEventObject {
  nullifier: BigNumber;
}
export type NewNullifierEvent = TypedEvent<
  [BigNumber],
  NewNullifierEventObject
>;

export type NewNullifierEventFilter = TypedEventFilter<NewNullifierEvent>;

export interface PublicKeyEventObject {
  owner: string;
  key: string;
}
export type PublicKeyEvent = TypedEvent<[string, string], PublicKeyEventObject>;

export type PublicKeyEventFilter = TypedEventFilter<PublicKeyEvent>;

export interface VAnchor extends BaseContract {
  connect(signerOrProvider: Signer | Provider | string): this;
  attach(addressOrName: string): this;
  deployed(): Promise<this>;

  interface: VAnchorInterface;

  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: {
    EVM_CHAIN_ID_TYPE(overrides?: CallOverrides): Promise<[string]>;

    FIELD_SIZE(overrides?: CallOverrides): Promise<[BigNumber]>;

    MAX_EXT_AMOUNT(overrides?: CallOverrides): Promise<[BigNumber]>;

    MAX_FEE(overrides?: CallOverrides): Promise<[BigNumber]>;

    ROOT_HISTORY_SIZE(overrides?: CallOverrides): Promise<[number]>;

    ZERO_VALUE(overrides?: CallOverrides): Promise<[BigNumber]>;

    _executeWrapping(
      _fromTokenAddress: PromiseOrValue<string>,
      _toTokenAddress: PromiseOrValue<string>,
      _extAmount: PromiseOrValue<BigNumberish>,
      overrides?: PayableOverrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    _genExtDataHash(
      arg0: PromiseOrValue<BytesLike>,
      _externalData: CommonExtDataStruct,
      _encryptions: EncryptionsStruct,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    _withdrawAndUnwrap(
      _fromTokenAddress: PromiseOrValue<string>,
      _toTokenAddress: PromiseOrValue<string>,
      _recipient: PromiseOrValue<string>,
      _minusExtAmount: PromiseOrValue<BigNumberish>,
      overrides?: PayableOverrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    calculatePublicAmount(
      _extAmount: PromiseOrValue<BigNumberish>,
      _fee: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

    commitments(
      arg0: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<[boolean]>;

    configureMaximumDepositLimit(
      _maximumDepositAmount: PromiseOrValue<BigNumberish>,
      _nonce: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    configureMinimalWithdrawalLimit(
      _minimalWithdrawalAmount: PromiseOrValue<BigNumberish>,
      _nonce: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    currentNeighborRootIndex(
      arg0: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<[number]>;

    edgeExistsForChain(
      arg0: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<[boolean]>;

    edgeIndex(
      arg0: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

    edgeList(
      arg0: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber, BigNumber, string] & {
        chainID: BigNumber;
        root: BigNumber;
        latestLeafIndex: BigNumber;
        srcResourceID: string;
      }
    >;

    filledSubtrees(
      arg0: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

    getChainId(overrides?: CallOverrides): Promise<[BigNumber]>;

    getChainIdType(overrides?: CallOverrides): Promise<[number]>;

    getHasher(overrides?: CallOverrides): Promise<[string]>;

    getLastRoot(overrides?: CallOverrides): Promise<[BigNumber]>;

    getLatestNeighborEdges(
      overrides?: CallOverrides
    ): Promise<[EdgeStructOutput[]]>;

    getLatestNeighborRoots(overrides?: CallOverrides): Promise<[BigNumber[]]>;

    getLevels(overrides?: CallOverrides): Promise<[number]>;

    getNextIndex(overrides?: CallOverrides): Promise<[number]>;

    getProposalNonce(overrides?: CallOverrides): Promise<[BigNumber]>;

    getZeroHash(
      index: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

    handler(overrides?: CallOverrides): Promise<[string]>;

    hasEdge(
      _chainID: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<[boolean]>;

    hashLeftRight(
      _left: PromiseOrValue<BigNumberish>,
      _right: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

    initialize(
      _minimalWithdrawalAmount: PromiseOrValue<BigNumberish>,
      _maximumDepositAmount: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    initialized(overrides?: CallOverrides): Promise<[boolean]>;

    isCorrectExecutionChain(
      resourceID: PromiseOrValue<BytesLike>,
      overrides?: CallOverrides
    ): Promise<[boolean]>;

    isCorrectExecutionContext(
      resourceId: PromiseOrValue<BytesLike>,
      overrides?: CallOverrides
    ): Promise<[boolean]>;

    isKnownNeighborRoot(
      _neighborChainID: PromiseOrValue<BigNumberish>,
      _root: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<[boolean]>;

    isKnownRoot(
      root: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<[boolean]>;

    isSpent(
      _nullifierHash: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<[boolean]>;

    isSpentArray(
      _nullifierHashes: PromiseOrValue<BigNumberish>[],
      overrides?: CallOverrides
    ): Promise<[boolean[]]>;

    isValidRoots(
      _roots: PromiseOrValue<BigNumberish>[],
      overrides?: CallOverrides
    ): Promise<[boolean]>;

    lastBalance(overrides?: CallOverrides): Promise<[BigNumber]>;

    maxEdges(overrides?: CallOverrides): Promise<[number]>;

    maximumDepositAmount(overrides?: CallOverrides): Promise<[BigNumber]>;

    minimalWithdrawalAmount(overrides?: CallOverrides): Promise<[BigNumber]>;

    neighborRoots(
      arg0: PromiseOrValue<BigNumberish>,
      arg1: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

    nullifierHashes(
      arg0: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<[boolean]>;

    outerLevels(overrides?: CallOverrides): Promise<[number]>;

    parseChainIdFromResourceId(
      _resourceId: PromiseOrValue<BytesLike>,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

    proposalNonce(overrides?: CallOverrides): Promise<[BigNumber]>;

    register(
      _account: VAnchorBase.AccountStruct,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    registerAndTransact(
      _account: VAnchorBase.AccountStruct,
      _proof: PromiseOrValue<BytesLike>,
      _auxPublicInputs: PromiseOrValue<BytesLike>,
      _externalData: CommonExtDataStruct,
      _publicInputs: PublicInputsStruct,
      _encryptions: EncryptionsStruct,
      overrides?: PayableOverrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    roots(
      arg0: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, number] & { root: BigNumber; latestLeafindex: number }
    >;

    setHandler(
      _handler: PromiseOrValue<string>,
      _nonce: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    setVerifier(
      _verifier: PromiseOrValue<string>,
      _nonce: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    token(overrides?: CallOverrides): Promise<[string]>;

    transact(
      _proof: PromiseOrValue<BytesLike>,
      _auxPublicInputs: PromiseOrValue<BytesLike>,
      _externalData: CommonExtDataStruct,
      _publicInputs: PublicInputsStruct,
      _encryptions: EncryptionsStruct,
      overrides?: PayableOverrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    unpackProof(
      _proof: PromiseOrValue<BigNumberish>[],
      overrides?: CallOverrides
    ): Promise<
      [
        [BigNumber, BigNumber],
        [[BigNumber, BigNumber], [BigNumber, BigNumber]],
        [BigNumber, BigNumber]
      ]
    >;

    updateEdge(
      _root: PromiseOrValue<BigNumberish>,
      _leafIndex: PromiseOrValue<BigNumberish>,
      _srcResourceID: PromiseOrValue<BytesLike>,
      overrides?: PayableOverrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    verifier(overrides?: CallOverrides): Promise<[string]>;
  };

  EVM_CHAIN_ID_TYPE(overrides?: CallOverrides): Promise<string>;

  FIELD_SIZE(overrides?: CallOverrides): Promise<BigNumber>;

  MAX_EXT_AMOUNT(overrides?: CallOverrides): Promise<BigNumber>;

  MAX_FEE(overrides?: CallOverrides): Promise<BigNumber>;

  ROOT_HISTORY_SIZE(overrides?: CallOverrides): Promise<number>;

  ZERO_VALUE(overrides?: CallOverrides): Promise<BigNumber>;

  _executeWrapping(
    _fromTokenAddress: PromiseOrValue<string>,
    _toTokenAddress: PromiseOrValue<string>,
    _extAmount: PromiseOrValue<BigNumberish>,
    overrides?: PayableOverrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  _genExtDataHash(
    arg0: PromiseOrValue<BytesLike>,
    _externalData: CommonExtDataStruct,
    _encryptions: EncryptionsStruct,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  _withdrawAndUnwrap(
    _fromTokenAddress: PromiseOrValue<string>,
    _toTokenAddress: PromiseOrValue<string>,
    _recipient: PromiseOrValue<string>,
    _minusExtAmount: PromiseOrValue<BigNumberish>,
    overrides?: PayableOverrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  calculatePublicAmount(
    _extAmount: PromiseOrValue<BigNumberish>,
    _fee: PromiseOrValue<BigNumberish>,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  commitments(
    arg0: PromiseOrValue<BigNumberish>,
    overrides?: CallOverrides
  ): Promise<boolean>;

  configureMaximumDepositLimit(
    _maximumDepositAmount: PromiseOrValue<BigNumberish>,
    _nonce: PromiseOrValue<BigNumberish>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  configureMinimalWithdrawalLimit(
    _minimalWithdrawalAmount: PromiseOrValue<BigNumberish>,
    _nonce: PromiseOrValue<BigNumberish>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  currentNeighborRootIndex(
    arg0: PromiseOrValue<BigNumberish>,
    overrides?: CallOverrides
  ): Promise<number>;

  edgeExistsForChain(
    arg0: PromiseOrValue<BigNumberish>,
    overrides?: CallOverrides
  ): Promise<boolean>;

  edgeIndex(
    arg0: PromiseOrValue<BigNumberish>,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  edgeList(
    arg0: PromiseOrValue<BigNumberish>,
    overrides?: CallOverrides
  ): Promise<
    [BigNumber, BigNumber, BigNumber, string] & {
      chainID: BigNumber;
      root: BigNumber;
      latestLeafIndex: BigNumber;
      srcResourceID: string;
    }
  >;

  filledSubtrees(
    arg0: PromiseOrValue<BigNumberish>,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  getChainId(overrides?: CallOverrides): Promise<BigNumber>;

  getChainIdType(overrides?: CallOverrides): Promise<number>;

  getHasher(overrides?: CallOverrides): Promise<string>;

  getLastRoot(overrides?: CallOverrides): Promise<BigNumber>;

  getLatestNeighborEdges(
    overrides?: CallOverrides
  ): Promise<EdgeStructOutput[]>;

  getLatestNeighborRoots(overrides?: CallOverrides): Promise<BigNumber[]>;

  getLevels(overrides?: CallOverrides): Promise<number>;

  getNextIndex(overrides?: CallOverrides): Promise<number>;

  getProposalNonce(overrides?: CallOverrides): Promise<BigNumber>;

  getZeroHash(
    index: PromiseOrValue<BigNumberish>,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  handler(overrides?: CallOverrides): Promise<string>;

  hasEdge(
    _chainID: PromiseOrValue<BigNumberish>,
    overrides?: CallOverrides
  ): Promise<boolean>;

  hashLeftRight(
    _left: PromiseOrValue<BigNumberish>,
    _right: PromiseOrValue<BigNumberish>,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  initialize(
    _minimalWithdrawalAmount: PromiseOrValue<BigNumberish>,
    _maximumDepositAmount: PromiseOrValue<BigNumberish>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  initialized(overrides?: CallOverrides): Promise<boolean>;

  isCorrectExecutionChain(
    resourceID: PromiseOrValue<BytesLike>,
    overrides?: CallOverrides
  ): Promise<boolean>;

  isCorrectExecutionContext(
    resourceId: PromiseOrValue<BytesLike>,
    overrides?: CallOverrides
  ): Promise<boolean>;

  isKnownNeighborRoot(
    _neighborChainID: PromiseOrValue<BigNumberish>,
    _root: PromiseOrValue<BigNumberish>,
    overrides?: CallOverrides
  ): Promise<boolean>;

  isKnownRoot(
    root: PromiseOrValue<BigNumberish>,
    overrides?: CallOverrides
  ): Promise<boolean>;

  isSpent(
    _nullifierHash: PromiseOrValue<BigNumberish>,
    overrides?: CallOverrides
  ): Promise<boolean>;

  isSpentArray(
    _nullifierHashes: PromiseOrValue<BigNumberish>[],
    overrides?: CallOverrides
  ): Promise<boolean[]>;

  isValidRoots(
    _roots: PromiseOrValue<BigNumberish>[],
    overrides?: CallOverrides
  ): Promise<boolean>;

  lastBalance(overrides?: CallOverrides): Promise<BigNumber>;

  maxEdges(overrides?: CallOverrides): Promise<number>;

  maximumDepositAmount(overrides?: CallOverrides): Promise<BigNumber>;

  minimalWithdrawalAmount(overrides?: CallOverrides): Promise<BigNumber>;

  neighborRoots(
    arg0: PromiseOrValue<BigNumberish>,
    arg1: PromiseOrValue<BigNumberish>,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  nullifierHashes(
    arg0: PromiseOrValue<BigNumberish>,
    overrides?: CallOverrides
  ): Promise<boolean>;

  outerLevels(overrides?: CallOverrides): Promise<number>;

  parseChainIdFromResourceId(
    _resourceId: PromiseOrValue<BytesLike>,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  proposalNonce(overrides?: CallOverrides): Promise<BigNumber>;

  register(
    _account: VAnchorBase.AccountStruct,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  registerAndTransact(
    _account: VAnchorBase.AccountStruct,
    _proof: PromiseOrValue<BytesLike>,
    _auxPublicInputs: PromiseOrValue<BytesLike>,
    _externalData: CommonExtDataStruct,
    _publicInputs: PublicInputsStruct,
    _encryptions: EncryptionsStruct,
    overrides?: PayableOverrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  roots(
    arg0: PromiseOrValue<BigNumberish>,
    overrides?: CallOverrides
  ): Promise<
    [BigNumber, number] & { root: BigNumber; latestLeafindex: number }
  >;

  setHandler(
    _handler: PromiseOrValue<string>,
    _nonce: PromiseOrValue<BigNumberish>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  setVerifier(
    _verifier: PromiseOrValue<string>,
    _nonce: PromiseOrValue<BigNumberish>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  token(overrides?: CallOverrides): Promise<string>;

  transact(
    _proof: PromiseOrValue<BytesLike>,
    _auxPublicInputs: PromiseOrValue<BytesLike>,
    _externalData: CommonExtDataStruct,
    _publicInputs: PublicInputsStruct,
    _encryptions: EncryptionsStruct,
    overrides?: PayableOverrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  unpackProof(
    _proof: PromiseOrValue<BigNumberish>[],
    overrides?: CallOverrides
  ): Promise<
    [
      [BigNumber, BigNumber],
      [[BigNumber, BigNumber], [BigNumber, BigNumber]],
      [BigNumber, BigNumber]
    ]
  >;

  updateEdge(
    _root: PromiseOrValue<BigNumberish>,
    _leafIndex: PromiseOrValue<BigNumberish>,
    _srcResourceID: PromiseOrValue<BytesLike>,
    overrides?: PayableOverrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  verifier(overrides?: CallOverrides): Promise<string>;

  callStatic: {
    EVM_CHAIN_ID_TYPE(overrides?: CallOverrides): Promise<string>;

    FIELD_SIZE(overrides?: CallOverrides): Promise<BigNumber>;

    MAX_EXT_AMOUNT(overrides?: CallOverrides): Promise<BigNumber>;

    MAX_FEE(overrides?: CallOverrides): Promise<BigNumber>;

    ROOT_HISTORY_SIZE(overrides?: CallOverrides): Promise<number>;

    ZERO_VALUE(overrides?: CallOverrides): Promise<BigNumber>;

    _executeWrapping(
      _fromTokenAddress: PromiseOrValue<string>,
      _toTokenAddress: PromiseOrValue<string>,
      _extAmount: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    _genExtDataHash(
      arg0: PromiseOrValue<BytesLike>,
      _externalData: CommonExtDataStruct,
      _encryptions: EncryptionsStruct,
      overrides?: CallOverrides
    ): Promise<string>;

    _withdrawAndUnwrap(
      _fromTokenAddress: PromiseOrValue<string>,
      _toTokenAddress: PromiseOrValue<string>,
      _recipient: PromiseOrValue<string>,
      _minusExtAmount: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<void>;

    calculatePublicAmount(
      _extAmount: PromiseOrValue<BigNumberish>,
      _fee: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    commitments(
      arg0: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<boolean>;

    configureMaximumDepositLimit(
      _maximumDepositAmount: PromiseOrValue<BigNumberish>,
      _nonce: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<void>;

    configureMinimalWithdrawalLimit(
      _minimalWithdrawalAmount: PromiseOrValue<BigNumberish>,
      _nonce: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<void>;

    currentNeighborRootIndex(
      arg0: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<number>;

    edgeExistsForChain(
      arg0: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<boolean>;

    edgeIndex(
      arg0: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    edgeList(
      arg0: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber, BigNumber, string] & {
        chainID: BigNumber;
        root: BigNumber;
        latestLeafIndex: BigNumber;
        srcResourceID: string;
      }
    >;

    filledSubtrees(
      arg0: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getChainId(overrides?: CallOverrides): Promise<BigNumber>;

    getChainIdType(overrides?: CallOverrides): Promise<number>;

    getHasher(overrides?: CallOverrides): Promise<string>;

    getLastRoot(overrides?: CallOverrides): Promise<BigNumber>;

    getLatestNeighborEdges(
      overrides?: CallOverrides
    ): Promise<EdgeStructOutput[]>;

    getLatestNeighborRoots(overrides?: CallOverrides): Promise<BigNumber[]>;

    getLevels(overrides?: CallOverrides): Promise<number>;

    getNextIndex(overrides?: CallOverrides): Promise<number>;

    getProposalNonce(overrides?: CallOverrides): Promise<BigNumber>;

    getZeroHash(
      index: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    handler(overrides?: CallOverrides): Promise<string>;

    hasEdge(
      _chainID: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<boolean>;

    hashLeftRight(
      _left: PromiseOrValue<BigNumberish>,
      _right: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    initialize(
      _minimalWithdrawalAmount: PromiseOrValue<BigNumberish>,
      _maximumDepositAmount: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<void>;

    initialized(overrides?: CallOverrides): Promise<boolean>;

    isCorrectExecutionChain(
      resourceID: PromiseOrValue<BytesLike>,
      overrides?: CallOverrides
    ): Promise<boolean>;

    isCorrectExecutionContext(
      resourceId: PromiseOrValue<BytesLike>,
      overrides?: CallOverrides
    ): Promise<boolean>;

    isKnownNeighborRoot(
      _neighborChainID: PromiseOrValue<BigNumberish>,
      _root: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<boolean>;

    isKnownRoot(
      root: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<boolean>;

    isSpent(
      _nullifierHash: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<boolean>;

    isSpentArray(
      _nullifierHashes: PromiseOrValue<BigNumberish>[],
      overrides?: CallOverrides
    ): Promise<boolean[]>;

    isValidRoots(
      _roots: PromiseOrValue<BigNumberish>[],
      overrides?: CallOverrides
    ): Promise<boolean>;

    lastBalance(overrides?: CallOverrides): Promise<BigNumber>;

    maxEdges(overrides?: CallOverrides): Promise<number>;

    maximumDepositAmount(overrides?: CallOverrides): Promise<BigNumber>;

    minimalWithdrawalAmount(overrides?: CallOverrides): Promise<BigNumber>;

    neighborRoots(
      arg0: PromiseOrValue<BigNumberish>,
      arg1: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    nullifierHashes(
      arg0: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<boolean>;

    outerLevels(overrides?: CallOverrides): Promise<number>;

    parseChainIdFromResourceId(
      _resourceId: PromiseOrValue<BytesLike>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    proposalNonce(overrides?: CallOverrides): Promise<BigNumber>;

    register(
      _account: VAnchorBase.AccountStruct,
      overrides?: CallOverrides
    ): Promise<void>;

    registerAndTransact(
      _account: VAnchorBase.AccountStruct,
      _proof: PromiseOrValue<BytesLike>,
      _auxPublicInputs: PromiseOrValue<BytesLike>,
      _externalData: CommonExtDataStruct,
      _publicInputs: PublicInputsStruct,
      _encryptions: EncryptionsStruct,
      overrides?: CallOverrides
    ): Promise<void>;

    roots(
      arg0: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, number] & { root: BigNumber; latestLeafindex: number }
    >;

    setHandler(
      _handler: PromiseOrValue<string>,
      _nonce: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<void>;

    setVerifier(
      _verifier: PromiseOrValue<string>,
      _nonce: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<void>;

    token(overrides?: CallOverrides): Promise<string>;

    transact(
      _proof: PromiseOrValue<BytesLike>,
      _auxPublicInputs: PromiseOrValue<BytesLike>,
      _externalData: CommonExtDataStruct,
      _publicInputs: PublicInputsStruct,
      _encryptions: EncryptionsStruct,
      overrides?: CallOverrides
    ): Promise<void>;

    unpackProof(
      _proof: PromiseOrValue<BigNumberish>[],
      overrides?: CallOverrides
    ): Promise<
      [
        [BigNumber, BigNumber],
        [[BigNumber, BigNumber], [BigNumber, BigNumber]],
        [BigNumber, BigNumber]
      ]
    >;

    updateEdge(
      _root: PromiseOrValue<BigNumberish>,
      _leafIndex: PromiseOrValue<BigNumberish>,
      _srcResourceID: PromiseOrValue<BytesLike>,
      overrides?: CallOverrides
    ): Promise<void>;

    verifier(overrides?: CallOverrides): Promise<string>;
  };

  filters: {
    "EdgeAddition(uint256,uint256,uint256)"(
      chainID?: null,
      latestLeafIndex?: null,
      merkleRoot?: null
    ): EdgeAdditionEventFilter;
    EdgeAddition(
      chainID?: null,
      latestLeafIndex?: null,
      merkleRoot?: null
    ): EdgeAdditionEventFilter;

    "EdgeUpdate(uint256,uint256,uint256)"(
      chainID?: null,
      latestLeafIndex?: null,
      merkleRoot?: null
    ): EdgeUpdateEventFilter;
    EdgeUpdate(
      chainID?: null,
      latestLeafIndex?: null,
      merkleRoot?: null
    ): EdgeUpdateEventFilter;

    "Insertion(uint256,uint32,uint256,uint256)"(
      commitment?: PromiseOrValue<BigNumberish> | null,
      leafIndex?: null,
      timestamp?: null,
      newMerkleRoot?: PromiseOrValue<BigNumberish> | null
    ): InsertionEventFilter;
    Insertion(
      commitment?: PromiseOrValue<BigNumberish> | null,
      leafIndex?: null,
      timestamp?: null,
      newMerkleRoot?: PromiseOrValue<BigNumberish> | null
    ): InsertionEventFilter;

    "NewCommitment(uint256,uint256,uint256,bytes)"(
      commitment?: null,
      subTreeIndex?: null,
      leafIndex?: null,
      encryptedOutput?: null
    ): NewCommitmentEventFilter;
    NewCommitment(
      commitment?: null,
      subTreeIndex?: null,
      leafIndex?: null,
      encryptedOutput?: null
    ): NewCommitmentEventFilter;

    "NewNullifier(uint256)"(nullifier?: null): NewNullifierEventFilter;
    NewNullifier(nullifier?: null): NewNullifierEventFilter;

    "PublicKey(address,bytes)"(
      owner?: PromiseOrValue<string> | null,
      key?: null
    ): PublicKeyEventFilter;
    PublicKey(
      owner?: PromiseOrValue<string> | null,
      key?: null
    ): PublicKeyEventFilter;
  };

  estimateGas: {
    EVM_CHAIN_ID_TYPE(overrides?: CallOverrides): Promise<BigNumber>;

    FIELD_SIZE(overrides?: CallOverrides): Promise<BigNumber>;

    MAX_EXT_AMOUNT(overrides?: CallOverrides): Promise<BigNumber>;

    MAX_FEE(overrides?: CallOverrides): Promise<BigNumber>;

    ROOT_HISTORY_SIZE(overrides?: CallOverrides): Promise<BigNumber>;

    ZERO_VALUE(overrides?: CallOverrides): Promise<BigNumber>;

    _executeWrapping(
      _fromTokenAddress: PromiseOrValue<string>,
      _toTokenAddress: PromiseOrValue<string>,
      _extAmount: PromiseOrValue<BigNumberish>,
      overrides?: PayableOverrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    _genExtDataHash(
      arg0: PromiseOrValue<BytesLike>,
      _externalData: CommonExtDataStruct,
      _encryptions: EncryptionsStruct,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    _withdrawAndUnwrap(
      _fromTokenAddress: PromiseOrValue<string>,
      _toTokenAddress: PromiseOrValue<string>,
      _recipient: PromiseOrValue<string>,
      _minusExtAmount: PromiseOrValue<BigNumberish>,
      overrides?: PayableOverrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    calculatePublicAmount(
      _extAmount: PromiseOrValue<BigNumberish>,
      _fee: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    commitments(
      arg0: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    configureMaximumDepositLimit(
      _maximumDepositAmount: PromiseOrValue<BigNumberish>,
      _nonce: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    configureMinimalWithdrawalLimit(
      _minimalWithdrawalAmount: PromiseOrValue<BigNumberish>,
      _nonce: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    currentNeighborRootIndex(
      arg0: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    edgeExistsForChain(
      arg0: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    edgeIndex(
      arg0: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    edgeList(
      arg0: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    filledSubtrees(
      arg0: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getChainId(overrides?: CallOverrides): Promise<BigNumber>;

    getChainIdType(overrides?: CallOverrides): Promise<BigNumber>;

    getHasher(overrides?: CallOverrides): Promise<BigNumber>;

    getLastRoot(overrides?: CallOverrides): Promise<BigNumber>;

    getLatestNeighborEdges(overrides?: CallOverrides): Promise<BigNumber>;

    getLatestNeighborRoots(overrides?: CallOverrides): Promise<BigNumber>;

    getLevels(overrides?: CallOverrides): Promise<BigNumber>;

    getNextIndex(overrides?: CallOverrides): Promise<BigNumber>;

    getProposalNonce(overrides?: CallOverrides): Promise<BigNumber>;

    getZeroHash(
      index: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    handler(overrides?: CallOverrides): Promise<BigNumber>;

    hasEdge(
      _chainID: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    hashLeftRight(
      _left: PromiseOrValue<BigNumberish>,
      _right: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    initialize(
      _minimalWithdrawalAmount: PromiseOrValue<BigNumberish>,
      _maximumDepositAmount: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    initialized(overrides?: CallOverrides): Promise<BigNumber>;

    isCorrectExecutionChain(
      resourceID: PromiseOrValue<BytesLike>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    isCorrectExecutionContext(
      resourceId: PromiseOrValue<BytesLike>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    isKnownNeighborRoot(
      _neighborChainID: PromiseOrValue<BigNumberish>,
      _root: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    isKnownRoot(
      root: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    isSpent(
      _nullifierHash: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    isSpentArray(
      _nullifierHashes: PromiseOrValue<BigNumberish>[],
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    isValidRoots(
      _roots: PromiseOrValue<BigNumberish>[],
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    lastBalance(overrides?: CallOverrides): Promise<BigNumber>;

    maxEdges(overrides?: CallOverrides): Promise<BigNumber>;

    maximumDepositAmount(overrides?: CallOverrides): Promise<BigNumber>;

    minimalWithdrawalAmount(overrides?: CallOverrides): Promise<BigNumber>;

    neighborRoots(
      arg0: PromiseOrValue<BigNumberish>,
      arg1: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    nullifierHashes(
      arg0: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    outerLevels(overrides?: CallOverrides): Promise<BigNumber>;

    parseChainIdFromResourceId(
      _resourceId: PromiseOrValue<BytesLike>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    proposalNonce(overrides?: CallOverrides): Promise<BigNumber>;

    register(
      _account: VAnchorBase.AccountStruct,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    registerAndTransact(
      _account: VAnchorBase.AccountStruct,
      _proof: PromiseOrValue<BytesLike>,
      _auxPublicInputs: PromiseOrValue<BytesLike>,
      _externalData: CommonExtDataStruct,
      _publicInputs: PublicInputsStruct,
      _encryptions: EncryptionsStruct,
      overrides?: PayableOverrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    roots(
      arg0: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    setHandler(
      _handler: PromiseOrValue<string>,
      _nonce: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    setVerifier(
      _verifier: PromiseOrValue<string>,
      _nonce: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    token(overrides?: CallOverrides): Promise<BigNumber>;

    transact(
      _proof: PromiseOrValue<BytesLike>,
      _auxPublicInputs: PromiseOrValue<BytesLike>,
      _externalData: CommonExtDataStruct,
      _publicInputs: PublicInputsStruct,
      _encryptions: EncryptionsStruct,
      overrides?: PayableOverrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    unpackProof(
      _proof: PromiseOrValue<BigNumberish>[],
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    updateEdge(
      _root: PromiseOrValue<BigNumberish>,
      _leafIndex: PromiseOrValue<BigNumberish>,
      _srcResourceID: PromiseOrValue<BytesLike>,
      overrides?: PayableOverrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    verifier(overrides?: CallOverrides): Promise<BigNumber>;
  };

  populateTransaction: {
    EVM_CHAIN_ID_TYPE(overrides?: CallOverrides): Promise<PopulatedTransaction>;

    FIELD_SIZE(overrides?: CallOverrides): Promise<PopulatedTransaction>;

    MAX_EXT_AMOUNT(overrides?: CallOverrides): Promise<PopulatedTransaction>;

    MAX_FEE(overrides?: CallOverrides): Promise<PopulatedTransaction>;

    ROOT_HISTORY_SIZE(overrides?: CallOverrides): Promise<PopulatedTransaction>;

    ZERO_VALUE(overrides?: CallOverrides): Promise<PopulatedTransaction>;

    _executeWrapping(
      _fromTokenAddress: PromiseOrValue<string>,
      _toTokenAddress: PromiseOrValue<string>,
      _extAmount: PromiseOrValue<BigNumberish>,
      overrides?: PayableOverrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    _genExtDataHash(
      arg0: PromiseOrValue<BytesLike>,
      _externalData: CommonExtDataStruct,
      _encryptions: EncryptionsStruct,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    _withdrawAndUnwrap(
      _fromTokenAddress: PromiseOrValue<string>,
      _toTokenAddress: PromiseOrValue<string>,
      _recipient: PromiseOrValue<string>,
      _minusExtAmount: PromiseOrValue<BigNumberish>,
      overrides?: PayableOverrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    calculatePublicAmount(
      _extAmount: PromiseOrValue<BigNumberish>,
      _fee: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    commitments(
      arg0: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    configureMaximumDepositLimit(
      _maximumDepositAmount: PromiseOrValue<BigNumberish>,
      _nonce: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    configureMinimalWithdrawalLimit(
      _minimalWithdrawalAmount: PromiseOrValue<BigNumberish>,
      _nonce: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    currentNeighborRootIndex(
      arg0: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    edgeExistsForChain(
      arg0: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    edgeIndex(
      arg0: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    edgeList(
      arg0: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    filledSubtrees(
      arg0: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    getChainId(overrides?: CallOverrides): Promise<PopulatedTransaction>;

    getChainIdType(overrides?: CallOverrides): Promise<PopulatedTransaction>;

    getHasher(overrides?: CallOverrides): Promise<PopulatedTransaction>;

    getLastRoot(overrides?: CallOverrides): Promise<PopulatedTransaction>;

    getLatestNeighborEdges(
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    getLatestNeighborRoots(
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    getLevels(overrides?: CallOverrides): Promise<PopulatedTransaction>;

    getNextIndex(overrides?: CallOverrides): Promise<PopulatedTransaction>;

    getProposalNonce(overrides?: CallOverrides): Promise<PopulatedTransaction>;

    getZeroHash(
      index: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    handler(overrides?: CallOverrides): Promise<PopulatedTransaction>;

    hasEdge(
      _chainID: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    hashLeftRight(
      _left: PromiseOrValue<BigNumberish>,
      _right: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    initialize(
      _minimalWithdrawalAmount: PromiseOrValue<BigNumberish>,
      _maximumDepositAmount: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    initialized(overrides?: CallOverrides): Promise<PopulatedTransaction>;

    isCorrectExecutionChain(
      resourceID: PromiseOrValue<BytesLike>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    isCorrectExecutionContext(
      resourceId: PromiseOrValue<BytesLike>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    isKnownNeighborRoot(
      _neighborChainID: PromiseOrValue<BigNumberish>,
      _root: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    isKnownRoot(
      root: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    isSpent(
      _nullifierHash: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    isSpentArray(
      _nullifierHashes: PromiseOrValue<BigNumberish>[],
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    isValidRoots(
      _roots: PromiseOrValue<BigNumberish>[],
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    lastBalance(overrides?: CallOverrides): Promise<PopulatedTransaction>;

    maxEdges(overrides?: CallOverrides): Promise<PopulatedTransaction>;

    maximumDepositAmount(
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    minimalWithdrawalAmount(
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    neighborRoots(
      arg0: PromiseOrValue<BigNumberish>,
      arg1: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    nullifierHashes(
      arg0: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    outerLevels(overrides?: CallOverrides): Promise<PopulatedTransaction>;

    parseChainIdFromResourceId(
      _resourceId: PromiseOrValue<BytesLike>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    proposalNonce(overrides?: CallOverrides): Promise<PopulatedTransaction>;

    register(
      _account: VAnchorBase.AccountStruct,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    registerAndTransact(
      _account: VAnchorBase.AccountStruct,
      _proof: PromiseOrValue<BytesLike>,
      _auxPublicInputs: PromiseOrValue<BytesLike>,
      _externalData: CommonExtDataStruct,
      _publicInputs: PublicInputsStruct,
      _encryptions: EncryptionsStruct,
      overrides?: PayableOverrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    roots(
      arg0: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    setHandler(
      _handler: PromiseOrValue<string>,
      _nonce: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    setVerifier(
      _verifier: PromiseOrValue<string>,
      _nonce: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    token(overrides?: CallOverrides): Promise<PopulatedTransaction>;

    transact(
      _proof: PromiseOrValue<BytesLike>,
      _auxPublicInputs: PromiseOrValue<BytesLike>,
      _externalData: CommonExtDataStruct,
      _publicInputs: PublicInputsStruct,
      _encryptions: EncryptionsStruct,
      overrides?: PayableOverrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    unpackProof(
      _proof: PromiseOrValue<BigNumberish>[],
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    updateEdge(
      _root: PromiseOrValue<BigNumberish>,
      _leafIndex: PromiseOrValue<BigNumberish>,
      _srcResourceID: PromiseOrValue<BytesLike>,
      overrides?: PayableOverrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    verifier(overrides?: CallOverrides): Promise<PopulatedTransaction>;
  };
}
