Struct RpcClient 

pub struct RpcClient { /* private fields */ }

The Client.

Implementations

impl Client

pub fn new(sender: RpcChannel) -> Self

Creates a new Client.

pub fn block_subscribe( &self, ) -> RpcResult<TypedSubscriptionStream<RpcResponse<()>>>

pub fn snapshot_subscribe( &self, snapshot_url: String, ) -> RpcResult<TypedSubscriptionStream<SnapshotImportNotification>>

Subscribe to snapshot import notifications via WebSocket.

This method allows clients to subscribe to real-time updates about snapshot import operations from a specific snapshot URL. The subscriber will receive notifications when the snapshot is being imported, including progress updates and completion status.

Parameters

• meta: WebSocket metadata containing RPC context and connection information.
• subscriber: The subscription sink for sending snapshot import notifications to the client.
• snapshot_url: The URL of the snapshot to import and monitor.

Returns

This method does not return a value directly. Instead, it establishes a continuous WebSocket subscription that will send SnapshotImportNotification notifications to the subscriber whenever the snapshot import operation status changes.

Example WebSocket Request

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "snapshotSubscribe",
  "params": ["https://example.com/snapshot.json"]
}

Example WebSocket Response (Subscription Confirmation)

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

Example WebSocket Notification

{
  "jsonrpc": "2.0",
  "method": "snapshotNotification",
  "params": {
    "result": {
      "snapshotId": "snapshot_20240107_123456",
      "status": "InProgress",
      "accountsLoaded": 1500,
      "totalAccounts": 3000,
      "error": null
    },
    "subscription": 12345
  }
}

Notes

• The subscription remains active until explicitly unsubscribed or the connection is closed.
• Multiple clients can subscribe to different snapshot notifications simultaneously.
• The snapshot URL must be accessible and contain a valid snapshot format.
• Each subscription runs in its own async task for optimal performance.

See Also

• snapshotUnsubscribe: Remove an active snapshot subscription

pub fn slots_updates_subscribe( &self, ) -> RpcResult<TypedSubscriptionStream<RpcResponse<()>>>

pub fn signature_subscribe( &self, signature_str: String, config: Option<RpcSignatureSubscribeConfig>, ) -> RpcResult<TypedSubscriptionStream<RpcResponse<RpcSignatureResult>>>

Subscribe to signature status notifications via WebSocket.

This method allows clients to subscribe to status updates for a specific transaction signature. The subscriber will receive notifications when the transaction reaches the desired confirmation level or when it’s initially received by the network (if configured).

Parameters

• meta: WebSocket metadata containing RPC context and connection information.
• subscriber: The subscription sink for sending signature status notifications to the client.
• signature_str: The transaction signature to monitor, as a base-58 encoded string.
• config: Optional configuration specifying commitment level and notification preferences.

Returns

This method does not return a value directly. Instead, it establishes a WebSocket subscription that will send RpcResponse<RpcSignatureResult> notifications to the subscriber when the transaction status changes.

Example WebSocket Request

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "signatureSubscribe",
  "params": [
    "2id3YC2jK9G5Wo2phDx4gJVAew8DcY5NAojnVuao8rkxwPYPe8cSwE5GzhEgJA2y8fVjDEo6iR6ykBvDxrTQrtpb",
    {
      "commitment": "finalized",
      "enableReceivedNotification": false
    }
  ]
}

Example WebSocket Response (Subscription Confirmation)

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

Example WebSocket Notification

{
  "jsonrpc": "2.0",
  "method": "signatureNotification",
  "params": {
    "result": {
      "context": {
        "slot": 5207624
      },
      "value": {
        "err": null
      }
    },
    "subscription": 0
  }
}

Notes

• If the transaction already exists with the desired confirmation status, the subscriber will be notified immediately and the subscription will complete.
• The subscription automatically terminates after sending the first matching notification.
• Invalid signature formats will cause the subscription to be rejected with an error.
• Each subscription runs in its own async task for optimal performance.

See Also

• signatureUnsubscribe: Remove an active signature subscription
• getSignatureStatuses: Get current status of multiple signatures

pub fn vote_subscribe( &self, ) -> RpcResult<TypedSubscriptionStream<RpcResponse<()>>>

pub fn account_subscribe( &self, pubkey_str: String, config: Option<RpcAccountSubscribeConfig>, ) -> RpcResult<TypedSubscriptionStream<RpcResponse<UiAccount>>>

Subscribe to account change notifications via WebSocket.

This method allows clients to subscribe to updates for a specific account. The subscriber will receive notifications whenever the account’s data, lamports balance, ownership, or other properties change.

Parameters

• meta: WebSocket metadata containing RPC context and connection information.
• subscriber: The subscription sink for sending account update notifications to the client.
• pubkey_str: The account public key to monitor, as a base-58 encoded string.
• config: Optional configuration specifying commitment level and encoding format for account data.

Returns

This method does not return a value directly. Instead, it establishes a continuous WebSocket subscription that will send RpcResponse<UiAccount> notifications to the subscriber whenever the account state changes.

Example WebSocket Request

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "accountSubscribe",
  "params": [
    "CM78CPUeXjn8o3yroDHxUtKsZZgoy4GPkPPXfouKNH12",
    {
      "commitment": "finalized",
      "encoding": "base64"
    }
  ]
}

Example WebSocket Response (Subscription Confirmation)

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

Example WebSocket Notification

{
  "jsonrpc": "2.0",
  "method": "accountNotification",
  "params": {
    "result": {
      "context": {
        "slot": 5208469
      },
      "value": {
        "data": ["base64EncodedAccountData", "base64"],
        "executable": false,
        "lamports": 33594,
        "owner": "11111111111111111111111111111112",
        "rentEpoch": 636
      }
    },
    "subscription": 23784
  }
}

Notes

• The subscription remains active until explicitly unsubscribed or the connection is closed.
• Account notifications are sent whenever any aspect of the account changes.
• The encoding format specified in the config determines how account data is serialized.
• Invalid public key formats will cause the subscription to be rejected with an error.
• Each subscription runs in its own async task to ensure optimal performance.

See Also

• accountUnsubscribe: Remove an active account subscription
• getAccountInfo: Get current account information

pub fn root_subscribe( &self, ) -> RpcResult<TypedSubscriptionStream<RpcResponse<()>>>

pub fn logs_subscribe( &self, mentions: Option<RpcTransactionLogsFilter>, commitment: Option<CommitmentConfig>, ) -> RpcResult<TypedSubscriptionStream<RpcResponse<RpcLogsResponse>>>

Subscribe to logs notifications.

This method allows clients to subscribe to transaction log messages emitted during transaction execution. It supports filtering by signature, account mentions, or all transactions.

Parameters

• meta: WebSocket metadata containing RPC context and connection information.
• subscriber: The subscription sink for sending log notifications to the client.
• mentions: Optional filter for the subscription: can be a specific signature, account, or "all".
• commitment: Optional commitment level for filtering logs by block finality.

Returns

This method establishes a continuous WebSocket subscription that streams RpcLogsResponse notifications as new transactions are processed.

Example WebSocket Request

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "logsSubscribe",
  "params": [
    {
      "mentions": ["11111111111111111111111111111111"]
    },
    {
      "commitment": "finalized"
    }
  ]
}

Example WebSocket Response (Subscription Confirmation)

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

Example WebSocket Notification

{
  "jsonrpc": "2.0",
  "method": "logsNotification",
  "params": {
    "result": {
      "signature": "3s6n...",
      "err": null,
      "logs": ["Program 111111... invoke [1]", "Program 111111... success"]
    },
    "subscription": 42
  }
}

Notes

• The subscription remains active until explicitly unsubscribed or the connection is closed.
• Each log subscription runs independently and supports filtering.
• Log messages may be truncated depending on cluster configuration.

See Also

• logsUnsubscribe: Remove an active logs subscription.

pub fn program_subscribe( &self, pubkey_str: String, config: Option<RpcProgramSubscribeConfig>, ) -> RpcResult<TypedSubscriptionStream<RpcResponse<RpcKeyedAccount>>>

Subscribe to notifications for all accounts owned by a specific program via WebSocket.

This method allows clients to subscribe to updates for any account whose owner matches the given program ID. Notifications are sent whenever an account owned by the program is created, updated, or deleted.

Parameters

• meta: WebSocket metadata containing RPC context and connection information.
• subscriber: The subscription sink for sending program account notifications to the client.
• pubkey_str: The program public key to monitor, as a base-58 encoded string.
• config: Optional configuration specifying commitment level, encoding format, and filters.

Returns

This method does not return a value directly. Instead, it establishes a continuous WebSocket subscription that will send RpcResponse<RpcKeyedAccount> notifications to the subscriber whenever an account owned by the program changes.

Filters

The optional config may include filters to narrow which account updates trigger notifications:

• dataSize: Only notify for accounts with a specific data length (in bytes).
• memcmp: Only notify for accounts whose data matches specific bytes at a given offset.

Example WebSocket Request

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "programSubscribe",
  "params": [
    "11111111111111111111111111111111",
    {
      "encoding": "base64",
      "filters": [
        { "dataSize": 80 }
      ]
    }
  ]
}

Example WebSocket Response (Subscription Confirmation)

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

Example WebSocket Notification

{
  "jsonrpc": "2.0",
  "method": "programNotification",
  "params": {
    "result": {
      "context": { "slot": 5208469 },
      "value": {
        "pubkey": "H4vnBqifaSACnKa7acsxstsY1iV1bvJNxsCY7enrd1hq",
        "account": {
          "data": ["base64data", "base64"],
          "executable": false,
          "lamports": 33594,
          "owner": "11111111111111111111111111111111",
          "rentEpoch": 636,
          "space": 36
        }
      }
    },
    "subscription": 24040
  }
}

Notes

• The subscription remains active until explicitly unsubscribed or the connection is closed.
• Notifications include both the account pubkey and the full account data.
• Invalid public key formats will cause the subscription to be rejected with an error.
• Each subscription runs in its own async task for optimal performance.

See Also

• programUnsubscribe: Remove an active program subscription
• getProgramAccounts: Get current accounts for a program

pub fn slot_subscribe(&self) -> RpcResult<TypedSubscriptionStream<SlotInfo>>

Subscribe to slot notifications.

This method allows clients to subscribe to updates for a specific slot. The subscriber will receive notifications whenever the slot changes.

Parameters

• meta: WebSocket metadata containing RPC context and connection information.
• subscriber: The subscription sink for sending slot update notifications to the client.

Returns

This method does not return a value directly. Instead, it establishes a continuous WebSocket subscription that will send SlotInfo notifications to the subscriber whenever the slot changes.

Example WebSocket Request

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "slotSubscribe",
  "params": [
    {
      "commitment": "finalized"
    }
  ]
}

Example WebSocket Response (Subscription Confirmation)

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

Example WebSocket Notification

{
  "jsonrpc": "2.0",
  "method": "slotNotification",
  "params": {
    "result": {
      "slot": 5207624
    },
    "subscription": 5207624
  }
}

Notes

• The subscription remains active until explicitly unsubscribed or the connection is closed.
• Slot notifications are sent whenever the slot changes.
• The subscription automatically terminates when the slot changes.
• Each subscription runs in its own async task for optimal performance.

See Also

• slotUnsubscribe: Remove an active slot subscription

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.