Struct Client

pub struct Client { /* private fields */ }

The Client.

Implementations

impl Client

pub fn new(sender: RpcChannel) -> Self

Creates a new Client.

pub fn get_account_info( &self, pubkey_str: String, config: Option<RpcAccountInfoConfig>, ) -> impl Future<Output = RpcResult<RpcResponse<Option<UiAccount>>>>

Returns detailed information about an account given its public key.

This method queries the blockchain for the account associated with the provided public key string. It can be used to inspect balances, ownership, and program-related metadata.

Parameters

• pubkey_str: A base-58 encoded string representing the account’s public key.
• config: Optional configuration that controls encoding, commitment level, data slicing, and other response details.

Returns

A RpcResponse containing an optional UiAccount object if the account exists. If the account does not exist, the response will contain null.

Example Request (JSON-RPC)

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "getAccountInfo",
  "params": [
    "9XQeWMPMPXwW1fzLEQeTTrfF5Eb9dj8Qs3tCPoMw3GiE",
    {
      "encoding": "jsonParsed",
      "commitment": "finalized"
    }
  ]
}

Example Response

{
  "jsonrpc": "2.0",
  "result": {
    "context": {
      "slot": 12345678
    },
    "value": {
      "lamports": 10000000,
      "data": {
        "program": "spl-token",
        "parsed": { ... },
        "space": 165
      },
      "owner": "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA",
      "executable": false,
      "rentEpoch": 203,
      "space": 165
    }
  },
  "id": 1
}

Errors

• Returns an error if the public key is malformed or invalid
• Returns an internal error if the ledger cannot be accessed

See also

• UiAccount: A readable structure representing on-chain accounts

pub fn get_block_commitment( &self, block: Slot, ) -> impl Future<Output = RpcResult<RpcBlockCommitment<BlockCommitmentArray>>>

Returns commitment levels for a given block (slot).

This method provides insight into how many validators have voted for a specific block and with what level of lockout. This can be used to analyze consensus progress and determine finality confidence.

Parameters

• block: The target slot (block) to query.

Returns

A RpcBlockCommitment containing a BlockCommitmentArray, which is an array of 32 integers representing the number of votes at each lockout level for that block. Each index corresponds to a lockout level (i.e., confidence in finality).

Example Request (JSON-RPC)

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "getBlockCommitment",
  "params": [150000000]
}

Example Response

{
  "jsonrpc": "2.0",
  "result": {
    "commitment": [0, 4, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
    "totalStake": 100000000
  },
  "id": 1
}

Errors

• If the slot is not found in the current bank or has been purged, this call may return an error.
• May fail if the RPC node is lagging behind or doesn’t have voting history for the slot.

See also

• BlockCommitmentArray: An array representing votes by lockout level
• RpcBlockCommitment: Wrapper struct for the full response

pub fn get_multiple_accounts( &self, pubkey_strs: Vec<String>, config: Option<RpcAccountInfoConfig>, ) -> impl Future<Output = RpcResult<RpcResponse<Vec<Option<UiAccount>>>>>

Returns account information for multiple public keys in a single call.

This method allows batching of account lookups for improved performance and fewer network roundtrips. It returns a list of UiAccount values in the same order as the provided public keys.

Parameters

• pubkey_strs: A list of base-58 encoded public key strings representing accounts to query.
• config: Optional configuration to control encoding, commitment level, data slicing, etc.

Returns

A RpcResponse wrapping a vector of optional UiAccount objects.
Each element in the response corresponds to the public key at the same index in the request. If an account is not found, the corresponding entry will be null.

Example Request (JSON-RPC)

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "getMultipleAccounts",
  "params": [
    [
      "9XQeWMPMPXwW1fzLEQeTTrfF5Eb9dj8Qs3tCPoMw3GiE",
      "3nN8SBQ2HqTDNnaCzryrSv4YHd4d6GpVCEyDhKMPxN4o"
    ],
    {
      "encoding": "jsonParsed",
      "commitment": "confirmed"
    }
  ]
}

Example Response

{
  "jsonrpc": "2.0",
  "result": {
    "context": { "slot": 12345678 },
    "value": [
      {
        "lamports": 10000000,
        "data": {
          "program": "spl-token",
          "parsed": { ... },
          "space": 165
        },
        "owner": "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA",
        "executable": false,
        "rentEpoch": 203,
        "space": 165
      },
      null
    ]
  },
  "id": 1
}

Errors

• If any public key is malformed or invalid, the entire call may fail.
• Returns an internal error if the ledger cannot be accessed or some accounts are purged.

See also

• UiAccount: Human-readable representation of an account
• [get_account_info]: Use when querying a single account

pub fn get_token_account_balance( &self, pubkey_str: String, commitment: Option<CommitmentConfig>, ) -> impl Future<Output = RpcResult<RpcResponse<Option<UiTokenAmount>>>>

Returns the balance of a token account, given its public key.

This method fetches the token balance of an account, including its amount and user-friendly information (like the UI amount in human-readable format). It is useful for token-related applications, such as checking balances in wallets or exchanges.

Parameters

• pubkey_str: The base-58 encoded string of the public key of the token account.
• commitment: Optional commitment configuration to specify the desired confirmation level of the query.

Returns

A RpcResponse containing the token balance in a UiTokenAmount struct. If the account doesn’t hold any tokens or is invalid, the response will contain null.

Example Request (JSON-RPC)

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "getTokenAccountBalance",
  "params": [
    "3nN8SBQ2HqTDNnaCzryrSv4YHd4d6GpVCEyDhKMPxN4o",
    {
      "commitment": "confirmed"
    }
  ]
}

Example Response

{
  "jsonrpc": "2.0",
  "result": {
    "context": {
      "slot": 12345678
    },
    "value": {
      "uiAmount": 100.0,
      "decimals": 6,
      "amount": "100000000",
      "uiAmountString": "100.000000"
    }
  },
  "id": 1
}

Errors

• If the provided public key is invalid or does not exist.
• If the account is not a valid token account or does not hold any tokens.

See also

• UiTokenAmount: Represents the token balance in user-friendly format.

pub fn get_token_supply( &self, mint_str: String, commitment: Option<CommitmentConfig>, ) -> impl Future<Output = RpcResult<RpcResponse<UiTokenAmount>>>

Returns the total supply of a token, given its mint address.

This method provides the total circulating supply of a specific token, including the raw amount and human-readable UI-formatted values. It can be useful for tracking token issuance and verifying the supply of a token on-chain.

Parameters

• mint_str: The base-58 encoded string of the mint address for the token.
• commitment: Optional commitment configuration to specify the desired confirmation level of the query.

Returns

A RpcResponse containing the total token supply in a UiTokenAmount struct. If the token does not exist or is invalid, the response will return an error.

Example Request (JSON-RPC)

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "getTokenSupply",
  "params": [
    "So11111111111111111111111111111111111111112",
    {
      "commitment": "confirmed"
    }
  ]
}

Example Response

{
  "jsonrpc": "2.0",
  "result": {
    "context": {
      "slot": 12345678
    },
    "value": {
      "uiAmount": 1000000000.0,
      "decimals": 6,
      "amount": "1000000000000000",
      "uiAmountString": "1000000000.000000"
    }
  },
  "id": 1
}

Errors

• If the mint address is invalid or does not correspond to a token.
• If the token supply cannot be fetched due to network issues or node synchronization problems.

See also

• UiTokenAmount: Represents the token balance or supply in a user-friendly format.

Trait Implementations

impl Clone for Client

fn clone(&self) -> Client

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl From<RpcChannel> for Client

fn from(channel: RpcChannel) -> Self

Converts to this type from the input type.