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. if featureFlags.isV2(), returns v2 trees too.

  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

getValidityProofV2

• getValidityProofV2(
      accountMerkleContexts?: (MerkleContext | undefined)[],
      newAddresses?: AddressWithTreeInfoV2[],
      derivationMode?: DerivationMode,
  ): Promise<ValidityProofWithContext>

  Fetch the latest validity proof for (1) compressed accounts specified by an array of account Merkle contexts, and (2) new unique addresses specified by an array of address objects with tree info.

  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

  • accountMerkleContexts: (MerkleContext | undefined)[] = []
  • newAddresses: AddressWithTreeInfoV2[] = []
  • OptionalderivationMode: DerivationMode

  Returns Promise<ValidityProofWithContext>

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

getAccountInfoInterface

• getAccountInfoInterface(
      address: PublicKey,
      programId: PublicKey,
      commitmentOrConfig?: Commitment | GetAccountInfoConfig,
      addressSpace?: TreeInfo,
  ): Promise<
      | {
          accountInfo: AccountInfo<Buffer<ArrayBufferLike>>;
          isCold: boolean;
          loadContext?: MerkleContext;
      }
      | null,
  >

  Fetch the account info for the specified public key. Returns metadata to load in case the account is cold.

  Parameters

  • address: PublicKey

    The account address to fetch.

  • programId: PublicKey

    The owner program ID.

  • OptionalcommitmentOrConfig: Commitment | GetAccountInfoConfig

    Optional. The commitment or config to use for the onchain account fetch.

  • OptionaladdressSpace: TreeInfo

    Optional. The address space info that was used at init.

  Returns Promise<
      | {
          accountInfo: AccountInfo<Buffer<ArrayBufferLike>>;
          isCold: boolean;
          loadContext?: MerkleContext;
      }
      | null,
  >

  Account info with load info, or null if account doesn't exist. LoadContext is always some if the account is compressible. isCold indicates the current state of the account, if true the account must referenced in a load instruction before use.

getSignaturesForAddressInterface

• getSignaturesForAddressInterface(
      address: PublicKey,
      options?: SignaturesForAddressOptions,
      compressedOptions?: PaginatedOptions,
  ): Promise<SignaturesForAddressInterfaceResult>

  Get signatures for an address from both Solana and compression indexer.

  Parameters

  • address: PublicKey

    Address to fetch signatures for.

  • Optionaloptions: SignaturesForAddressOptions

    Options for the Solana getSignaturesForAddress call.

  • OptionalcompressedOptions: PaginatedOptions

    Options for the compression getCompressionSignaturesForAddress call.

  Returns Promise<SignaturesForAddressInterfaceResult>

  Unified signatures from both sources.

getSignaturesForOwnerInterface

• getSignaturesForOwnerInterface(
      owner: PublicKey,
      options?: SignaturesForAddressOptions,
      compressedOptions?: PaginatedOptions,
  ): Promise<SignaturesForAddressInterfaceResult>

  Get signatures for an owner from both Solana and compression indexer.

  Parameters

  • owner: PublicKey

    Owner address to fetch signatures for.

  • Optionaloptions: SignaturesForAddressOptions

    Options for the Solana getSignaturesForAddress call.

  • OptionalcompressedOptions: PaginatedOptions

    Options for the compression getCompressionSignaturesForOwner call.

  Returns Promise<SignaturesForAddressInterfaceResult>

  Unified signatures from both sources.

getTokenAccountBalanceInterface

• getTokenAccountBalanceInterface(
      address: PublicKey,
      owner: PublicKey,
      mint: PublicKey,
      commitment?: Commitment,
  ): Promise<UnifiedTokenBalance>

  Get token account balance for an address, regardless of whether the token account is hot or cold.

  Parameters

  • address: PublicKey

    Token account address.

  • owner: PublicKey

    Owner public key.

  • mint: PublicKey

    Mint public key.

  • Optionalcommitment: Commitment

    Commitment level for on-chain query.

  Returns Promise<UnifiedTokenBalance>

  Unified token balance from both sources.

getBalanceInterface

• getBalanceInterface(
      address: PublicKey,
      commitment?: Commitment,
  ): Promise<UnifiedBalance>

  Get SOL balance for an address, regardless of whether the account is hot or cold.

  Parameters

  • address: PublicKey

    Address to fetch balance for.

  • Optionalcommitment: Commitment

    Commitment level for on-chain query.

  Returns Promise<UnifiedBalance>

  Unified SOL balance.