Options
All
  • Public
  • Public/Protected
  • All
Menu

Class LinkableVAnchor

Hierarchy

  • BaseContract
    • LinkableVAnchor

Index

Constructors

Properties

Methods

Constructors

constructor

  • new LinkableVAnchor(addressOrName: string, contractInterface: ContractInterface, signerOrProvider?: Signer | Provider): LinkableVAnchor

  • Parameters

    • addressOrName: string
    • contractInterface: ContractInterface
    • Optional signerOrProvider: Signer | Provider

    Returns LinkableVAnchor

Properties

_deployedPromise

_deployedPromise: Promise<Contract>

_runningEvents

_runningEvents: {}

Type declaration

  • [eventTag: string]: RunningEvent

_wrappedEmits

_wrappedEmits: {}

Type declaration

  • [eventTag: string]: (...args: any[]) => void
      • (...args: any[]): void

      • Parameters

        • Rest ...args: any[]

        Returns void

Readonly address

address: string

callStatic

callStatic: { FIELD_SIZE: any; MAX_EXT_AMOUNT: any; MAX_FEE: any; ROOT_HISTORY_SIZE: any; ZERO_VALUE: any; calculatePublicAmount: any; configureLimits: any; currentNeighborRootIndex: any; currentRootIndex: any; edgeExistsForChain: any; edgeIndex: any; edgeList: any; filledSubtrees: any; getLastRoot: any; getLatestNeighborEdges: any; hasEdge: any; hashLeftRight: any; hasher: any; initialize: any; isKnownNeighborRoot: any; isKnownRoot: any; isSpent: any; isValidRoots: any; lastBalance: any; levels: any; maxEdges: any; maximumDepositAmount: any; minimalWithdrawalAmount: any; neighborRoots: any; nextIndex: any; nullifierHashes: any; permissions: any; register: any; registerAndTransact: any; roots: any; setHandler: any; setVerifier: any; transact: any; unpackProof: any; updateEdge: any; verifier: any; zeros: any }

Type declaration

  • FIELD_SIZE:function
    • FIELD_SIZE(overrides?: CallOverrides): Promise<BigNumber>
  • MAX_EXT_AMOUNT:function
    • MAX_EXT_AMOUNT(overrides?: CallOverrides): Promise<BigNumber>
  • MAX_FEE:function
    • MAX_FEE(overrides?: CallOverrides): Promise<BigNumber>
  • ROOT_HISTORY_SIZE:function
    • ROOT_HISTORY_SIZE(overrides?: CallOverrides): Promise<number>
  • ZERO_VALUE:function
    • ZERO_VALUE(overrides?: CallOverrides): Promise<BigNumber>
  • calculatePublicAmount:function
    • calculatePublicAmount(_extAmount: BigNumberish, _fee: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>
  • configureLimits:function
    • configureLimits(_minimalWithdrawalAmount: BigNumberish, _maximumDepositAmount: BigNumberish, overrides?: CallOverrides): Promise<void>
  • currentNeighborRootIndex:function
    • currentNeighborRootIndex(arg0: BigNumberish, overrides?: CallOverrides): Promise<number>
  • currentRootIndex:function
    • currentRootIndex(overrides?: CallOverrides): Promise<number>
  • edgeExistsForChain:function
    • edgeExistsForChain(arg0: BigNumberish, overrides?: CallOverrides): Promise<boolean>
  • edgeIndex:function
    • edgeIndex(arg0: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>
  • edgeList:function
    • edgeList(arg0: BigNumberish, overrides?: CallOverrides): Promise<[BigNumber, string, BigNumber] & { chainID: BigNumber; latestLeafIndex: BigNumber; root: string }>
  • filledSubtrees:function
    • filledSubtrees(arg0: BigNumberish, overrides?: CallOverrides): Promise<string>
  • getLastRoot:function
    • getLastRoot(overrides?: CallOverrides): Promise<string>
  • getLatestNeighborEdges:function
    • getLatestNeighborEdges(overrides?: CallOverrides): Promise<([BigNumber, string, BigNumber] & { chainID: BigNumber; latestLeafIndex: BigNumber; root: string })[]>
  • hasEdge:function
    • hasEdge(_chainID: BigNumberish, overrides?: CallOverrides): Promise<boolean>
  • hashLeftRight:function
    • hashLeftRight(_left: BytesLike, _right: BytesLike, overrides?: CallOverrides): Promise<string>
  • hasher:function
    • hasher(overrides?: CallOverrides): Promise<string>
  • initialize:function
    • initialize(_minimalWithdrawalAmount: BigNumberish, _maximumDepositAmount: BigNumberish, overrides?: CallOverrides): Promise<void>
  • isKnownNeighborRoot:function
    • isKnownNeighborRoot(neighborChainID: BigNumberish, _root: BytesLike, overrides?: CallOverrides): Promise<boolean>
  • isKnownRoot:function
    • isKnownRoot(_root: BytesLike, overrides?: CallOverrides): Promise<boolean>
  • isSpent:function
    • isSpent(_nullifierHash: BytesLike, overrides?: CallOverrides): Promise<boolean>
  • isValidRoots:function
    • isValidRoots(roots: BytesLike[], overrides?: CallOverrides): Promise<boolean>
  • lastBalance:function
    • lastBalance(overrides?: CallOverrides): Promise<BigNumber>
  • levels:function
    • levels(overrides?: CallOverrides): Promise<number>
  • maxEdges:function
    • maxEdges(overrides?: CallOverrides): Promise<number>
  • maximumDepositAmount:function
    • maximumDepositAmount(overrides?: CallOverrides): Promise<BigNumber>
  • minimalWithdrawalAmount:function
    • minimalWithdrawalAmount(overrides?: CallOverrides): Promise<BigNumber>
  • neighborRoots:function
    • neighborRoots(arg0: BigNumberish, arg1: BigNumberish, overrides?: CallOverrides): Promise<string>
  • nextIndex:function
    • nextIndex(overrides?: CallOverrides): Promise<number>
  • nullifierHashes:function
    • nullifierHashes(arg0: BytesLike, overrides?: CallOverrides): Promise<boolean>
  • permissions:function
    • permissions(overrides?: CallOverrides): Promise<[string, string, string] & { admin: string; bridge: string; handler: string }>
  • register:function
    • register(_account: { owner: string; publicKey: BytesLike }, overrides?: CallOverrides): Promise<void>
  • registerAndTransact:function
    • registerAndTransact(_account: { owner: string; publicKey: BytesLike }, _proofArgs: { extDataHash: BytesLike; inputNullifiers: BytesLike[]; outputCommitments: [BytesLike, BytesLike]; proof: BytesLike; publicAmount: BigNumberish; roots: BytesLike }, _extData: { encryptedOutput1: BytesLike; encryptedOutput2: BytesLike; extAmount: BigNumberish; fee: BigNumberish; recipient: string; relayer: string }, overrides?: CallOverrides): Promise<void>

    • Parameters

      • _account: { owner: string; publicKey: BytesLike }
        • owner: string
        • publicKey: BytesLike
      • _proofArgs: { extDataHash: BytesLike; inputNullifiers: BytesLike[]; outputCommitments: [BytesLike, BytesLike]; proof: BytesLike; publicAmount: BigNumberish; roots: BytesLike }
        • extDataHash: BytesLike
        • inputNullifiers: BytesLike[]
        • outputCommitments: [BytesLike, BytesLike]
        • proof: BytesLike
        • publicAmount: BigNumberish
        • roots: BytesLike
      • _extData: { encryptedOutput1: BytesLike; encryptedOutput2: BytesLike; extAmount: BigNumberish; fee: BigNumberish; recipient: string; relayer: string }
        • encryptedOutput1: BytesLike
        • encryptedOutput2: BytesLike
        • extAmount: BigNumberish
        • fee: BigNumberish
        • recipient: string
        • relayer: string
      • Optional overrides: CallOverrides

      Returns Promise<void>

  • roots:function
    • roots(arg0: BigNumberish, overrides?: CallOverrides): Promise<string>
  • setHandler:function
    • setHandler(_handler: string, nonce: BigNumberish, overrides?: CallOverrides): Promise<void>
  • setVerifier:function
    • setVerifier(newVerifier: string, overrides?: CallOverrides): Promise<void>
  • transact:function
    • transact(_args: { extDataHash: BytesLike; inputNullifiers: BytesLike[]; outputCommitments: [BytesLike, BytesLike]; proof: BytesLike; publicAmount: BigNumberish; roots: BytesLike }, _extData: { encryptedOutput1: BytesLike; encryptedOutput2: BytesLike; extAmount: BigNumberish; fee: BigNumberish; recipient: string; relayer: string }, overrides?: CallOverrides): Promise<void>

    • Parameters

      • _args: { extDataHash: BytesLike; inputNullifiers: BytesLike[]; outputCommitments: [BytesLike, BytesLike]; proof: BytesLike; publicAmount: BigNumberish; roots: BytesLike }
        • extDataHash: BytesLike
        • inputNullifiers: BytesLike[]
        • outputCommitments: [BytesLike, BytesLike]
        • proof: BytesLike
        • publicAmount: BigNumberish
        • roots: BytesLike
      • _extData: { encryptedOutput1: BytesLike; encryptedOutput2: BytesLike; extAmount: BigNumberish; fee: BigNumberish; recipient: string; relayer: string }
        • encryptedOutput1: BytesLike
        • encryptedOutput2: BytesLike
        • extAmount: BigNumberish
        • fee: BigNumberish
        • recipient: string
        • relayer: string
      • Optional overrides: CallOverrides

      Returns Promise<void>

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

    • Parameters

      • _proof: [BigNumberish, BigNumberish, BigNumberish, BigNumberish, BigNumberish, BigNumberish, BigNumberish, BigNumberish]
      • Optional overrides: CallOverrides

      Returns Promise<[[BigNumber, BigNumber], [[BigNumber, BigNumber], [BigNumber, BigNumber]], [BigNumber, BigNumber]]>

  • updateEdge:function
    • updateEdge(sourceChainID: BigNumberish, root: BytesLike, leafIndex: BigNumberish, overrides?: CallOverrides): Promise<void>
  • verifier:function
    • verifier(overrides?: CallOverrides): Promise<string>
  • zeros:function
    • zeros(i: BigNumberish, overrides?: CallOverrides): Promise<string>

Readonly deployTransaction

deployTransaction: TransactionResponse

estimateGas

estimateGas: { FIELD_SIZE: any; MAX_EXT_AMOUNT: any; MAX_FEE: any; ROOT_HISTORY_SIZE: any; ZERO_VALUE: any; calculatePublicAmount: any; configureLimits: any; currentNeighborRootIndex: any; currentRootIndex: any; edgeExistsForChain: any; edgeIndex: any; edgeList: any; filledSubtrees: any; getLastRoot: any; getLatestNeighborEdges: any; hasEdge: any; hashLeftRight: any; hasher: any; initialize: any; isKnownNeighborRoot: any; isKnownRoot: any; isSpent: any; isValidRoots: any; lastBalance: any; levels: any; maxEdges: any; maximumDepositAmount: any; minimalWithdrawalAmount: any; neighborRoots: any; nextIndex: any; nullifierHashes: any; permissions: any; register: any; registerAndTransact: any; roots: any; setHandler: any; setVerifier: any; transact: any; unpackProof: any; updateEdge: any; verifier: any; zeros: any }

Type declaration

  • FIELD_SIZE:function
    • FIELD_SIZE(overrides?: CallOverrides): Promise<BigNumber>
  • MAX_EXT_AMOUNT:function
    • MAX_EXT_AMOUNT(overrides?: CallOverrides): Promise<BigNumber>
  • MAX_FEE:function
    • MAX_FEE(overrides?: CallOverrides): Promise<BigNumber>
  • ROOT_HISTORY_SIZE:function
    • ROOT_HISTORY_SIZE(overrides?: CallOverrides): Promise<BigNumber>
  • ZERO_VALUE:function
    • ZERO_VALUE(overrides?: CallOverrides): Promise<BigNumber>
  • calculatePublicAmount:function
    • calculatePublicAmount(_extAmount: BigNumberish, _fee: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>
  • configureLimits:function
    • configureLimits(_minimalWithdrawalAmount: BigNumberish, _maximumDepositAmount: BigNumberish, overrides?: Overrides & { from?: string | Promise<string> }): Promise<BigNumber>
  • currentNeighborRootIndex:function
    • currentNeighborRootIndex(arg0: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>
  • currentRootIndex:function
    • currentRootIndex(overrides?: CallOverrides): Promise<BigNumber>
  • edgeExistsForChain:function
    • edgeExistsForChain(arg0: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>
  • edgeIndex:function
    • edgeIndex(arg0: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>
  • edgeList:function
    • edgeList(arg0: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>
  • filledSubtrees:function
    • filledSubtrees(arg0: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>
  • getLastRoot:function
    • getLastRoot(overrides?: CallOverrides): Promise<BigNumber>
  • getLatestNeighborEdges:function
    • getLatestNeighborEdges(overrides?: CallOverrides): Promise<BigNumber>
  • hasEdge:function
    • hasEdge(_chainID: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>
  • hashLeftRight:function
    • hashLeftRight(_left: BytesLike, _right: BytesLike, overrides?: CallOverrides): Promise<BigNumber>
  • hasher:function
    • hasher(overrides?: CallOverrides): Promise<BigNumber>
  • initialize:function
    • initialize(_minimalWithdrawalAmount: BigNumberish, _maximumDepositAmount: BigNumberish, overrides?: Overrides & { from?: string | Promise<string> }): Promise<BigNumber>
  • isKnownNeighborRoot:function
    • isKnownNeighborRoot(neighborChainID: BigNumberish, _root: BytesLike, overrides?: CallOverrides): Promise<BigNumber>
  • isKnownRoot:function
    • isKnownRoot(_root: BytesLike, overrides?: CallOverrides): Promise<BigNumber>
  • isSpent:function
    • isSpent(_nullifierHash: BytesLike, overrides?: CallOverrides): Promise<BigNumber>
  • isValidRoots:function
    • isValidRoots(roots: BytesLike[], overrides?: CallOverrides): Promise<BigNumber>
  • lastBalance:function
    • lastBalance(overrides?: CallOverrides): Promise<BigNumber>
  • levels:function
    • levels(overrides?: CallOverrides): Promise<BigNumber>
  • maxEdges:function
    • maxEdges(overrides?: CallOverrides): Promise<BigNumber>
  • maximumDepositAmount:function
    • maximumDepositAmount(overrides?: CallOverrides): Promise<BigNumber>
  • minimalWithdrawalAmount:function
    • minimalWithdrawalAmount(overrides?: CallOverrides): Promise<BigNumber>
  • neighborRoots:function
    • neighborRoots(arg0: BigNumberish, arg1: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>
  • nextIndex:function
    • nextIndex(overrides?: CallOverrides): Promise<BigNumber>
  • nullifierHashes:function
    • nullifierHashes(arg0: BytesLike, overrides?: CallOverrides): Promise<BigNumber>
  • permissions:function
    • permissions(overrides?: CallOverrides): Promise<BigNumber>
  • register:function
    • register(_account: { owner: string; publicKey: BytesLike }, overrides?: Overrides & { from?: string | Promise<string> }): Promise<BigNumber>

    • Parameters

      • _account: { owner: string; publicKey: BytesLike }
        • owner: string
        • publicKey: BytesLike
      • Optional overrides: Overrides & { from?: string | Promise<string> }

      Returns Promise<BigNumber>

  • registerAndTransact:function
    • registerAndTransact(_account: { owner: string; publicKey: BytesLike }, _proofArgs: { extDataHash: BytesLike; inputNullifiers: BytesLike[]; outputCommitments: [BytesLike, BytesLike]; proof: BytesLike; publicAmount: BigNumberish; roots: BytesLike }, _extData: { encryptedOutput1: BytesLike; encryptedOutput2: BytesLike; extAmount: BigNumberish; fee: BigNumberish; recipient: string; relayer: string }, overrides?: Overrides & { from?: string | Promise<string> }): Promise<BigNumber>

    • Parameters

      • _account: { owner: string; publicKey: BytesLike }
        • owner: string
        • publicKey: BytesLike
      • _proofArgs: { extDataHash: BytesLike; inputNullifiers: BytesLike[]; outputCommitments: [BytesLike, BytesLike]; proof: BytesLike; publicAmount: BigNumberish; roots: BytesLike }
        • extDataHash: BytesLike
        • inputNullifiers: BytesLike[]
        • outputCommitments: [BytesLike, BytesLike]
        • proof: BytesLike
        • publicAmount: BigNumberish
        • roots: BytesLike
      • _extData: { encryptedOutput1: BytesLike; encryptedOutput2: BytesLike; extAmount: BigNumberish; fee: BigNumberish; recipient: string; relayer: string }
        • encryptedOutput1: BytesLike
        • encryptedOutput2: BytesLike
        • extAmount: BigNumberish
        • fee: BigNumberish
        • recipient: string
        • relayer: string
      • Optional overrides: Overrides & { from?: string | Promise<string> }

      Returns Promise<BigNumber>

  • roots:function
    • roots(arg0: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>
  • setHandler:function
    • setHandler(_handler: string, nonce: BigNumberish, overrides?: Overrides & { from?: string | Promise<string> }): Promise<BigNumber>
  • setVerifier:function
    • setVerifier(newVerifier: string, overrides?: Overrides & { from?: string | Promise<string> }): Promise<BigNumber>
  • transact:function
    • transact(_args: { extDataHash: BytesLike; inputNullifiers: BytesLike[]; outputCommitments: [BytesLike, BytesLike]; proof: BytesLike; publicAmount: BigNumberish; roots: BytesLike }, _extData: { encryptedOutput1: BytesLike; encryptedOutput2: BytesLike; extAmount: BigNumberish; fee: BigNumberish; recipient: string; relayer: string }, overrides?: Overrides & { from?: string | Promise<string> }): Promise<BigNumber>

    • Parameters

      • _args: { extDataHash: BytesLike; inputNullifiers: BytesLike[]; outputCommitments: [BytesLike, BytesLike]; proof: BytesLike; publicAmount: BigNumberish; roots: BytesLike }
        • extDataHash: BytesLike
        • inputNullifiers: BytesLike[]
        • outputCommitments: [BytesLike, BytesLike]
        • proof: BytesLike
        • publicAmount: BigNumberish
        • roots: BytesLike
      • _extData: { encryptedOutput1: BytesLike; encryptedOutput2: BytesLike; extAmount: BigNumberish; fee: BigNumberish; recipient: string; relayer: string }
        • encryptedOutput1: BytesLike
        • encryptedOutput2: BytesLike
        • extAmount: BigNumberish
        • fee: BigNumberish
        • recipient: string
        • relayer: string
      • Optional overrides: Overrides & { from?: string | Promise<string> }

      Returns Promise<BigNumber>

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

    • Parameters

      • _proof: [BigNumberish, BigNumberish, BigNumberish, BigNumberish, BigNumberish, BigNumberish, BigNumberish, BigNumberish]
      • Optional overrides: CallOverrides

      Returns Promise<BigNumber>

  • updateEdge:function
    • updateEdge(sourceChainID: BigNumberish, root: BytesLike, leafIndex: BigNumberish, overrides?: PayableOverrides & { from?: string | Promise<string> }): Promise<BigNumber>
  • verifier:function
    • verifier(overrides?: CallOverrides): Promise<BigNumber>
  • zeros:function
    • zeros(i: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>

filters

filters: { EdgeAddition: any; EdgeAddition(uint256,uint256,bytes32): any; EdgeUpdate: any; EdgeUpdate(uint256,uint256,bytes32): any; NewCommitment: any; NewCommitment(bytes32,uint256,bytes): any; NewNullifier: any; NewNullifier(bytes32): any; PublicKey: any; PublicKey(address,bytes): any }

Type declaration

  • EdgeAddition:function
    • EdgeAddition(chainID?: null, latestLeafIndex?: null, merkleRoot?: null): TypedEventFilter<[BigNumber, BigNumber, string], { chainID: BigNumber; latestLeafIndex: BigNumber; merkleRoot: string }>

    • Parameters

      • Optional chainID: null
      • Optional latestLeafIndex: null
      • Optional merkleRoot: null

      Returns TypedEventFilter<[BigNumber, BigNumber, string], { chainID: BigNumber; latestLeafIndex: BigNumber; merkleRoot: string }>

  • EdgeAddition(uint256,uint256,bytes32):function
    • EdgeAddition(uint256,uint256,bytes32)(chainID?: null, latestLeafIndex?: null, merkleRoot?: null): TypedEventFilter<[BigNumber, BigNumber, string], { chainID: BigNumber; latestLeafIndex: BigNumber; merkleRoot: string }>

    • Parameters

      • Optional chainID: null
      • Optional latestLeafIndex: null
      • Optional merkleRoot: null

      Returns TypedEventFilter<[BigNumber, BigNumber, string], { chainID: BigNumber; latestLeafIndex: BigNumber; merkleRoot: string }>

  • EdgeUpdate:function
    • EdgeUpdate(chainID?: null, latestLeafIndex?: null, merkleRoot?: null): TypedEventFilter<[BigNumber, BigNumber, string], { chainID: BigNumber; latestLeafIndex: BigNumber; merkleRoot: string }>

    • Parameters

      • Optional chainID: null
      • Optional latestLeafIndex: null
      • Optional merkleRoot: null

      Returns TypedEventFilter<[BigNumber, BigNumber, string], { chainID: BigNumber; latestLeafIndex: BigNumber; merkleRoot: string }>

  • EdgeUpdate(uint256,uint256,bytes32):function
    • EdgeUpdate(uint256,uint256,bytes32)(chainID?: null, latestLeafIndex?: null, merkleRoot?: null): TypedEventFilter<[BigNumber, BigNumber, string], { chainID: BigNumber; latestLeafIndex: BigNumber; merkleRoot: string }>

    • Parameters

      • Optional chainID: null
      • Optional latestLeafIndex: null
      • Optional merkleRoot: null

      Returns TypedEventFilter<[BigNumber, BigNumber, string], { chainID: BigNumber; latestLeafIndex: BigNumber; merkleRoot: string }>

  • NewCommitment:function
    • NewCommitment(commitment?: null, index?: null, encryptedOutput?: null): TypedEventFilter<[string, BigNumber, string], { commitment: string; encryptedOutput: string; index: BigNumber }>

    • Parameters

      • Optional commitment: null
      • Optional index: null
      • Optional encryptedOutput: null

      Returns TypedEventFilter<[string, BigNumber, string], { commitment: string; encryptedOutput: string; index: BigNumber }>

  • NewCommitment(bytes32,uint256,bytes):function
    • NewCommitment(bytes32,uint256,bytes)(commitment?: null, index?: null, encryptedOutput?: null): TypedEventFilter<[string, BigNumber, string], { commitment: string; encryptedOutput: string; index: BigNumber }>

    • Parameters

      • Optional commitment: null
      • Optional index: null
      • Optional encryptedOutput: null

      Returns TypedEventFilter<[string, BigNumber, string], { commitment: string; encryptedOutput: string; index: BigNumber }>

  • NewNullifier:function
    • NewNullifier(nullifier?: null): TypedEventFilter<[string], { nullifier: string }>
  • NewNullifier(bytes32):function
    • NewNullifier(bytes32)(nullifier?: null): TypedEventFilter<[string], { nullifier: string }>
  • PublicKey:function
    • PublicKey(owner?: string, key?: null): TypedEventFilter<[string, string], { key: string; owner: string }>
  • PublicKey(address,bytes):function
    • PublicKey(address,bytes)(owner?: string, key?: null): TypedEventFilter<[string, string], { key: string; owner: string }>

functions

functions: { FIELD_SIZE: any; MAX_EXT_AMOUNT: any; MAX_FEE: any; ROOT_HISTORY_SIZE: any; ZERO_VALUE: any; calculatePublicAmount: any; configureLimits: any; currentNeighborRootIndex: any; currentRootIndex: any; edgeExistsForChain: any; edgeIndex: any; edgeList: any; filledSubtrees: any; getLastRoot: any; getLatestNeighborEdges: any; hasEdge: any; hashLeftRight: any; hasher: any; initialize: any; isKnownNeighborRoot: any; isKnownRoot: any; isSpent: any; isValidRoots: any; lastBalance: any; levels: any; maxEdges: any; maximumDepositAmount: any; minimalWithdrawalAmount: any; neighborRoots: any; nextIndex: any; nullifierHashes: any; permissions: any; register: any; registerAndTransact: any; roots: any; setHandler: any; setVerifier: any; transact: any; unpackProof: any; updateEdge: any; verifier: any; zeros: any }

Type declaration

  • FIELD_SIZE:function
    • FIELD_SIZE(overrides?: CallOverrides): Promise<[BigNumber]>
  • MAX_EXT_AMOUNT:function
    • MAX_EXT_AMOUNT(overrides?: CallOverrides): Promise<[BigNumber]>
  • MAX_FEE:function
    • MAX_FEE(overrides?: CallOverrides): Promise<[BigNumber]>
  • ROOT_HISTORY_SIZE:function
    • ROOT_HISTORY_SIZE(overrides?: CallOverrides): Promise<[number]>
  • ZERO_VALUE:function
    • ZERO_VALUE(overrides?: CallOverrides): Promise<[BigNumber]>
  • calculatePublicAmount:function
    • calculatePublicAmount(_extAmount: BigNumberish, _fee: BigNumberish, overrides?: CallOverrides): Promise<[BigNumber]>
  • configureLimits:function
    • configureLimits(_minimalWithdrawalAmount: BigNumberish, _maximumDepositAmount: BigNumberish, overrides?: Overrides & { from?: string | Promise<string> }): Promise<ContractTransaction>

    • Parameters

      • _minimalWithdrawalAmount: BigNumberish
      • _maximumDepositAmount: BigNumberish
      • Optional overrides: Overrides & { from?: string | Promise<string> }

      Returns Promise<ContractTransaction>

  • currentNeighborRootIndex:function
    • currentNeighborRootIndex(arg0: BigNumberish, overrides?: CallOverrides): Promise<[number]>
  • currentRootIndex:function
    • currentRootIndex(overrides?: CallOverrides): Promise<[number]>
  • edgeExistsForChain:function
    • edgeExistsForChain(arg0: BigNumberish, overrides?: CallOverrides): Promise<[boolean]>
  • edgeIndex:function
    • edgeIndex(arg0: BigNumberish, overrides?: CallOverrides): Promise<[BigNumber]>
  • edgeList:function
    • edgeList(arg0: BigNumberish, overrides?: CallOverrides): Promise<[BigNumber, string, BigNumber] & { chainID: BigNumber; latestLeafIndex: BigNumber; root: string }>
  • filledSubtrees:function
    • filledSubtrees(arg0: BigNumberish, overrides?: CallOverrides): Promise<[string]>
  • getLastRoot:function
    • getLastRoot(overrides?: CallOverrides): Promise<[string]>
  • getLatestNeighborEdges:function
    • getLatestNeighborEdges(overrides?: CallOverrides): Promise<[([BigNumber, string, BigNumber] & { chainID: BigNumber; latestLeafIndex: BigNumber; root: string })[]] & { edges: ([BigNumber, string, BigNumber] & { chainID: BigNumber; latestLeafIndex: BigNumber; root: string })[] }>

    • Parameters

      • Optional overrides: CallOverrides

      Returns Promise<[([BigNumber, string, BigNumber] & { chainID: BigNumber; latestLeafIndex: BigNumber; root: string })[]] & { edges: ([BigNumber, string, BigNumber] & { chainID: BigNumber; latestLeafIndex: BigNumber; root: string })[] }>

  • hasEdge:function
    • hasEdge(_chainID: BigNumberish, overrides?: CallOverrides): Promise<[boolean]>
  • hashLeftRight:function
    • hashLeftRight(_left: BytesLike, _right: BytesLike, overrides?: CallOverrides): Promise<[string]>
  • hasher:function
    • hasher(overrides?: CallOverrides): Promise<[string]>
  • initialize:function
    • initialize(_minimalWithdrawalAmount: BigNumberish, _maximumDepositAmount: BigNumberish, overrides?: Overrides & { from?: string | Promise<string> }): Promise<ContractTransaction>

    • Parameters

      • _minimalWithdrawalAmount: BigNumberish
      • _maximumDepositAmount: BigNumberish
      • Optional overrides: Overrides & { from?: string | Promise<string> }

      Returns Promise<ContractTransaction>

  • isKnownNeighborRoot:function
    • isKnownNeighborRoot(neighborChainID: BigNumberish, _root: BytesLike, overrides?: CallOverrides): Promise<[boolean]>
  • isKnownRoot:function
    • isKnownRoot(_root: BytesLike, overrides?: CallOverrides): Promise<[boolean]>
  • isSpent:function
    • isSpent(_nullifierHash: BytesLike, overrides?: CallOverrides): Promise<[boolean]>
  • isValidRoots:function
    • isValidRoots(roots: BytesLike[], overrides?: CallOverrides): Promise<[boolean]>
  • lastBalance:function
    • lastBalance(overrides?: CallOverrides): Promise<[BigNumber]>
  • levels:function
    • levels(overrides?: CallOverrides): Promise<[number]>
  • maxEdges:function
    • maxEdges(overrides?: CallOverrides): Promise<[number]>
  • maximumDepositAmount:function
    • maximumDepositAmount(overrides?: CallOverrides): Promise<[BigNumber]>
  • minimalWithdrawalAmount:function
    • minimalWithdrawalAmount(overrides?: CallOverrides): Promise<[BigNumber]>
  • neighborRoots:function
    • neighborRoots(arg0: BigNumberish, arg1: BigNumberish, overrides?: CallOverrides): Promise<[string]>
  • nextIndex:function
    • nextIndex(overrides?: CallOverrides): Promise<[number]>
  • nullifierHashes:function
    • nullifierHashes(arg0: BytesLike, overrides?: CallOverrides): Promise<[boolean]>
  • permissions:function
    • permissions(overrides?: CallOverrides): Promise<[string, string, string] & { admin: string; bridge: string; handler: string }>
  • register:function
    • register(_account: { owner: string; publicKey: BytesLike }, overrides?: Overrides & { from?: string | Promise<string> }): Promise<ContractTransaction>

    • Parameters

      • _account: { owner: string; publicKey: BytesLike }
        • owner: string
        • publicKey: BytesLike
      • Optional overrides: Overrides & { from?: string | Promise<string> }

      Returns Promise<ContractTransaction>

  • registerAndTransact:function
    • registerAndTransact(_account: { owner: string; publicKey: BytesLike }, _proofArgs: { extDataHash: BytesLike; inputNullifiers: BytesLike[]; outputCommitments: [BytesLike, BytesLike]; proof: BytesLike; publicAmount: BigNumberish; roots: BytesLike }, _extData: { encryptedOutput1: BytesLike; encryptedOutput2: BytesLike; extAmount: BigNumberish; fee: BigNumberish; recipient: string; relayer: string }, overrides?: Overrides & { from?: string | Promise<string> }): Promise<ContractTransaction>

    • Parameters

      • _account: { owner: string; publicKey: BytesLike }
        • owner: string
        • publicKey: BytesLike
      • _proofArgs: { extDataHash: BytesLike; inputNullifiers: BytesLike[]; outputCommitments: [BytesLike, BytesLike]; proof: BytesLike; publicAmount: BigNumberish; roots: BytesLike }
        • extDataHash: BytesLike
        • inputNullifiers: BytesLike[]
        • outputCommitments: [BytesLike, BytesLike]
        • proof: BytesLike
        • publicAmount: BigNumberish
        • roots: BytesLike
      • _extData: { encryptedOutput1: BytesLike; encryptedOutput2: BytesLike; extAmount: BigNumberish; fee: BigNumberish; recipient: string; relayer: string }
        • encryptedOutput1: BytesLike
        • encryptedOutput2: BytesLike
        • extAmount: BigNumberish
        • fee: BigNumberish
        • recipient: string
        • relayer: string
      • Optional overrides: Overrides & { from?: string | Promise<string> }

      Returns Promise<ContractTransaction>

  • roots:function
    • roots(arg0: BigNumberish, overrides?: CallOverrides): Promise<[string]>
  • setHandler:function
    • setHandler(_handler: string, nonce: BigNumberish, overrides?: Overrides & { from?: string | Promise<string> }): Promise<ContractTransaction>
  • setVerifier:function
    • setVerifier(newVerifier: string, overrides?: Overrides & { from?: string | Promise<string> }): Promise<ContractTransaction>
  • transact:function
    • transact(_args: { extDataHash: BytesLike; inputNullifiers: BytesLike[]; outputCommitments: [BytesLike, BytesLike]; proof: BytesLike; publicAmount: BigNumberish; roots: BytesLike }, _extData: { encryptedOutput1: BytesLike; encryptedOutput2: BytesLike; extAmount: BigNumberish; fee: BigNumberish; recipient: string; relayer: string }, overrides?: Overrides & { from?: string | Promise<string> }): Promise<ContractTransaction>

    • Parameters

      • _args: { extDataHash: BytesLike; inputNullifiers: BytesLike[]; outputCommitments: [BytesLike, BytesLike]; proof: BytesLike; publicAmount: BigNumberish; roots: BytesLike }
        • extDataHash: BytesLike
        • inputNullifiers: BytesLike[]
        • outputCommitments: [BytesLike, BytesLike]
        • proof: BytesLike
        • publicAmount: BigNumberish
        • roots: BytesLike
      • _extData: { encryptedOutput1: BytesLike; encryptedOutput2: BytesLike; extAmount: BigNumberish; fee: BigNumberish; recipient: string; relayer: string }
        • encryptedOutput1: BytesLike
        • encryptedOutput2: BytesLike
        • extAmount: BigNumberish
        • fee: BigNumberish
        • recipient: string
        • relayer: string
      • Optional overrides: Overrides & { from?: string | Promise<string> }

      Returns Promise<ContractTransaction>

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

    • Parameters

      • _proof: [BigNumberish, BigNumberish, BigNumberish, BigNumberish, BigNumberish, BigNumberish, BigNumberish, BigNumberish]
      • Optional overrides: CallOverrides

      Returns Promise<[[BigNumber, BigNumber], [[BigNumber, BigNumber], [BigNumber, BigNumber]], [BigNumber, BigNumber]]>

  • updateEdge:function
    • updateEdge(sourceChainID: BigNumberish, root: BytesLike, leafIndex: BigNumberish, overrides?: PayableOverrides & { from?: string | Promise<string> }): Promise<ContractTransaction>

    • Parameters

      • sourceChainID: BigNumberish
      • root: BytesLike
      • leafIndex: BigNumberish
      • Optional overrides: PayableOverrides & { from?: string | Promise<string> }

      Returns Promise<ContractTransaction>

  • verifier:function
    • verifier(overrides?: CallOverrides): Promise<[string]>
  • zeros:function
    • zeros(i: BigNumberish, overrides?: CallOverrides): Promise<[string]>

interface

interface: LinkableVAnchorInterface

populateTransaction

populateTransaction: { FIELD_SIZE: any; MAX_EXT_AMOUNT: any; MAX_FEE: any; ROOT_HISTORY_SIZE: any; ZERO_VALUE: any; calculatePublicAmount: any; configureLimits: any; currentNeighborRootIndex: any; currentRootIndex: any; edgeExistsForChain: any; edgeIndex: any; edgeList: any; filledSubtrees: any; getLastRoot: any; getLatestNeighborEdges: any; hasEdge: any; hashLeftRight: any; hasher: any; initialize: any; isKnownNeighborRoot: any; isKnownRoot: any; isSpent: any; isValidRoots: any; lastBalance: any; levels: any; maxEdges: any; maximumDepositAmount: any; minimalWithdrawalAmount: any; neighborRoots: any; nextIndex: any; nullifierHashes: any; permissions: any; register: any; registerAndTransact: any; roots: any; setHandler: any; setVerifier: any; transact: any; unpackProof: any; updateEdge: any; verifier: any; zeros: any }

Type declaration

  • FIELD_SIZE:function
    • FIELD_SIZE(overrides?: CallOverrides): Promise<PopulatedTransaction>
  • MAX_EXT_AMOUNT:function
    • MAX_EXT_AMOUNT(overrides?: CallOverrides): Promise<PopulatedTransaction>
  • MAX_FEE:function
    • MAX_FEE(overrides?: CallOverrides): Promise<PopulatedTransaction>
  • ROOT_HISTORY_SIZE:function
    • ROOT_HISTORY_SIZE(overrides?: CallOverrides): Promise<PopulatedTransaction>
  • ZERO_VALUE:function
    • ZERO_VALUE(overrides?: CallOverrides): Promise<PopulatedTransaction>
  • calculatePublicAmount:function
    • calculatePublicAmount(_extAmount: BigNumberish, _fee: BigNumberish, overrides?: CallOverrides): Promise<PopulatedTransaction>
  • configureLimits:function
    • configureLimits(_minimalWithdrawalAmount: BigNumberish, _maximumDepositAmount: BigNumberish, overrides?: Overrides & { from?: string | Promise<string> }): Promise<PopulatedTransaction>

    • Parameters

      • _minimalWithdrawalAmount: BigNumberish
      • _maximumDepositAmount: BigNumberish
      • Optional overrides: Overrides & { from?: string | Promise<string> }

      Returns Promise<PopulatedTransaction>

  • currentNeighborRootIndex:function
    • currentNeighborRootIndex(arg0: BigNumberish, overrides?: CallOverrides): Promise<PopulatedTransaction>
  • currentRootIndex:function
    • currentRootIndex(overrides?: CallOverrides): Promise<PopulatedTransaction>
  • edgeExistsForChain:function
    • edgeExistsForChain(arg0: BigNumberish, overrides?: CallOverrides): Promise<PopulatedTransaction>
  • edgeIndex:function
    • edgeIndex(arg0: BigNumberish, overrides?: CallOverrides): Promise<PopulatedTransaction>
  • edgeList:function
    • edgeList(arg0: BigNumberish, overrides?: CallOverrides): Promise<PopulatedTransaction>
  • filledSubtrees:function
    • filledSubtrees(arg0: BigNumberish, overrides?: CallOverrides): Promise<PopulatedTransaction>
  • getLastRoot:function
    • getLastRoot(overrides?: CallOverrides): Promise<PopulatedTransaction>
  • getLatestNeighborEdges:function
    • getLatestNeighborEdges(overrides?: CallOverrides): Promise<PopulatedTransaction>
  • hasEdge:function
    • hasEdge(_chainID: BigNumberish, overrides?: CallOverrides): Promise<PopulatedTransaction>
  • hashLeftRight:function
    • hashLeftRight(_left: BytesLike, _right: BytesLike, overrides?: CallOverrides): Promise<PopulatedTransaction>
  • hasher:function
    • hasher(overrides?: CallOverrides): Promise<PopulatedTransaction>
  • initialize:function
    • initialize(_minimalWithdrawalAmount: BigNumberish, _maximumDepositAmount: BigNumberish, overrides?: Overrides & { from?: string | Promise<string> }): Promise<PopulatedTransaction>

    • Parameters

      • _minimalWithdrawalAmount: BigNumberish
      • _maximumDepositAmount: BigNumberish
      • Optional overrides: Overrides & { from?: string | Promise<string> }

      Returns Promise<PopulatedTransaction>

  • isKnownNeighborRoot:function
    • isKnownNeighborRoot(neighborChainID: BigNumberish, _root: BytesLike, overrides?: CallOverrides): Promise<PopulatedTransaction>
  • isKnownRoot:function
    • isKnownRoot(_root: BytesLike, overrides?: CallOverrides): Promise<PopulatedTransaction>
  • isSpent:function
    • isSpent(_nullifierHash: BytesLike, overrides?: CallOverrides): Promise<PopulatedTransaction>
  • isValidRoots:function
    • isValidRoots(roots: BytesLike[], overrides?: CallOverrides): Promise<PopulatedTransaction>
  • lastBalance:function
    • lastBalance(overrides?: CallOverrides): Promise<PopulatedTransaction>
  • levels:function
    • levels(overrides?: CallOverrides): Promise<PopulatedTransaction>
  • maxEdges:function
    • maxEdges(overrides?: CallOverrides): Promise<PopulatedTransaction>
  • maximumDepositAmount:function
    • maximumDepositAmount(overrides?: CallOverrides): Promise<PopulatedTransaction>
  • minimalWithdrawalAmount:function
    • minimalWithdrawalAmount(overrides?: CallOverrides): Promise<PopulatedTransaction>
  • neighborRoots:function
    • neighborRoots(arg0: BigNumberish, arg1: BigNumberish, overrides?: CallOverrides): Promise<PopulatedTransaction>
  • nextIndex:function
    • nextIndex(overrides?: CallOverrides): Promise<PopulatedTransaction>
  • nullifierHashes:function
    • nullifierHashes(arg0: BytesLike, overrides?: CallOverrides): Promise<PopulatedTransaction>
  • permissions:function
    • permissions(overrides?: CallOverrides): Promise<PopulatedTransaction>
  • register:function
    • register(_account: { owner: string; publicKey: BytesLike }, overrides?: Overrides & { from?: string | Promise<string> }): Promise<PopulatedTransaction>

    • Parameters

      • _account: { owner: string; publicKey: BytesLike }
        • owner: string
        • publicKey: BytesLike
      • Optional overrides: Overrides & { from?: string | Promise<string> }

      Returns Promise<PopulatedTransaction>

  • registerAndTransact:function
    • registerAndTransact(_account: { owner: string; publicKey: BytesLike }, _proofArgs: { extDataHash: BytesLike; inputNullifiers: BytesLike[]; outputCommitments: [BytesLike, BytesLike]; proof: BytesLike; publicAmount: BigNumberish; roots: BytesLike }, _extData: { encryptedOutput1: BytesLike; encryptedOutput2: BytesLike; extAmount: BigNumberish; fee: BigNumberish; recipient: string; relayer: string }, overrides?: Overrides & { from?: string | Promise<string> }): Promise<PopulatedTransaction>

    • Parameters

      • _account: { owner: string; publicKey: BytesLike }
        • owner: string
        • publicKey: BytesLike
      • _proofArgs: { extDataHash: BytesLike; inputNullifiers: BytesLike[]; outputCommitments: [BytesLike, BytesLike]; proof: BytesLike; publicAmount: BigNumberish; roots: BytesLike }
        • extDataHash: BytesLike
        • inputNullifiers: BytesLike[]
        • outputCommitments: [BytesLike, BytesLike]
        • proof: BytesLike
        • publicAmount: BigNumberish
        • roots: BytesLike
      • _extData: { encryptedOutput1: BytesLike; encryptedOutput2: BytesLike; extAmount: BigNumberish; fee: BigNumberish; recipient: string; relayer: string }
        • encryptedOutput1: BytesLike
        • encryptedOutput2: BytesLike
        • extAmount: BigNumberish
        • fee: BigNumberish
        • recipient: string
        • relayer: string
      • Optional overrides: Overrides & { from?: string | Promise<string> }

      Returns Promise<PopulatedTransaction>

  • roots:function
    • roots(arg0: BigNumberish, overrides?: CallOverrides): Promise<PopulatedTransaction>
  • setHandler:function
    • setHandler(_handler: string, nonce: BigNumberish, overrides?: Overrides & { from?: string | Promise<string> }): Promise<PopulatedTransaction>
  • setVerifier:function
    • setVerifier(newVerifier: string, overrides?: Overrides & { from?: string | Promise<string> }): Promise<PopulatedTransaction>
  • transact:function
    • transact(_args: { extDataHash: BytesLike; inputNullifiers: BytesLike[]; outputCommitments: [BytesLike, BytesLike]; proof: BytesLike; publicAmount: BigNumberish; roots: BytesLike }, _extData: { encryptedOutput1: BytesLike; encryptedOutput2: BytesLike; extAmount: BigNumberish; fee: BigNumberish; recipient: string; relayer: string }, overrides?: Overrides & { from?: string | Promise<string> }): Promise<PopulatedTransaction>

    • Parameters

      • _args: { extDataHash: BytesLike; inputNullifiers: BytesLike[]; outputCommitments: [BytesLike, BytesLike]; proof: BytesLike; publicAmount: BigNumberish; roots: BytesLike }
        • extDataHash: BytesLike
        • inputNullifiers: BytesLike[]
        • outputCommitments: [BytesLike, BytesLike]
        • proof: BytesLike
        • publicAmount: BigNumberish
        • roots: BytesLike
      • _extData: { encryptedOutput1: BytesLike; encryptedOutput2: BytesLike; extAmount: BigNumberish; fee: BigNumberish; recipient: string; relayer: string }
        • encryptedOutput1: BytesLike
        • encryptedOutput2: BytesLike
        • extAmount: BigNumberish
        • fee: BigNumberish
        • recipient: string
        • relayer: string
      • Optional overrides: Overrides & { from?: string | Promise<string> }

      Returns Promise<PopulatedTransaction>

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

    • Parameters

      • _proof: [BigNumberish, BigNumberish, BigNumberish, BigNumberish, BigNumberish, BigNumberish, BigNumberish, BigNumberish]
      • Optional overrides: CallOverrides

      Returns Promise<PopulatedTransaction>

  • updateEdge:function
    • updateEdge(sourceChainID: BigNumberish, root: BytesLike, leafIndex: BigNumberish, overrides?: PayableOverrides & { from?: string | Promise<string> }): Promise<PopulatedTransaction>

    • Parameters

      • sourceChainID: BigNumberish
      • root: BytesLike
      • leafIndex: BigNumberish
      • Optional overrides: PayableOverrides & { from?: string | Promise<string> }

      Returns Promise<PopulatedTransaction>

  • verifier:function
    • verifier(overrides?: CallOverrides): Promise<PopulatedTransaction>
  • zeros:function
    • zeros(i: BigNumberish, overrides?: CallOverrides): Promise<PopulatedTransaction>

Readonly provider

provider: Provider

Readonly resolvedAddress

resolvedAddress: Promise<string>

Readonly signer

signer: Signer

Methods

FIELD_SIZE

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

MAX_EXT_AMOUNT

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

MAX_FEE

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

ROOT_HISTORY_SIZE

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

ZERO_VALUE

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

_checkRunningEvents

  • _checkRunningEvents(runningEvent: RunningEvent): void

  • Parameters

    • runningEvent: RunningEvent

    Returns void

_deployed

  • _deployed(blockTag?: BlockTag): Promise<Contract>

  • Parameters

    • Optional blockTag: BlockTag

    Returns Promise<Contract>

_wrapEvent

  • _wrapEvent(runningEvent: RunningEvent, log: Log, listener: Listener): Event

  • Parameters

    • runningEvent: RunningEvent
    • log: Log
    • listener: Listener

    Returns Event

attach

calculatePublicAmount

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

configureLimits

  • configureLimits(_minimalWithdrawalAmount: BigNumberish, _maximumDepositAmount: BigNumberish, overrides?: Overrides & { from?: string | Promise<string> }): Promise<ContractTransaction>

  • Parameters

    • _minimalWithdrawalAmount: BigNumberish
    • _maximumDepositAmount: BigNumberish
    • Optional overrides: Overrides & { from?: string | Promise<string> }

    Returns Promise<ContractTransaction>

connect

currentNeighborRootIndex

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

currentRootIndex

  • currentRootIndex(overrides?: CallOverrides): Promise<number>

deployed

edgeExistsForChain

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

edgeIndex

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

edgeList

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

emit

  • emit(eventName: string | EventFilter, ...args: any[]): boolean

  • Parameters

    • eventName: string | EventFilter
    • Rest ...args: any[]

    Returns boolean

fallback

  • fallback(overrides?: TransactionRequest): Promise<TransactionResponse>

  • Parameters

    • Optional overrides: TransactionRequest

    Returns Promise<TransactionResponse>

filledSubtrees

  • filledSubtrees(arg0: BigNumberish, overrides?: CallOverrides): Promise<string>

getLastRoot

  • getLastRoot(overrides?: CallOverrides): Promise<string>

getLatestNeighborEdges

  • getLatestNeighborEdges(overrides?: CallOverrides): Promise<([BigNumber, string, BigNumber] & { chainID: BigNumber; latestLeafIndex: BigNumber; root: string })[]>

hasEdge

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

hashLeftRight

  • hashLeftRight(_left: BytesLike, _right: BytesLike, overrides?: CallOverrides): Promise<string>

hasher

  • hasher(overrides?: CallOverrides): Promise<string>

initialize

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

  • Parameters

    • _minimalWithdrawalAmount: BigNumberish
    • _maximumDepositAmount: BigNumberish
    • Optional overrides: Overrides & { from?: string | Promise<string> }

    Returns Promise<ContractTransaction>

isKnownNeighborRoot

  • isKnownNeighborRoot(neighborChainID: BigNumberish, _root: BytesLike, overrides?: CallOverrides): Promise<boolean>

isKnownRoot

  • isKnownRoot(_root: BytesLike, overrides?: CallOverrides): Promise<boolean>

isSpent

  • isSpent(_nullifierHash: BytesLike, overrides?: CallOverrides): Promise<boolean>

isValidRoots

  • isValidRoots(roots: BytesLike[], overrides?: CallOverrides): Promise<boolean>

lastBalance

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

levels

  • levels(overrides?: CallOverrides): Promise<number>

listenerCount

  • listenerCount(eventName?: string | EventFilter): number

  • Parameters

    • Optional eventName: string | EventFilter

    Returns number

listeners

  • listeners<EventArgsArray, EventArgsObject>(eventFilter?: TypedEventFilter<EventArgsArray, EventArgsObject>): TypedListener<EventArgsArray, EventArgsObject>[]
  • listeners(eventName?: string): Listener[]

maxEdges

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

maximumDepositAmount

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

minimalWithdrawalAmount

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

neighborRoots

  • neighborRoots(arg0: BigNumberish, arg1: BigNumberish, overrides?: CallOverrides): Promise<string>

nextIndex

  • nextIndex(overrides?: CallOverrides): Promise<number>

nullifierHashes

  • nullifierHashes(arg0: BytesLike, overrides?: CallOverrides): Promise<boolean>

off

  • off<EventArgsArray, EventArgsObject>(eventFilter: TypedEventFilter<EventArgsArray, EventArgsObject>, listener: TypedListener<EventArgsArray, EventArgsObject>): LinkableVAnchor
  • off(eventName: string, listener: Listener): LinkableVAnchor

on

  • on<EventArgsArray, EventArgsObject>(eventFilter: TypedEventFilter<EventArgsArray, EventArgsObject>, listener: TypedListener<EventArgsArray, EventArgsObject>): LinkableVAnchor
  • on(eventName: string, listener: Listener): LinkableVAnchor

once

  • once<EventArgsArray, EventArgsObject>(eventFilter: TypedEventFilter<EventArgsArray, EventArgsObject>, listener: TypedListener<EventArgsArray, EventArgsObject>): LinkableVAnchor
  • once(eventName: string, listener: Listener): LinkableVAnchor

permissions

  • permissions(overrides?: CallOverrides): Promise<[string, string, string] & { admin: string; bridge: string; handler: string }>

queryFilter

  • queryFilter<EventArgsArray, EventArgsObject>(event: TypedEventFilter<EventArgsArray, EventArgsObject>, fromBlockOrBlockhash?: string | number, toBlock?: string | number): Promise<TypedEvent<EventArgsArray & EventArgsObject>[]>

  • Type parameters

    • EventArgsArray: any[]

    • EventArgsObject

    Parameters

    • event: TypedEventFilter<EventArgsArray, EventArgsObject>
    • Optional fromBlockOrBlockhash: string | number
    • Optional toBlock: string | number

    Returns Promise<TypedEvent<EventArgsArray & EventArgsObject>[]>

register

  • register(_account: { owner: string; publicKey: BytesLike }, overrides?: Overrides & { from?: string | Promise<string> }): Promise<ContractTransaction>

  • Parameters

    • _account: { owner: string; publicKey: BytesLike }
      • owner: string
      • publicKey: BytesLike
    • Optional overrides: Overrides & { from?: string | Promise<string> }

    Returns Promise<ContractTransaction>

registerAndTransact

  • registerAndTransact(_account: { owner: string; publicKey: BytesLike }, _proofArgs: { extDataHash: BytesLike; inputNullifiers: BytesLike[]; outputCommitments: [BytesLike, BytesLike]; proof: BytesLike; publicAmount: BigNumberish; roots: BytesLike }, _extData: { encryptedOutput1: BytesLike; encryptedOutput2: BytesLike; extAmount: BigNumberish; fee: BigNumberish; recipient: string; relayer: string }, overrides?: Overrides & { from?: string | Promise<string> }): Promise<ContractTransaction>

  • Parameters

    • _account: { owner: string; publicKey: BytesLike }
      • owner: string
      • publicKey: BytesLike
    • _proofArgs: { extDataHash: BytesLike; inputNullifiers: BytesLike[]; outputCommitments: [BytesLike, BytesLike]; proof: BytesLike; publicAmount: BigNumberish; roots: BytesLike }
      • extDataHash: BytesLike
      • inputNullifiers: BytesLike[]
      • outputCommitments: [BytesLike, BytesLike]
      • proof: BytesLike
      • publicAmount: BigNumberish
      • roots: BytesLike
    • _extData: { encryptedOutput1: BytesLike; encryptedOutput2: BytesLike; extAmount: BigNumberish; fee: BigNumberish; recipient: string; relayer: string }
      • encryptedOutput1: BytesLike
      • encryptedOutput2: BytesLike
      • extAmount: BigNumberish
      • fee: BigNumberish
      • recipient: string
      • relayer: string
    • Optional overrides: Overrides & { from?: string | Promise<string> }

    Returns Promise<ContractTransaction>

removeAllListeners

  • removeAllListeners<EventArgsArray, EventArgsObject>(eventFilter: TypedEventFilter<EventArgsArray, EventArgsObject>): LinkableVAnchor
  • removeAllListeners(eventName?: string): LinkableVAnchor

removeListener

  • removeListener<EventArgsArray, EventArgsObject>(eventFilter: TypedEventFilter<EventArgsArray, EventArgsObject>, listener: TypedListener<EventArgsArray, EventArgsObject>): LinkableVAnchor
  • removeListener(eventName: string, listener: Listener): LinkableVAnchor

roots

  • roots(arg0: BigNumberish, overrides?: CallOverrides): Promise<string>

setHandler

  • setHandler(_handler: string, nonce: BigNumberish, overrides?: Overrides & { from?: string | Promise<string> }): Promise<ContractTransaction>

setVerifier

  • setVerifier(newVerifier: string, overrides?: Overrides & { from?: string | Promise<string> }): Promise<ContractTransaction>

transact

  • transact(_args: { extDataHash: BytesLike; inputNullifiers: BytesLike[]; outputCommitments: [BytesLike, BytesLike]; proof: BytesLike; publicAmount: BigNumberish; roots: BytesLike }, _extData: { encryptedOutput1: BytesLike; encryptedOutput2: BytesLike; extAmount: BigNumberish; fee: BigNumberish; recipient: string; relayer: string }, overrides?: Overrides & { from?: string | Promise<string> }): Promise<ContractTransaction>

  • Parameters

    • _args: { extDataHash: BytesLike; inputNullifiers: BytesLike[]; outputCommitments: [BytesLike, BytesLike]; proof: BytesLike; publicAmount: BigNumberish; roots: BytesLike }
      • extDataHash: BytesLike
      • inputNullifiers: BytesLike[]
      • outputCommitments: [BytesLike, BytesLike]
      • proof: BytesLike
      • publicAmount: BigNumberish
      • roots: BytesLike
    • _extData: { encryptedOutput1: BytesLike; encryptedOutput2: BytesLike; extAmount: BigNumberish; fee: BigNumberish; recipient: string; relayer: string }
      • encryptedOutput1: BytesLike
      • encryptedOutput2: BytesLike
      • extAmount: BigNumberish
      • fee: BigNumberish
      • recipient: string
      • relayer: string
    • Optional overrides: Overrides & { from?: string | Promise<string> }

    Returns Promise<ContractTransaction>

unpackProof

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

  • Parameters

    • _proof: [BigNumberish, BigNumberish, BigNumberish, BigNumberish, BigNumberish, BigNumberish, BigNumberish, BigNumberish]
    • Optional overrides: CallOverrides

    Returns Promise<[[BigNumber, BigNumber], [[BigNumber, BigNumber], [BigNumber, BigNumber]], [BigNumber, BigNumber]]>

updateEdge

  • updateEdge(sourceChainID: BigNumberish, root: BytesLike, leafIndex: BigNumberish, overrides?: PayableOverrides & { from?: string | Promise<string> }): Promise<ContractTransaction>

  • Parameters

    • sourceChainID: BigNumberish
    • root: BytesLike
    • leafIndex: BigNumberish
    • Optional overrides: PayableOverrides & { from?: string | Promise<string> }

    Returns Promise<ContractTransaction>

verifier

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

zeros

  • zeros(i: BigNumberish, overrides?: CallOverrides): Promise<string>

Static getContractAddress

  • getContractAddress(transaction: { from: string; nonce: BigNumberish }): string

  • Parameters

    • transaction: { from: string; nonce: BigNumberish }
      • from: string
      • nonce: BigNumberish

    Returns string

Static getInterface

  • getInterface(contractInterface: ContractInterface): Interface

  • Parameters

    • contractInterface: ContractInterface

    Returns Interface

Static isIndexed

  • isIndexed(value: any): value is Indexed

  • Parameters

    • value: any

    Returns value is Indexed

Generated using TypeDoc