Class Rpc

constructor

• new Rpc(
      endpoint: string,
      compressionApiEndpoint: string,
      proverEndpoint: string,
      config?: ConnectionConfig,
  ): Rpc

  Parameters

  • endpoint: string
  • compressionApiEndpoint: string
  • proverEndpoint: string
  • Optionalconfig: ConnectionConfig

  Returns Rpc

compressionApiEndpoint

proverEndpoint

allStateTreeInfos

lastStateTreeFetchTime

CACHE_TTL

fetchPromise

getCachedActiveStateTreeInfo

• getCachedActiveStateTreeInfo(): Promise<void>

  Returns Promise<void>

  Deprecated

  Use getStateTreeInfos instead

getCachedActiveStateTreeInfos

• getCachedActiveStateTreeInfos(): Promise<void>

  Returns Promise<void>

  Deprecated

  Use getStateTreeInfos instead

getStateTreeInfos

• getStateTreeInfos(): Promise<TreeInfo[]>

  Get a list of all state tree infos. If not already cached, fetches from the cluster.

  Returns Promise<TreeInfo[]>

getAddressTreeInfoV2

• getAddressTreeInfoV2(): Promise<TreeInfo>

  Get a V2 address tree info.

  Returns Promise<TreeInfo>

getCompressedAccount

• getCompressedAccount(
      address?: BN,
      hash?: BN,
  ): Promise<CompressedAccountWithMerkleContext | null>

  Fetch the compressed account for the specified account address or hash

  Parameters

  • Optionaladdress: BN
  • Optionalhash: BN

  Returns Promise<CompressedAccountWithMerkleContext | null>

getCompressedBalance

• getCompressedBalance(address?: BN, hash?: BN): Promise<BN>

  Fetch the compressed balance for the specified account address or hash

  Parameters

  • Optionaladdress: BN
  • Optionalhash: BN

  Returns Promise<BN>

getCompressedBalanceByOwner

• getCompressedBalanceByOwner(owner: PublicKey): Promise<BN>

  Fetch the total compressed balance for the specified owner public key

  Parameters

  • owner: PublicKey

  Returns Promise<BN>

getCompressedAccountProof

• getCompressedAccountProof(hash: BN): Promise<MerkleContextWithMerkleProof>

  Fetch the latest merkle proof for the specified account hash from the cluster

  Parameters

  • hash: BN

  Returns Promise<MerkleContextWithMerkleProof>

getMultipleCompressedAccounts

• getMultipleCompressedAccounts(
      hashes: BN[],
  ): Promise<CompressedAccountWithMerkleContext[]>

  Fetch all the account info for multiple compressed accounts specified by an array of account hashes

  Parameters

  • hashes: BN[]

  Returns Promise<CompressedAccountWithMerkleContext[]>

getMultipleCompressedAccountProofs

• getMultipleCompressedAccountProofs(
      hashes: BN[],
  ): Promise<MerkleContextWithMerkleProof[]>

  Fetch the latest merkle proofs for multiple compressed accounts specified by an array account hashes

  Parameters

  • hashes: BN[]

  Returns Promise<MerkleContextWithMerkleProof[]>

getCompressedAccountsByOwner

• getCompressedAccountsByOwner(
      owner: PublicKey,
      config?: GetCompressedAccountsByOwnerConfig,
  ): Promise<WithCursor<CompressedAccountWithMerkleContext[]>>

  Fetch all the compressed accounts owned by the specified public key. Owner can be a program or user account

  Parameters

  • owner: PublicKey
  • Optionalconfig: GetCompressedAccountsByOwnerConfig

  Returns Promise<WithCursor<CompressedAccountWithMerkleContext[]>>

getCompressedTokenAccountsByOwner

• getCompressedTokenAccountsByOwner(
      owner: PublicKey,
      options?: GetCompressedTokenAccountsByOwnerOrDelegateOptions,
  ): Promise<WithCursor<ParsedTokenAccount[]>>

  Fetch all the compressed token accounts owned by the specified public key. Owner can be a program or user account

  Parameters

  • owner: PublicKey
  • Optionaloptions: GetCompressedTokenAccountsByOwnerOrDelegateOptions

  Returns Promise<WithCursor<ParsedTokenAccount[]>>

getCompressedTokenAccountsByDelegate

• getCompressedTokenAccountsByDelegate(
      delegate: PublicKey,
      options?: GetCompressedTokenAccountsByOwnerOrDelegateOptions,
  ): Promise<WithCursor<ParsedTokenAccount[]>>

  Fetch all the compressed accounts delegated to the specified public key.

  Parameters

  • delegate: PublicKey
  • Optionaloptions: GetCompressedTokenAccountsByOwnerOrDelegateOptions

  Returns Promise<WithCursor<ParsedTokenAccount[]>>

getCompressedTokenAccountBalance

• getCompressedTokenAccountBalance(hash: BN): Promise<{ amount: BN }>

  Fetch the compressed token balance for the specified account hash

  Parameters

  • hash: BN

  Returns Promise<{ amount: BN }>

getCompressedTokenBalancesByOwner

• getCompressedTokenBalancesByOwner(
      owner: PublicKey,
      options?: GetCompressedTokenAccountsByOwnerOrDelegateOptions,
  ): Promise<WithCursor<TokenBalance[]>>

  Parameters

  • owner: PublicKey
  • Optionaloptions: GetCompressedTokenAccountsByOwnerOrDelegateOptions

  Returns Promise<WithCursor<TokenBalance[]>>

  Deprecated

  use getCompressedTokenBalancesByOwnerV2 instead.

  Fetch all the compressed token balances owned by the specified public key. Can filter by mint. Returns without context.

getCompressedTokenBalancesByOwnerV2

• getCompressedTokenBalancesByOwnerV2(
      owner: PublicKey,
      options?: GetCompressedTokenAccountsByOwnerOrDelegateOptions,
  ): Promise<WithContext<WithCursor<TokenBalance[]>>>

  Fetch the compressed token balances owned by the specified public key. Paginated. Can filter by mint. Returns with context.

  Parameters

  • owner: PublicKey
  • Optionaloptions: GetCompressedTokenAccountsByOwnerOrDelegateOptions

  Returns Promise<WithContext<WithCursor<TokenBalance[]>>>

getCompressionSignaturesForAccount

• getCompressionSignaturesForAccount(hash: BN): Promise<SignatureWithMetadata[]>

  Returns confirmed compression signatures for transactions involving the specified account hash forward in time from genesis to the most recent confirmed block

  Parameters

  • hash: BN

    queried account hash

  Returns Promise<SignatureWithMetadata[]>

getTransactionWithCompressionInfo

• getTransactionWithCompressionInfo(
      signature: string,
  ): Promise<CompressedTransaction | null>

  Fetch a confirmed or finalized transaction from the cluster. Return with CompressionInfo

  Parameters

  • signature: string

  Returns Promise<CompressedTransaction | null>

getCompressionSignaturesForAddress

• getCompressionSignaturesForAddress(
      address: PublicKey,
      options?: PaginatedOptions,
  ): Promise<WithCursor<SignatureWithMetadata[]>>

  Returns confirmed signatures for transactions involving the specified address forward in time from genesis to the most recent confirmed block

  Parameters

  • address: PublicKey

    queried compressed account address

  • Optionaloptions: PaginatedOptions

  Returns Promise<WithCursor<SignatureWithMetadata[]>>

getCompressionSignaturesForOwner

• getCompressionSignaturesForOwner(
      owner: PublicKey,
      options?: PaginatedOptions,
  ): Promise<WithCursor<SignatureWithMetadata[]>>

  Returns confirmed signatures for compression transactions involving the specified account owner forward in time from genesis to the most recent confirmed block

  Parameters

  • owner: PublicKey

    queried owner public key

  • Optionaloptions: PaginatedOptions

  Returns Promise<WithCursor<SignatureWithMetadata[]>>

getCompressionSignaturesForTokenOwner

• getCompressionSignaturesForTokenOwner(
      owner: PublicKey,
      options?: PaginatedOptions,
  ): Promise<WithCursor<SignatureWithMetadata[]>>

  Returns confirmed signatures for compression transactions involving the specified token account owner forward in time from genesis to the most recent confirmed block

  Parameters

  • owner: PublicKey
  • Optionaloptions: PaginatedOptions

  Returns Promise<WithCursor<SignatureWithMetadata[]>>

getIndexerHealth

• getIndexerHealth(): Promise<string>

  Fetch the current indexer health status

  Returns Promise<string>

confirmTransactionIndexed

• confirmTransactionIndexed(slot: number): Promise<boolean>

  Ensure that the Compression Indexer has already indexed the transaction

  Parameters

  • slot: number

  Returns Promise<boolean>

getIndexerSlot

• getIndexerSlot(): Promise<number>

  Fetch the current slot that the node is processing

  Returns Promise<number>

getCompressedMintTokenHolders

• getCompressedMintTokenHolders(
      mint: PublicKey,
      options?: PaginatedOptions,
  ): Promise<WithContext<WithCursor<CompressedMintTokenHolders[]>>>

  Fetch all the compressed token holders for a given mint. Paginated.

  Parameters

  • mint: PublicKey
  • Optionaloptions: PaginatedOptions

  Returns Promise<WithContext<WithCursor<CompressedMintTokenHolders[]>>>

getLatestCompressionSignatures

• getLatestCompressionSignatures(
      cursor?: string,
      limit?: number,
  ): Promise<LatestNonVotingSignaturesPaginated>

  Fetch the latest compression signatures on the cluster. Results are paginated.

  Parameters

  • Optionalcursor: string
  • Optionallimit: number

  Returns Promise<LatestNonVotingSignaturesPaginated>

getLatestNonVotingSignatures

• getLatestNonVotingSignatures(
      limit?: number,
      cursor?: string,
  ): Promise<LatestNonVotingSignatures>

  Fetch all non-voting signatures

  Parameters

  • Optionallimit: number
  • Optionalcursor: string

  Returns Promise<LatestNonVotingSignatures>

getMultipleNewAddressProofs

• getMultipleNewAddressProofs(
      addresses: BN[],
  ): Promise<MerkleContextWithNewAddressProof[]>

  Fetch the latest address proofs for new unique addresses specified by an array of addresses.

  the proof states that said address have not yet been created in respective address tree.

  Parameters

  • addresses: BN[]

    Array of BN254 new addresses

  Returns Promise<MerkleContextWithNewAddressProof[]>

  Array of validity proofs for new addresses

getValidityProof

• getValidityProof(
      hashes?: BN[],
      newAddresses?: BN[],
  ): Promise<ValidityProofWithContext>

  Parameters

  • hashes: BN[] = []

    Array of BN254 hashes.

  • newAddresses: BN[] = []

    Array of BN254 new addresses.

  Returns Promise<ValidityProofWithContext>

  validity proof with context

  Deprecated

  use getValidityProofV0 instead.

  Fetch the latest validity proof for (1) compressed accounts specified by an array of account hashes. (2) new unique addresses specified by an array of addresses.

  Validity proofs prove the presence of compressed accounts in state trees and the non-existence of addresses in address trees, respectively. They enable verification without recomputing the merkle proof path, thus lowering verification and data costs.

getValidityProofV0

• getValidityProofV0(
      hashes?: HashWithTree[],
      newAddresses?: AddressWithTree[],
  ): Promise<ValidityProofWithContext>

  Fetch the latest validity proof for (1) compressed accounts specified by an array of account hashes. (2) new unique addresses specified by an array of addresses.

  Validity proofs prove the presence of compressed accounts in state trees and the non-existence of addresses in address trees, respectively. They enable verification without recomputing the merkle proof path, thus lowering verification and data costs.

  Parameters

  • hashes: HashWithTree[] = []

    Array of { hash: BN254, tree: PublicKey, queue: PublicKey }.

  • newAddresses: AddressWithTree[] = []

    Array of { address: BN254, tree: PublicKey, queue: PublicKey }.

  Returns Promise<ValidityProofWithContext>

  validity proof with context

getValidityProofAndRpcContext

• getValidityProofAndRpcContext(
      hashes?: HashWithTree[],
      newAddresses?: AddressWithTree[],
  ): Promise<WithContext<ValidityProofWithContext>>

  Fetch the latest validity proof for (1) compressed accounts specified by an array of account hashes. (2) new unique addresses specified by an array of addresses. Returns with context slot.

  Validity proofs prove the presence of compressed accounts in state trees and the non-existence of addresses in address trees, respectively. They enable verification without recomputing the merkle proof path, thus lowering verification and data costs.

  Parameters

  • hashes: HashWithTree[] = []

    Array of BN254 hashes.

  • newAddresses: AddressWithTree[] = []

    Array of BN254 new addresses. Optionally specify the tree and queue for each address. Default to public state tree/queue.

  Returns Promise<WithContext<ValidityProofWithContext>>

  validity proof with context