Struct MinimalClient 

pub struct MinimalClient { /* private fields */ }

The Client.

Implementations

impl Client

pub fn new(sender: RpcChannel) -> Self

Creates a new Client.

pub fn get_balance( &self, pubkey_str: String, config: Option<RpcContextConfig>, ) -> impl Future<Output = RpcResult<RpcResponse<u64>>>

Returns the balance (in lamports) of the account at the provided public key.

This endpoint queries the current or historical balance of an account, depending on the optional commitment level provided in the config.

Parameters

• pubkey_str: The base-58 encoded public key of the account to query.
• _config (optional): RpcContextConfig specifying commitment level and/or minimum context slot.

Returns

An RpcResponse<u64> where the value is the balance in lamports.

Example Request

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "getBalance",
  "params": [
    "4Nd1mXUmh23rQk8VN7wM9hEnfxqrrB1yrn11eW9gMoVr"
  ]
}

Example Response

{
  "jsonrpc": "2.0",
  "result": {
    "context": {
      "slot": 1085597
    },
    "value": 20392800
  },
  "id": 1
}

Notes

• 1 SOL = 1,000,000,000 lamports.
• Use commitment level in the config to specify whether the balance should be fetched from processed, confirmed, or finalized state.

See Also

• getAccountInfo, getTokenAccountBalance

pub fn get_epoch_info( &self, config: Option<RpcContextConfig>, ) -> impl Future<Output = RpcResult<EpochInfo>>

Returns information about the current epoch.

This endpoint provides epoch-related data such as the current epoch number, the total number of slots in the epoch, the current slot index within the epoch, and the absolute slot number.

Parameters

• config (optional): RpcContextConfig for specifying commitment level and/or minimum context slot.

Returns

An EpochInfo struct containing information about the current epoch.

Example Request

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "getEpochInfo"
}

Example Response

{
  "jsonrpc": "2.0",
  "result": {
    "epoch": 278,
    "slotIndex": 423,
    "slotsInEpoch": 432000,
    "absoluteSlot": 124390823,
    "blockHeight": 18962432,
    "transactionCount": 981234523
  },
  "id": 1
}

Notes

• The slotIndex is the current slot’s position within the epoch.
• slotsInEpoch may vary due to network adjustments (e.g., warm-up periods).
• The commitment field in the config can influence how recent the returned data is.

See Also

• getEpochSchedule, getSlot, getBlockHeight

pub fn get_genesis_hash(&self) -> impl Future<Output = RpcResult<String>>

Returns the genesis hash of the blockchain.

The genesis hash is a unique identifier that represents the state of the blockchain at the genesis block (the very first block). This can be used to validate the integrity of the blockchain and ensure that a node is operating with the correct blockchain data.

Parameters

• None.

Returns

A String containing the base-58 encoded genesis hash.

Example Request

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "getGenesisHash"
}

Example Response

{
  "jsonrpc": "2.0",
  "result": "5eymX3jrWXcKqD1tsB2BzAB6gX9LP2pLrpVG6KwBSoZJ"
  "id": 1
}

Notes

• The genesis hash is a critical identifier for validating the blockchain’s origin and initial state.
• This endpoint does not require any parameters and provides a quick way to verify the genesis hash for blockchain verification or initial setup.

See Also

• getEpochInfo, getBlock, getClusterNodes

pub fn get_health(&self) -> impl Future<Output = RpcResult<String>>

Returns the health status of the blockchain node.

This method checks the health of the node and returns a status indicating whether the node is in a healthy state or if it is experiencing any issues such as being out of sync with the network or encountering any failures.

Parameters

• None.

Returns

A String indicating the health status of the node:

• "ok": The node is healthy and synchronized with the network.
• "failed": The node is not healthy or is experiencing issues.

Example Request

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "getHealth"
}

Example Response

{
  "jsonrpc": "2.0",
  "result": "ok",
  "id": 1
}

Notes

• The "ok" response means that the node is fully operational and synchronized with the blockchain.
• The "failed" response indicates that the node is either out of sync, has encountered an error, or is not functioning properly.
• This is typically used to monitor the health of the node in production environments.

See Also

• getGenesisHash, getEpochInfo, getBlock

pub fn get_identity(&self) -> impl Future<Output = RpcResult<RpcIdentity>>

Returns the identity (public key) of the node.

This method retrieves the current identity of the node, which is represented by a public key. The identity is used to uniquely identify the node on the network.

Parameters

• None.

Returns

A RpcIdentity object containing the identity of the node:

• identity: The base-58 encoded public key of the node’s identity.

Example Request

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "getIdentity"
}

Example Response

{
  "jsonrpc": "2.0",
  "result": {
    "identity": "Base58EncodedPublicKeyHere"
  },
  "id": 1
}

Notes

• The identity returned is a base-58 encoded public key representing the current node.
• This identity is often used for network identification and security.

See Also

• getGenesisHash, getHealth, getBlock

pub fn get_slot( &self, config: Option<RpcContextConfig>, ) -> impl Future<Output = RpcResult<Slot>>

Returns the current slot of the ledger.

This method retrieves the current slot number in the blockchain, which represents a point in the ledger’s history. Slots are used to organize and validate the timing of transactions in the network.

Parameters

• config (optional): Configuration options for the request, such as commitment level or context slot. Defaults to None.

Returns

A Slot value representing the current slot of the ledger.

Example Request

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "getSlot"
}

Example Response

{
  "jsonrpc": "2.0",
  "result": 12345678,
  "id": 1
}

Notes

• The slot represents the position in the ledger. It increments over time as new blocks are produced.

See Also

• getBlock, getEpochInfo, getGenesisHash

pub fn get_block_height( &self, config: Option<RpcContextConfig>, ) -> impl Future<Output = RpcResult<u64>>

Returns the current block height.

This method retrieves the height of the most recent block in the ledger, which is an indicator of how many blocks have been added to the blockchain. The block height is the number of blocks that have been produced since the genesis block.

Parameters

• config (optional): Configuration options for the request, such as commitment level or context slot. Defaults to None.

Returns

A u64 representing the current block height of the ledger.

Example Request

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "getBlockHeight"
}

Example Response

{
  "jsonrpc": "2.0",
  "result": 12345678,
  "id": 1
}

Notes

• The block height reflects the number of blocks produced in the ledger, starting from the genesis block. It is incremented each time a new block is added.

See Also

• getSlot, getEpochInfo, getGenesisHash

pub fn get_highest_snapshot_slot( &self, ) -> impl Future<Output = RpcResult<RpcSnapshotSlotInfo>>

Returns information about the highest snapshot slot.

This method retrieves information about the most recent snapshot slot, which refers to the slot in the blockchain where the most recent snapshot has been taken. A snapshot is a point-in-time capture of the state of the ledger, allowing for quicker validation of the state without processing every transaction.

Parameters

• meta: Metadata passed with the request, such as the client’s request context.

Returns

A RpcSnapshotSlotInfo containing information about the highest snapshot slot.

Example Request

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "getHighestSnapshotSlot"
}

Example Response

{
  "jsonrpc": "2.0",
  "result": {
    "slot": 987654,
    "root": "A9B7F1A4D1D55D0635B905E5AB6341C5D9F7F4D2A1160C53B5647B1E3259BB24"
  },
  "id": 1
}

Notes

• The snapshot slot represents the most recent snapshot in the blockchain and is used for more efficient state validation and recovery.
• The result also includes the root, which is the blockhash at the snapshot point.

See Also

• getBlock, getSnapshotInfo

pub fn get_transaction_count( &self, config: Option<RpcContextConfig>, ) -> impl Future<Output = RpcResult<u64>>

Returns the total number of transactions processed by the blockchain.

This method retrieves the number of transactions that have been processed in the blockchain up to the current point. It provides a snapshot of the transaction throughput and can be useful for monitoring and performance analysis.

Parameters

• meta: Metadata passed with the request, such as the client’s request context.
• config: Optional configuration for the request, such as commitment settings or minimum context slot.

Returns

A u64 representing the total transaction count.

Example Request

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "getTransactionCount"
}

Example Response

{
  "jsonrpc": "2.0",
  "result": 1234567890,
  "id": 1
}

Notes

• This method gives a cumulative count of all transactions in the blockchain from the start of the network.

See Also

• getBlockHeight, getEpochInfo

pub fn get_version( &self, ) -> impl Future<Output = RpcResult<SurfpoolRpcVersionInfo>>

Returns the current version of the server or application.

This method retrieves the version information for the server or application. It provides details such as the version number and additional metadata that can help with compatibility checks or updates.

Parameters

• meta: Metadata passed with the request, such as the client’s request context.

Returns

A SurfpoolRpcVersionInfo object containing the version details.

Example Request

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "getVersion"
}

Example Response

{
  "jsonrpc": "2.0",
  "result": {
    "surfnet_version": "1.2.3",
    "solana_core": "1.9.0",
    "feature_set": 12345
  },
  "id": 1
}

Notes

• The version information typically includes the version number of surfpool, the version of solana-core, and a feature_set identifier (first 4 bytes).
• The feature_set field may not always be present, depending on whether a feature set identifier is available.

See Also

• getHealth, getIdentity

pub fn get_vote_accounts( &self, config: Option<RpcGetVoteAccountsConfig>, ) -> impl Future<Output = RpcResult<RpcVoteAccountStatus>>

Returns vote account information.

This method retrieves the current status of vote accounts, including information about the validator’s vote account and whether it is delinquent. The response includes vote account details such as the stake, commission, vote history, and more.

Parameters

• meta: Metadata passed with the request, such as the client’s request context.
• config: Optional configuration parameters, such as specific vote account addresses or commitment settings.

Returns

A RpcVoteAccountStatus object containing details about the current and delinquent vote accounts.

Example Request

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

Example Response

{
  "jsonrpc": "2.0",
  "result": {
    "current": [
      {
        "votePubkey": "votePubkeyBase58",
        "nodePubkey": "nodePubkeyBase58",
        "activatedStake": 1000000,
        "commission": 5,
        "epochVoteAccount": true,
        "epochCredits": [[1, 1000, 900], [2, 1100, 1000]],
        "lastVote": 1000,
        "rootSlot": 1200
      }
    ],
    "delinquent": [
      {
        "votePubkey": "delinquentVotePubkeyBase58",
        "nodePubkey": "delinquentNodePubkeyBase58",
        "activatedStake": 0,
        "commission": 10,
        "epochVoteAccount": false,
        "epochCredits": [[1, 500, 400]],
        "lastVote": 0,
        "rootSlot": 0
      }
    ]
  },
  "id": 1
}

Notes

• The current field contains details about vote accounts that are active and have current stake.
• The delinquent field contains details about vote accounts that have become delinquent due to inactivity or other issues.
• The epochCredits field contains historical voting data.

See Also

• getHealth, getIdentity, getVersion

pub fn get_leader_schedule( &self, options: Option<RpcLeaderScheduleConfigWrapper>, config: Option<RpcLeaderScheduleConfig>, ) -> impl Future<Output = RpcResult<Option<RpcLeaderSchedule>>>

Returns the leader schedule for the given configuration or slot.

This method retrieves the leader schedule for the given slot or configuration, providing a map of validator identities to slot indices within a given range.

Parameters

• meta: Metadata passed with the request, such as the client’s request context.
• options: Optional configuration wrapper, which can either be a specific slot or a full configuration.
• config: Optional configuration containing the validator identity and commitment level.

Returns

An Option<RpcLeaderSchedule> containing a map of leader identities (base-58 encoded pubkeys) to slot indices, relative to the first epoch slot.

Example Request

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

Example Response

{
  "jsonrpc": "2.0",
  "result": {
    "votePubkey1": [0, 2, 4],
    "votePubkey2": [1, 3, 5]
  },
  "id": 1
}

Notes

• The returned map contains validator identities as keys (base-58 encoded strings), with slot indices as values.

See Also

• getSlot, getBlockHeight, getEpochInfo

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.