Class Connection

constructor

• new Connection(
      endpoint: string,
      commitmentOrConfig?: Commitment | ConnectionConfig,
  ): Connection

• Establish a JSON RPC connection

  Parameters

  • endpoint: string

    URL to the fullnode JSON RPC endpoint
  • OptionalcommitmentOrConfig: Commitment | ConnectionConfig

    optional default commitment level or optional ConnectionConfig configuration object

  Returns Connection

getBlockHeight

commitment

• get commitment(): undefined | Commitment

• The default commitment used for requests

  Returns undefined | Commitment

rpcEndpoint

• get rpcEndpoint(): string

• The RPC endpoint

  Returns string

_buildArgs

• _buildArgs(
      args: any[],
      override?: Commitment,
      encoding?: "base64" | "jsonParsed",
      extra?: any,
  ): any[]

• Parameters

  • args: any[]
  • Optionaloverride: Commitment
  • Optionalencoding: "base64" | "jsonParsed"
  • Optionalextra: any

  Returns any[]

confirmTransaction

• confirmTransaction(
      strategy: TransactionConfirmationStrategy,
      commitment?: Commitment,
  ): Promise<RpcResponseAndContext<SignatureResult>>

• Parameters

  • strategy: TransactionConfirmationStrategy
  • Optionalcommitment: Commitment

  Returns Promise<RpcResponseAndContext<SignatureResult>>

• confirmTransaction(
      strategy: string,
      commitment?: Commitment,
  ): Promise<RpcResponseAndContext<SignatureResult>>

• Parameters

  • strategy: string
  • Optionalcommitment: Commitment

  Returns Promise<RpcResponseAndContext<SignatureResult>>

  Deprecated

  Instead, call confirmTransaction and pass in TransactionConfirmationStrategy

getAccountInfo

• getAccountInfo(
      publicKey: PublicKey,
      commitmentOrConfig?: Commitment | GetAccountInfoConfig,
  ): Promise<null | AccountInfo<Buffer>>

• Fetch all the account info for the specified public key

  Parameters

  • publicKey: PublicKey
  • OptionalcommitmentOrConfig: Commitment | GetAccountInfoConfig

  Returns Promise<null | AccountInfo<Buffer>>

getAccountInfoAndContext

• getAccountInfoAndContext(
      publicKey: PublicKey,
      commitmentOrConfig?: Commitment | GetAccountInfoConfig,
  ): Promise<RpcResponseAndContext<null | AccountInfo<Buffer>>>

• Fetch all the account info for the specified public key, return with context

  Parameters

  • publicKey: PublicKey
  • OptionalcommitmentOrConfig: Commitment | GetAccountInfoConfig

  Returns Promise<RpcResponseAndContext<null | AccountInfo<Buffer>>>

getAddressLookupTable

• getAddressLookupTable(
      accountKey: PublicKey,
      config?: GetAccountInfoConfig,
  ): Promise<RpcResponseAndContext<null | AddressLookupTableAccount>>

• Parameters

  • accountKey: PublicKey
  • Optionalconfig: GetAccountInfoConfig

  Returns Promise<RpcResponseAndContext<null | AddressLookupTableAccount>>

getBalance

• getBalance(
      publicKey: PublicKey,
      commitmentOrConfig?: Commitment | GetBalanceConfig,
  ): Promise<number>

• Fetch the balance for the specified public key

  Parameters

  • publicKey: PublicKey
  • OptionalcommitmentOrConfig: Commitment | GetBalanceConfig

  Returns Promise<number>

getBalanceAndContext

• getBalanceAndContext(
      publicKey: PublicKey,
      commitmentOrConfig?: Commitment | GetBalanceConfig,
  ): Promise<RpcResponseAndContext<number>>

• Fetch the balance for the specified public key, return with context

  Parameters

  • publicKey: PublicKey
  • OptionalcommitmentOrConfig: Commitment | GetBalanceConfig

  Returns Promise<RpcResponseAndContext<number>>

getBlock

• getBlock(
      slot: number,
      rawConfig?: GetBlockConfig,
  ): Promise<null | BlockResponse>

• Fetch a processed block from the cluster.

  Parameters

  • slot: number
  • OptionalrawConfig: GetBlockConfig

  Returns Promise<null | BlockResponse>

  Deprecated

  Instead, call getBlock using a GetVersionedBlockConfig by setting the maxSupportedTransactionVersion property.

• getBlock(
      slot: number,
      rawConfig: GetBlockConfig & { transactionDetails: "accounts" },
  ): Promise<null | VersionedAccountsModeBlockResponse>

• Parameters

  • slot: number
  • rawConfig: GetBlockConfig & { transactionDetails: "accounts" }

  Returns Promise<null | VersionedAccountsModeBlockResponse>

  Deprecated

  Instead, call getBlock using a GetVersionedBlockConfig by setting the maxSupportedTransactionVersion property.

• getBlock(
      slot: number,
      rawConfig: GetBlockConfig & { transactionDetails: "none" },
  ): Promise<null | VersionedNoneModeBlockResponse>

• Parameters

  • slot: number
  • rawConfig: GetBlockConfig & { transactionDetails: "none" }

  Returns Promise<null | VersionedNoneModeBlockResponse>

  Deprecated

  Instead, call getBlock using a GetVersionedBlockConfig by setting the maxSupportedTransactionVersion property.

• getBlock(
      slot: number,
      rawConfig?: GetVersionedBlockConfig,
  ): Promise<null | VersionedBlockResponse>

• Fetch a processed block from the cluster.

  Parameters

  • slot: number
  • OptionalrawConfig: GetVersionedBlockConfig

  Returns Promise<null | VersionedBlockResponse>
• getBlock(
      slot: number,
      rawConfig: GetVersionedBlockConfig & { transactionDetails: "accounts" },
  ): Promise<null | VersionedAccountsModeBlockResponse>

• Fetch a processed block from the cluster.

  Parameters

  • slot: number
  • rawConfig: GetVersionedBlockConfig & { transactionDetails: "accounts" }

  Returns Promise<null | VersionedAccountsModeBlockResponse>

  Deprecated

  Instead, call getBlock using a GetVersionedBlockConfig by setting the maxSupportedTransactionVersion property.

• getBlock(
      slot: number,
      rawConfig: GetVersionedBlockConfig & { transactionDetails: "none" },
  ): Promise<null | VersionedNoneModeBlockResponse>

• Fetch a processed block from the cluster.

  Parameters

  • slot: number
  • rawConfig: GetVersionedBlockConfig & { transactionDetails: "none" }

  Returns Promise<null | VersionedNoneModeBlockResponse>

  Deprecated

  Instead, call getBlock using a GetVersionedBlockConfig by setting the maxSupportedTransactionVersion property.

getBlockProduction

• getBlockProduction(
      configOrCommitment?: Commitment | GetBlockProductionConfig,
  ): Promise<
      RpcResponseAndContext<
          Readonly<
              {
                  byIdentity: Readonly<Record<string, readonly number[]>>;
                  range: Readonly<{ firstSlot: number; lastSlot: number }>;
              },
          >,
      >,
  >

• Parameters

  • OptionalconfigOrCommitment: Commitment | GetBlockProductionConfig

  Returns Promise<
      RpcResponseAndContext<
          Readonly<
              {
                  byIdentity: Readonly<Record<string, readonly number[]>>;
                  range: Readonly<{ firstSlot: number; lastSlot: number }>;
              },
          >,
      >,
  >

getBlocks

• getBlocks(
      startSlot: number,
      endSlot?: number,
      commitment?: Finality,
  ): Promise<number[]>

• Fetch confirmed blocks between two slots

  Parameters

  • startSlot: number
  • OptionalendSlot: number
  • Optionalcommitment: Finality

  Returns Promise<number[]>

getBlockSignatures

• getBlockSignatures(
      slot: number,
      commitment?: Finality,
  ): Promise<BlockSignatures>

• Fetch a list of Signatures from the cluster for a block, excluding rewards

  Parameters

  • slot: number
  • Optionalcommitment: Finality

  Returns Promise<BlockSignatures>

getBlockTime

• getBlockTime(slot: number): Promise<null | number>

• Fetch the estimated production time of a block

  Parameters

  • slot: number

  Returns Promise<null | number>

getClusterNodes

• getClusterNodes(): Promise<ContactInfo[]>

• Return the list of nodes that are currently participating in the cluster

  Returns Promise<ContactInfo[]>

getConfirmedBlock

• getConfirmedBlock(slot: number, commitment?: Finality): Promise<ConfirmedBlock>

• Fetch a list of Transactions and transaction statuses from the cluster for a confirmed block.

  Parameters

  • slot: number
  • Optionalcommitment: Finality

  Returns Promise<ConfirmedBlock>

  Deprecated

  Deprecated since RPC v1.7.0. Please use getBlock instead.

getConfirmedBlockSignatures

• getConfirmedBlockSignatures(
      slot: number,
      commitment?: Finality,
  ): Promise<BlockSignatures>

• Fetch a list of Signatures from the cluster for a confirmed block, excluding rewards

  Parameters

  • slot: number
  • Optionalcommitment: Finality

  Returns Promise<BlockSignatures>

  Deprecated

  Deprecated since RPC v1.7.0. Please use getBlockSignatures instead.

getConfirmedSignaturesForAddress

• getConfirmedSignaturesForAddress(
      address: PublicKey,
      startSlot: number,
      endSlot: number,
  ): Promise<string[]>

• Fetch a list of all the confirmed signatures for transactions involving an address within a specified slot range. Max range allowed is 10,000 slots.

  Parameters

  • address: PublicKey

    queried address
  • startSlot: number

    start slot, inclusive
  • endSlot: number

    end slot, inclusive

  Returns Promise<string[]>

  Deprecated

  Deprecated since RPC v1.3. Please use getConfirmedSignaturesForAddress2 instead.

getConfirmedSignaturesForAddress2

• getConfirmedSignaturesForAddress2(
      address: PublicKey,
      options?: ConfirmedSignaturesForAddress2Options,
      commitment?: Finality,
  ): Promise<ConfirmedSignatureInfo[]>

• Returns confirmed signatures for transactions involving an address backwards in time from the provided signature or most recent confirmed block

  Parameters

  • address: PublicKey
  • Optionaloptions: ConfirmedSignaturesForAddress2Options
  • Optionalcommitment: Finality

  Returns Promise<ConfirmedSignatureInfo[]>

  Deprecated

  Deprecated since RPC v1.7.0. Please use getSignaturesForAddress instead.

getConfirmedTransaction

• getConfirmedTransaction(
      signature: string,
      commitment?: Finality,
  ): Promise<null | ConfirmedTransaction>

• Fetch a transaction details for a confirmed transaction

  Parameters

  • signature: string
  • Optionalcommitment: Finality

  Returns Promise<null | ConfirmedTransaction>

  Deprecated

  Deprecated since RPC v1.7.0. Please use getTransaction instead.

getEpochInfo

• getEpochInfo(
      commitmentOrConfig?: Commitment | GetEpochInfoConfig,
  ): Promise<EpochInfo>

• Fetch the Epoch Info parameters

  Parameters

  • OptionalcommitmentOrConfig: Commitment | GetEpochInfoConfig

  Returns Promise<EpochInfo>

getEpochSchedule

• getEpochSchedule(): Promise<EpochSchedule>

• Fetch the Epoch Schedule parameters

  Returns Promise<EpochSchedule>

getFeeCalculatorForBlockhash

• getFeeCalculatorForBlockhash(
      blockhash: string,
      commitment?: Commitment,
  ): Promise<RpcResponseAndContext<null | FeeCalculator>>

• Fetch the fee calculator for a recent blockhash from the cluster, return with context

  Parameters

  • blockhash: string
  • Optionalcommitment: Commitment

  Returns Promise<RpcResponseAndContext<null | FeeCalculator>>

  Deprecated

  Deprecated since RPC v1.9.0. Please use getFeeForMessage instead.

getFeeForMessage

• getFeeForMessage(
      message: VersionedMessage,
      commitment?: Commitment,
  ): Promise<RpcResponseAndContext<null | number>>

• Fetch the fee for a message from the cluster, return with context

  Parameters

  • message: VersionedMessage
  • Optionalcommitment: Commitment

  Returns Promise<RpcResponseAndContext<null | number>>

getFirstAvailableBlock

• getFirstAvailableBlock(): Promise<number>

• Fetch the slot of the lowest confirmed block that has not been purged from the ledger

  Returns Promise<number>

getGenesisHash

• getGenesisHash(): Promise<string>

• Fetch the genesis hash

  Returns Promise<string>

getInflationGovernor

• getInflationGovernor(commitment?: Commitment): Promise<InflationGovernor>

• Fetch the cluster InflationGovernor parameters

  Parameters

  • Optionalcommitment: Commitment

  Returns Promise<InflationGovernor>

getInflationRate

• getInflationRate(): Promise<InflationRate>

• Fetch the specific inflation values for the current epoch

  Returns Promise<InflationRate>

getInflationReward

• getInflationReward(
      addresses: PublicKey[],
      epoch?: number,
      commitmentOrConfig?: Commitment | GetInflationRewardConfig,
  ): Promise<(null | InflationReward)[]>

• Fetch the inflation reward for a list of addresses for an epoch

  Parameters

  • addresses: PublicKey[]
  • Optionalepoch: number
  • OptionalcommitmentOrConfig: Commitment | GetInflationRewardConfig

  Returns Promise<(null | InflationReward)[]>

getLargestAccounts

• getLargestAccounts(
      config?: GetLargestAccountsConfig,
  ): Promise<RpcResponseAndContext<AccountBalancePair[]>>

• Fetch the 20 largest accounts with their current balances

  Parameters

  • Optionalconfig: GetLargestAccountsConfig

  Returns Promise<RpcResponseAndContext<AccountBalancePair[]>>

getLatestBlockhash

• getLatestBlockhash(
      commitmentOrConfig?: Commitment | GetLatestBlockhashConfig,
  ): Promise<Readonly<{ blockhash: string; lastValidBlockHeight: number }>>

• Fetch the latest blockhash from the cluster

  Parameters

  • OptionalcommitmentOrConfig: Commitment | GetLatestBlockhashConfig

  Returns Promise<Readonly<{ blockhash: string; lastValidBlockHeight: number }>>

getLatestBlockhashAndContext

• getLatestBlockhashAndContext(
      commitmentOrConfig?: Commitment | GetLatestBlockhashConfig,
  ): Promise<
      RpcResponseAndContext<
          Readonly<{ blockhash: string; lastValidBlockHeight: number }>,
      >,
  >

• Fetch the latest blockhash from the cluster

  Parameters

  • OptionalcommitmentOrConfig: Commitment | GetLatestBlockhashConfig

  Returns Promise<
      RpcResponseAndContext<
          Readonly<{ blockhash: string; lastValidBlockHeight: number }>,
      >,
  >

getLeaderSchedule

• getLeaderSchedule(): Promise<LeaderSchedule>

• Fetch the leader schedule for the current epoch

  Returns Promise<LeaderSchedule>

getMinimumBalanceForRentExemption

• getMinimumBalanceForRentExemption(
      dataLength: number,
      commitment?: Commitment,
  ): Promise<number>

• Fetch the minimum balance needed to exempt an account of dataLength size from rent

  Parameters

  • dataLength: number
  • Optionalcommitment: Commitment

  Returns Promise<number>

getMinimumLedgerSlot

• getMinimumLedgerSlot(): Promise<number>

• Fetch the lowest slot that the node has information about in its ledger. This value may increase over time if the node is configured to purge older ledger data

  Returns Promise<number>

getMultipleAccountsInfo

• getMultipleAccountsInfo(
      publicKeys: PublicKey[],
      commitmentOrConfig?: Commitment | GetMultipleAccountsConfig,
  ): Promise<(null | AccountInfo<Buffer>)[]>

• Fetch all the account info for multiple accounts specified by an array of public keys

  Parameters

  • publicKeys: PublicKey[]
  • OptionalcommitmentOrConfig: Commitment | GetMultipleAccountsConfig

  Returns Promise<(null | AccountInfo<Buffer>)[]>

getMultipleAccountsInfoAndContext

• getMultipleAccountsInfoAndContext(
      publicKeys: PublicKey[],
      commitmentOrConfig?: Commitment | GetMultipleAccountsConfig,
  ): Promise<RpcResponseAndContext<(null | AccountInfo<Buffer>)[]>>

• Fetch all the account info for multiple accounts specified by an array of public keys, return with context

  Parameters

  • publicKeys: PublicKey[]
  • OptionalcommitmentOrConfig: Commitment | GetMultipleAccountsConfig

  Returns Promise<RpcResponseAndContext<(null | AccountInfo<Buffer>)[]>>

getMultipleParsedAccounts

• getMultipleParsedAccounts(
      publicKeys: PublicKey[],
      rawConfig?: GetMultipleAccountsConfig,
  ): Promise<
      RpcResponseAndContext<
          (null | AccountInfo<Buffer | ParsedAccountData>)[],
      >,
  >

• Fetch all the account info for multiple accounts specified by an array of public keys, return with context

  Parameters

  • publicKeys: PublicKey[]
  • OptionalrawConfig: GetMultipleAccountsConfig

  Returns Promise<
      RpcResponseAndContext<
          (null | AccountInfo<Buffer | ParsedAccountData>)[],
      >,
  >

getNonce

• getNonce(
      nonceAccount: PublicKey,
      commitmentOrConfig?: Commitment | GetNonceConfig,
  ): Promise<null | NonceAccount>

• Fetch the contents of a Nonce account from the cluster

  Parameters

  • nonceAccount: PublicKey
  • OptionalcommitmentOrConfig: Commitment | GetNonceConfig

  Returns Promise<null | NonceAccount>

getNonceAndContext

• getNonceAndContext(
      nonceAccount: PublicKey,
      commitmentOrConfig?: Commitment | GetNonceAndContextConfig,
  ): Promise<RpcResponseAndContext<null | NonceAccount>>

• Fetch the contents of a Nonce account from the cluster, return with context

  Parameters

  • nonceAccount: PublicKey
  • OptionalcommitmentOrConfig: Commitment | GetNonceAndContextConfig

  Returns Promise<RpcResponseAndContext<null | NonceAccount>>

getParsedAccountInfo

• getParsedAccountInfo(
      publicKey: PublicKey,
      commitmentOrConfig?: Commitment | GetAccountInfoConfig,
  ): Promise<
      RpcResponseAndContext<null | AccountInfo<Buffer | ParsedAccountData>>,
  >

• Fetch parsed account info for the specified public key

  Parameters

  • publicKey: PublicKey
  • OptionalcommitmentOrConfig: Commitment | GetAccountInfoConfig

  Returns Promise<RpcResponseAndContext<null | AccountInfo<Buffer | ParsedAccountData>>>

getParsedBlock

• getParsedBlock(
      slot: number,
      rawConfig?: GetVersionedBlockConfig,
  ): Promise<ParsedAccountsModeBlockResponse>

• Fetch parsed transaction details for a confirmed or finalized block

  Parameters

  • slot: number
  • OptionalrawConfig: GetVersionedBlockConfig

  Returns Promise<ParsedAccountsModeBlockResponse>
• getParsedBlock(
      slot: number,
      rawConfig: GetVersionedBlockConfig & { transactionDetails: "accounts" },
  ): Promise<ParsedAccountsModeBlockResponse>

• Fetch parsed transaction details for a confirmed or finalized block

  Parameters

  • slot: number
  • rawConfig: GetVersionedBlockConfig & { transactionDetails: "accounts" }

  Returns Promise<ParsedAccountsModeBlockResponse>
• getParsedBlock(
      slot: number,
      rawConfig: GetVersionedBlockConfig & { transactionDetails: "none" },
  ): Promise<ParsedNoneModeBlockResponse>

• Fetch parsed transaction details for a confirmed or finalized block

  Parameters

  • slot: number
  • rawConfig: GetVersionedBlockConfig & { transactionDetails: "none" }

  Returns Promise<ParsedNoneModeBlockResponse>

getParsedConfirmedTransaction

• getParsedConfirmedTransaction(
      signature: string,
      commitment?: Finality,
  ): Promise<null | ParsedTransactionWithMeta>

• Fetch parsed transaction details for a confirmed transaction

  Parameters

  • signature: string
  • Optionalcommitment: Finality

  Returns Promise<null | ParsedTransactionWithMeta>

  Deprecated

  Deprecated since RPC v1.7.0. Please use getParsedTransaction instead.

getParsedConfirmedTransactions

• getParsedConfirmedTransactions(
      signatures: string[],
      commitment?: Finality,
  ): Promise<(null | ParsedTransactionWithMeta)[]>

• Fetch parsed transaction details for a batch of confirmed transactions

  Parameters

  • signatures: string[]
  • Optionalcommitment: Finality

  Returns Promise<(null | ParsedTransactionWithMeta)[]>

  Deprecated

  Deprecated since RPC v1.7.0. Please use getParsedTransactions instead.

getParsedProgramAccounts

• getParsedProgramAccounts(
      programId: PublicKey,
      configOrCommitment?: Commitment | GetParsedProgramAccountsConfig,
  ): Promise<
      { account: AccountInfo<Buffer | ParsedAccountData>; pubkey: PublicKey }[],
  >

• Fetch and parse all the accounts owned by the specified program id

  Parameters

  • programId: PublicKey
  • OptionalconfigOrCommitment: Commitment | GetParsedProgramAccountsConfig

  Returns Promise<
      { account: AccountInfo<Buffer | ParsedAccountData>; pubkey: PublicKey }[],
  >

getParsedTokenAccountsByOwner

• getParsedTokenAccountsByOwner(
      ownerAddress: PublicKey,
      filter: TokenAccountsFilter,
      commitment?: Commitment,
  ): Promise<
      RpcResponseAndContext<
          { account: AccountInfo<ParsedAccountData>; pubkey: PublicKey }[],
      >,
  >

• Fetch parsed token accounts owned by the specified account

  Parameters

  • ownerAddress: PublicKey
  • filter: TokenAccountsFilter
  • Optionalcommitment: Commitment

  Returns Promise<
      RpcResponseAndContext<
          { account: AccountInfo<ParsedAccountData>; pubkey: PublicKey }[],
      >,
  >

getParsedTransaction

• getParsedTransaction(
      signature: string,
      commitmentOrConfig?: Finality | GetVersionedTransactionConfig,
  ): Promise<null | ParsedTransactionWithMeta>

• Fetch parsed transaction details for a confirmed or finalized transaction

  Parameters

  • signature: string
  • OptionalcommitmentOrConfig: Finality | GetVersionedTransactionConfig

  Returns Promise<null | ParsedTransactionWithMeta>

getParsedTransactions

• getParsedTransactions(
      signatures: string[],
      commitmentOrConfig?: Finality | GetVersionedTransactionConfig,
  ): Promise<(null | ParsedTransactionWithMeta)[]>

• Fetch parsed transaction details for a batch of confirmed transactions

  Parameters

  • signatures: string[]
  • OptionalcommitmentOrConfig: Finality | GetVersionedTransactionConfig

  Returns Promise<(null | ParsedTransactionWithMeta)[]>

getProgramAccounts

• getProgramAccounts(
      programId: PublicKey,
      configOrCommitment: GetProgramAccountsConfig & Readonly<
          { withContext: true },
      >,
  ): Promise<RpcResponseAndContext<GetProgramAccountsResponse>>

• Fetch all the accounts owned by the specified program id

  Parameters

  • programId: PublicKey
  • configOrCommitment: GetProgramAccountsConfig & Readonly<{ withContext: true }>

  Returns Promise<RpcResponseAndContext<GetProgramAccountsResponse>>
• getProgramAccounts(
      programId: PublicKey,
      configOrCommitment?: Commitment | GetProgramAccountsConfig,
  ): Promise<GetProgramAccountsResponse>

• Fetch all the accounts owned by the specified program id

  Parameters

  • programId: PublicKey
  • OptionalconfigOrCommitment: Commitment | GetProgramAccountsConfig

  Returns Promise<GetProgramAccountsResponse>

getRecentBlockhash

• getRecentBlockhash(
      commitment?: Commitment,
  ): Promise<{ blockhash: string; feeCalculator: FeeCalculator }>

• Fetch a recent blockhash from the cluster

  Parameters

  • Optionalcommitment: Commitment

  Returns Promise<{ blockhash: string; feeCalculator: FeeCalculator }>

  Deprecated

  Deprecated since RPC v1.8.0. Please use getLatestBlockhash instead.

getRecentBlockhashAndContext

• getRecentBlockhashAndContext(
      commitment?: Commitment,
  ): Promise<
      RpcResponseAndContext<
          { blockhash: string; feeCalculator: FeeCalculator },
      >,
  >

• Fetch a recent blockhash from the cluster, return with context

  Parameters

  • Optionalcommitment: Commitment

  Returns Promise<
      RpcResponseAndContext<
          { blockhash: string; feeCalculator: FeeCalculator },
      >,
  >

  Deprecated

  Deprecated since RPC v1.9.0. Please use getLatestBlockhash instead.

getRecentPerformanceSamples

• getRecentPerformanceSamples(limit?: number): Promise<PerfSample[]>

• Fetch recent performance samples

  Parameters

  • Optionallimit: number

  Returns Promise<PerfSample[]>

getRecentPrioritizationFees

• getRecentPrioritizationFees(
      config?: GetRecentPrioritizationFeesConfig,
  ): Promise<RecentPrioritizationFees[]>

• Fetch a list of prioritization fees from recent blocks.

  Parameters

  • Optionalconfig: GetRecentPrioritizationFeesConfig

  Returns Promise<RecentPrioritizationFees[]>

getSignaturesForAddress

• getSignaturesForAddress(
      address: PublicKey,
      options?: SignaturesForAddressOptions,
      commitment?: Finality,
  ): Promise<ConfirmedSignatureInfo[]>

• Returns confirmed signatures for transactions involving an address backwards in time from the provided signature or most recent confirmed block

  Parameters

  • address: PublicKey

    queried address
  • Optionaloptions: SignaturesForAddressOptions
  • Optionalcommitment: Finality

  Returns Promise<ConfirmedSignatureInfo[]>

getSignatureStatus

• getSignatureStatus(
      signature: string,
      config?: SignatureStatusConfig,
  ): Promise<RpcResponseAndContext<null | SignatureStatus>>

• Fetch the current status of a signature

  Parameters

  • signature: string
  • Optionalconfig: SignatureStatusConfig

  Returns Promise<RpcResponseAndContext<null | SignatureStatus>>

getSignatureStatuses

• getSignatureStatuses(
      signatures: string[],
      config?: SignatureStatusConfig,
  ): Promise<RpcResponseAndContext<(null | SignatureStatus)[]>>

• Fetch the current statuses of a batch of signatures

  Parameters

  • signatures: string[]
  • Optionalconfig: SignatureStatusConfig

  Returns Promise<RpcResponseAndContext<(null | SignatureStatus)[]>>

getSlot

• getSlot(commitmentOrConfig?: Commitment | GetSlotConfig): Promise<number>

• Fetch the current slot that the node is processing

  Parameters

  • OptionalcommitmentOrConfig: Commitment | GetSlotConfig

  Returns Promise<number>

getSlotLeader

• getSlotLeader(
      commitmentOrConfig?: Commitment | GetSlotLeaderConfig,
  ): Promise<string>

• Fetch the current slot leader of the cluster

  Parameters

  • OptionalcommitmentOrConfig: Commitment | GetSlotLeaderConfig

  Returns Promise<string>

getSlotLeaders

• getSlotLeaders(startSlot: number, limit: number): Promise<PublicKey[]>

• Fetch limit number of slot leaders starting from startSlot

  Parameters

  • startSlot: number

    fetch slot leaders starting from this slot
  • limit: number

    number of slot leaders to return

  Returns Promise<PublicKey[]>

getStakeActivation

• getStakeActivation(
      publicKey: PublicKey,
      commitmentOrConfig?: Commitment | GetStakeActivationConfig,
      epoch?: number,
  ): Promise<StakeActivationData>

• Returns epoch activation information for a stake account that has been delegated

  Parameters

  • publicKey: PublicKey
  • OptionalcommitmentOrConfig: Commitment | GetStakeActivationConfig
  • Optionalepoch: number

  Returns Promise<StakeActivationData>

  Deprecated

  Deprecated since RPC v1.18; will be removed in a future version.

getStakeMinimumDelegation

• getStakeMinimumDelegation(
      config?: GetStakeMinimumDelegationConfig,
  ): Promise<RpcResponseAndContext<number>>

• get the stake minimum delegation

  Parameters

  • Optionalconfig: GetStakeMinimumDelegationConfig

  Returns Promise<RpcResponseAndContext<number>>

getSupply

• getSupply(
      config?: Commitment | GetSupplyConfig,
  ): Promise<RpcResponseAndContext<Supply>>

• Fetch information about the current supply

  Parameters

  • Optionalconfig: Commitment | GetSupplyConfig

  Returns Promise<RpcResponseAndContext<Supply>>

getTokenAccountBalance

• getTokenAccountBalance(
      tokenAddress: PublicKey,
      commitment?: Commitment,
  ): Promise<RpcResponseAndContext<TokenAmount>>

• Fetch the current balance of a token account

  Parameters

  • tokenAddress: PublicKey
  • Optionalcommitment: Commitment

  Returns Promise<RpcResponseAndContext<TokenAmount>>

getTokenAccountsByOwner

• getTokenAccountsByOwner(
      ownerAddress: PublicKey,
      filter: TokenAccountsFilter,
      commitmentOrConfig?: Commitment | GetTokenAccountsByOwnerConfig,
  ): Promise<RpcResponseAndContext<GetProgramAccountsResponse>>

• Fetch all the token accounts owned by the specified account

  Parameters

  • ownerAddress: PublicKey
  • filter: TokenAccountsFilter
  • OptionalcommitmentOrConfig: Commitment | GetTokenAccountsByOwnerConfig

  Returns Promise<RpcResponseAndContext<GetProgramAccountsResponse>>

getTokenLargestAccounts

• getTokenLargestAccounts(
      mintAddress: PublicKey,
      commitment?: Commitment,
  ): Promise<RpcResponseAndContext<TokenAccountBalancePair[]>>

• Fetch the 20 largest token accounts with their current balances for a given mint.

  Parameters

  • mintAddress: PublicKey
  • Optionalcommitment: Commitment

  Returns Promise<RpcResponseAndContext<TokenAccountBalancePair[]>>

getTokenSupply

• getTokenSupply(
      tokenMintAddress: PublicKey,
      commitment?: Commitment,
  ): Promise<RpcResponseAndContext<TokenAmount>>

• Fetch the current supply of a token mint

  Parameters

  • tokenMintAddress: PublicKey
  • Optionalcommitment: Commitment

  Returns Promise<RpcResponseAndContext<TokenAmount>>

getTotalSupply

• getTotalSupply(commitment?: Commitment): Promise<number>

• Fetch the current total currency supply of the cluster in lamports

  Parameters

  • Optionalcommitment: Commitment

  Returns Promise<number>

  Deprecated

  Deprecated since RPC v1.2.8. Please use getSupply instead.

getTransaction

• getTransaction(
      signature: string,
      rawConfig?: GetTransactionConfig,
  ): Promise<null | TransactionResponse>

• Fetch a confirmed or finalized transaction from the cluster.

  Parameters

  • signature: string
  • OptionalrawConfig: GetTransactionConfig

  Returns Promise<null | TransactionResponse>

  Deprecated

  Instead, call getTransaction using a GetVersionedTransactionConfig by setting the maxSupportedTransactionVersion property.

• getTransaction(
      signature: string,
      rawConfig: GetVersionedTransactionConfig,
  ): Promise<null | VersionedTransactionResponse>

• Fetch a confirmed or finalized transaction from the cluster.

  Parameters

  • signature: string
  • rawConfig: GetVersionedTransactionConfig

  Returns Promise<null | VersionedTransactionResponse>

getTransactionCount

• getTransactionCount(
      commitmentOrConfig?: Commitment | GetTransactionCountConfig,
  ): Promise<number>

• Fetch the current transaction count of the cluster

  Parameters

  • OptionalcommitmentOrConfig: Commitment | GetTransactionCountConfig

  Returns Promise<number>

getTransactions

• getTransactions(
      signatures: string[],
      commitmentOrConfig?: GetTransactionConfig | Finality,
  ): Promise<(null | TransactionResponse)[]>

• Fetch transaction details for a batch of confirmed transactions. Similar to getParsedTransactions but returns a TransactionResponse.

  Parameters

  • signatures: string[]
  • OptionalcommitmentOrConfig: GetTransactionConfig | Finality

  Returns Promise<(null | TransactionResponse)[]>

  Deprecated

  Instead, call getTransactions using a GetVersionedTransactionConfig by setting the maxSupportedTransactionVersion property.

• getTransactions(
      signatures: string[],
      commitmentOrConfig: Finality | GetVersionedTransactionConfig,
  ): Promise<(null | VersionedTransactionResponse)[]>

• Fetch transaction details for a batch of confirmed transactions. Similar to getParsedTransactions but returns a VersionedTransactionResponse.

  Parameters

  • signatures: string[]
  • commitmentOrConfig: Finality | GetVersionedTransactionConfig

  Returns Promise<(null | VersionedTransactionResponse)[]>

getVersion

• getVersion(): Promise<Version>

• Fetch the node version

  Returns Promise<Version>

getVoteAccounts

• getVoteAccounts(commitment?: Commitment): Promise<VoteAccountStatus>

• Return the list of nodes that are currently participating in the cluster

  Parameters

  • Optionalcommitment: Commitment

  Returns Promise<VoteAccountStatus>

isBlockhashValid

• isBlockhashValid(
      blockhash: string,
      rawConfig?: IsBlockhashValidConfig,
  ): Promise<RpcResponseAndContext<boolean>>

• Returns whether a blockhash is still valid or not

  Parameters

  • blockhash: string
  • OptionalrawConfig: IsBlockhashValidConfig

  Returns Promise<RpcResponseAndContext<boolean>>

onAccountChange

• onAccountChange(
      publicKey: PublicKey,
      callback: AccountChangeCallback,
      config?: Readonly<
          {
              commitment?: Commitment;
              encoding?: "base64"
              | "base58"
              | "base64+zstd"
              | "jsonParsed";
          },
      >,
  ): number

• Register a callback to be invoked whenever the specified account changes

  Parameters

  • publicKey: PublicKey

    Public key of the account to monitor
  • callback: AccountChangeCallback

    Function to invoke whenever the account is changed
  • Optionalconfig: Readonly<
        {
            commitment?: Commitment;
            encoding?: "base64"
            | "base58"
            | "base64+zstd"
            | "jsonParsed";
        },
    >

  Returns number

  subscription id
• onAccountChange(
      publicKey: PublicKey,
      callback: AccountChangeCallback,
      commitment?: Commitment,
  ): number

• Parameters

  • publicKey: PublicKey
  • callback: AccountChangeCallback
  • Optionalcommitment: Commitment

  Returns number

  Deprecated

  Instead, pass in an AccountSubscriptionConfig

onLogs

• onLogs(
      filter: LogsFilter,
      callback: LogsCallback,
      commitment?: Commitment,
  ): number

• Registers a callback to be invoked whenever logs are emitted.

  Parameters

  • filter: LogsFilter
  • callback: LogsCallback
  • Optionalcommitment: Commitment

  Returns number

onProgramAccountChange

• onProgramAccountChange(
      programId: PublicKey,
      callback: ProgramAccountChangeCallback,
      config?: Readonly<
          {
              commitment?: Commitment;
              encoding?: "base64"
              | "base58"
              | "base64+zstd"
              | "jsonParsed";
              filters?: GetProgramAccountsFilter[];
          },
      >,
  ): number

• Register a callback to be invoked whenever accounts owned by the specified program change

  Parameters

  • programId: PublicKey

    Public key of the program to monitor
  • callback: ProgramAccountChangeCallback

    Function to invoke whenever the account is changed
  • Optionalconfig: Readonly<
        {
            commitment?: Commitment;
            encoding?: "base64"
            | "base58"
            | "base64+zstd"
            | "jsonParsed";
            filters?: GetProgramAccountsFilter[];
        },
    >

  Returns number

  subscription id
• onProgramAccountChange(
      programId: PublicKey,
      callback: ProgramAccountChangeCallback,
      commitment?: Commitment,
      filters?: GetProgramAccountsFilter[],
  ): number

• Parameters

  • programId: PublicKey
  • callback: ProgramAccountChangeCallback
  • Optionalcommitment: Commitment
  • Optionalfilters: GetProgramAccountsFilter[]

  Returns number

  Deprecated

  Instead, pass in a ProgramAccountSubscriptionConfig

onRootChange

• onRootChange(callback: RootChangeCallback): number

• Register a callback to be invoked upon root changes

  Parameters

  • callback: RootChangeCallback

    Function to invoke whenever the root changes

  Returns number

  subscription id

onSignature

• onSignature(
      signature: string,
      callback: SignatureResultCallback,
      commitment?: Commitment,
  ): number

• Register a callback to be invoked upon signature updates

  Parameters

  • signature: string

    Transaction signature string in base 58
  • callback: SignatureResultCallback

    Function to invoke on signature notifications
  • Optionalcommitment: Commitment

    Specify the commitment level signature must reach before notification

  Returns number

  subscription id

onSignatureWithOptions

• onSignatureWithOptions(
      signature: string,
      callback: SignatureSubscriptionCallback,
      options?: SignatureSubscriptionOptions,
  ): number

• Register a callback to be invoked when a transaction is received and/or processed.

  Parameters

  • signature: string

    Transaction signature string in base 58
  • callback: SignatureSubscriptionCallback

    Function to invoke on signature notifications
  • Optionaloptions: SignatureSubscriptionOptions

    Enable received notifications and set the commitment level that signature must reach before notification

  Returns number

  subscription id

onSlotChange

• onSlotChange(callback: SlotChangeCallback): number

• Register a callback to be invoked upon slot changes

  Parameters

  • callback: SlotChangeCallback

    Function to invoke whenever the slot changes

  Returns number

  subscription id

onSlotUpdate

• onSlotUpdate(callback: SlotUpdateCallback): number

• Register a callback to be invoked upon slot updates. SlotUpdate's may be useful to track live progress of a cluster.

  Parameters

  • callback: SlotUpdateCallback

    Function to invoke whenever the slot updates

  Returns number

  subscription id

removeAccountChangeListener

• removeAccountChangeListener(clientSubscriptionId: number): Promise<void>

• Deregister an account notification callback

  Parameters

  • clientSubscriptionId: number

    client subscription id to deregister

  Returns Promise<void>

removeOnLogsListener

• removeOnLogsListener(clientSubscriptionId: number): Promise<void>

• Deregister a logs callback.

  Parameters

  • clientSubscriptionId: number

    client subscription id to deregister.

  Returns Promise<void>

removeProgramAccountChangeListener

• removeProgramAccountChangeListener(clientSubscriptionId: number): Promise<void>

• Deregister an account notification callback

  Parameters

  • clientSubscriptionId: number

    client subscription id to deregister

  Returns Promise<void>

removeRootChangeListener

• removeRootChangeListener(clientSubscriptionId: number): Promise<void>

• Deregister a root notification callback

  Parameters

  • clientSubscriptionId: number

    client subscription id to deregister

  Returns Promise<void>

removeSignatureListener

• removeSignatureListener(clientSubscriptionId: number): Promise<void>

• Deregister a signature notification callback

  Parameters

  • clientSubscriptionId: number

    client subscription id to deregister

  Returns Promise<void>

removeSlotChangeListener

• removeSlotChangeListener(clientSubscriptionId: number): Promise<void>

• Deregister a slot notification callback

  Parameters

  • clientSubscriptionId: number

    client subscription id to deregister

  Returns Promise<void>

removeSlotUpdateListener

• removeSlotUpdateListener(clientSubscriptionId: number): Promise<void>

• Deregister a slot update notification callback

  Parameters

  • clientSubscriptionId: number

    client subscription id to deregister

  Returns Promise<void>

requestAirdrop

• requestAirdrop(to: PublicKey, lamports: number): Promise<string>

• Request an allocation of lamports to the specified address

  import { Connection, PublicKey, LAMPORTS_PER_SOL } from "@solana/web3.js";
  
  (async () => {
    const connection = new Connection("https://api.testnet.solana.com", "confirmed");
    const myAddress = new PublicKey("2nr1bHFT86W9tGnyvmYW4vcHKsQB3sVQfnddasz4kExM");
    const signature = await connection.requestAirdrop(myAddress, LAMPORTS_PER_SOL);
    await connection.confirmTransaction(signature);
  })();
  Copy

  Parameters

  • to: PublicKey
  • lamports: number

  Returns Promise<string>

sendEncodedTransaction

• sendEncodedTransaction(
      encodedTransaction: string,
      options?: SendOptions,
  ): Promise<string>

• Send a transaction that has already been signed, serialized into the wire format, and encoded as a base64 string

  Parameters

  • encodedTransaction: string
  • Optionaloptions: SendOptions

  Returns Promise<string>

sendRawTransaction

• sendRawTransaction(
      rawTransaction: number[] | Uint8Array | Buffer,
      options?: SendOptions,
  ): Promise<string>

• Send a transaction that has already been signed and serialized into the wire format

  Parameters

  • rawTransaction: number[] | Uint8Array | Buffer
  • Optionaloptions: SendOptions

  Returns Promise<string>

sendTransaction

• sendTransaction(
      transaction: Transaction,
      signers: Signer[],
      options?: SendOptions,
  ): Promise<string>

• Sign and send a transaction

  Parameters

  • transaction: Transaction
  • signers: Signer[]
  • Optionaloptions: SendOptions

  Returns Promise<string>

  Deprecated

  Instead, call sendTransaction with a VersionedTransaction

• sendTransaction(
      transaction: VersionedTransaction,
      options?: SendOptions,
  ): Promise<string>

• Send a signed transaction

  Parameters

  • transaction: VersionedTransaction
  • Optionaloptions: SendOptions

  Returns Promise<string>

simulateTransaction

• simulateTransaction(
      transactionOrMessage: Transaction | Message,
      signers?: Signer[],
      includeAccounts?: boolean | PublicKey[],
  ): Promise<RpcResponseAndContext<SimulatedTransactionResponse>>

• Simulate a transaction

  Parameters

  • transactionOrMessage: Transaction | Message
  • Optionalsigners: Signer[]
  • OptionalincludeAccounts: boolean | PublicKey[]

  Returns Promise<RpcResponseAndContext<SimulatedTransactionResponse>>

  Deprecated

  Instead, call simulateTransaction with VersionedTransaction and SimulateTransactionConfig parameters

• simulateTransaction(
      transaction: VersionedTransaction,
      config?: SimulateTransactionConfig,
  ): Promise<RpcResponseAndContext<SimulatedTransactionResponse>>

• Simulate a transaction

  Parameters

  • transaction: VersionedTransaction
  • Optionalconfig: SimulateTransactionConfig

  Returns Promise<RpcResponseAndContext<SimulatedTransactionResponse>>