Struct Client 

pub struct Client { /* private fields */ }

The Client.

Implementations

impl Client

pub fn new(sender: RpcChannel) -> Self

Creates a new Client.

pub fn send_bundle( &self, transactions: Vec<String>, config: Option<RpcSendTransactionConfig>, ) -> impl Future<Output = RpcResult<String>>

Sends a bundle of transactions to be processed atomically.

This RPC method accepts a bundle of transactions (Jito-compatible format) and processes them one by one in order against an isolated sandbox VM. The bundle is all-or-nothing: if any transaction in the bundle fails (simulation error, execution error, or verification error), every other transaction’s effects are discarded and the underlying VM is left byte-identical to its pre-bundle state. No Geyser event, no Simnet event, and no WebSocket subscriber notification is dispatched for a bundle that fails.

On full success, the sandbox’s state changes — account mutations, transaction storage writes, token-account index updates, write-version increments, etc. — are atomically committed onto the original VM under an exclusive writer guard, and Geyser/Simnet events plus WebSocket subscriber notifications (account, program, signature, logs) are fired onto the live event channels exactly as if each transaction had been submitted through the regular sendTransaction RPC.

Parameters

• transactions: An array of serialized transaction data (base64 or base58 encoded).
• config: Optional configuration for encoding format.

Returns

• BoxFuture<Result<String>>: A future resolving to the bundle ID (SHA-256 hash of comma-separated signatures), or an error if any transaction in the bundle fails. Returning a future (rather than blocking) lets the JSON-RPC runtime drive the async sandbox execution without spawning a nested tokio runtime on an HTTP worker thread.

Example Request (JSON-RPC)

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "sendBundle",
  "params": [
    ["base64EncodedTx1", "base64EncodedTx2"],
    { "encoding": "base64" }
  ]
}

Notes

• Bundles are limited to a maximum of 5 transactions, matching Jito’s limit.
• Transactions are processed sequentially in the order provided against a single sandbox.
• Atomicity is guaranteed: on any failure the original VM is unaffected.
• The bundle ID is calculated as SHA-256 hash of comma-separated transaction signatures.

pub fn get_bundle_statuses( &self, bundle_ids: Vec<String>, ) -> impl Future<Output = RpcResult<RpcResponse<Vec<Option<JitoBundleStatus>>>>>

Retrieves Jito-shaped status summaries for one or more previously submitted bundles.

Mirrors Jito’s wire protocol: the first positional parameter is an array of bundle IDs (max [MAX_BUNDLES_PER_QUERY]). For each requested id we resolve per-signature status via the same path as getSignatureStatuses and return a single aggregate status object per bundle, or null at that index when the bundle is unknown locally.

Parameters

• bundle_ids: Array of bundle identifiers returned by sendBundle. May contain up to [MAX_BUNDLES_PER_QUERY] entries; the empty array is rejected with invalid_params.

Returns

On success, the JSON-RPC result is the standard Solana contextualized response shape:

• context.slot: Context slot from the underlying status query (same idea as getSignatureStatuses).
• value: An array with exactly one element per input bundle id, at the same index:
  • null when the bundle id is not known locally (no stored signatures — the id may be valid elsewhere, we simply have nothing to report).
  • A surfpool_types::JitoBundleStatus object otherwise, with:
    • bundle_id: The requested bundle id (snake_case wire field).
    • transactions: Base-58 signatures in bundle submission order (from local jito_bundles storage).
    • slot: Slot from the first per-signature status entry (bundle txs share a landing slot), or 0 if none yet.
    • confirmation_status: From that same first entry (defaults to processed when absent).
    • err: Ok if no transaction error was observed on any status; otherwise the first Err encountered (JSON-serialized like other Solana Result values, e.g. {"Ok": null} or {"Err": ...}).

Example Request (JSON-RPC)

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "getBundleStatuses",
  "params": [
    ["bundleIdHere", "anotherBundleId"]
  ]
}

Example Response (JSON-RPC)

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "context": { "slot": 242806119 },
    "value": [
      {
        "bundle_id": "892b79ed49138bfb3aa5441f0df6e06ef34f9ee8f3976c15b323605bae0cf51d",
        "transactions": [
          "3bC2M9fiACSjkTXZDgeNAuQ4ScTsdKGwR42ytFdhUvikqTmBheUxfsR1fDVsM5ADCMMspuwGkdm1uKbU246x5aE3",
          "8t9hKYEYNbLvNqiSzP96S13XF1C2f1ro271Kdf7bkZ6EpjPLuDff1ywRy4gfaGSTubsM2FeYGDoT64ZwPm1cQUt"
        ],
        "slot": 242804011,
        "confirmation_status": "finalized",
        "err": { "Ok": null }
      },
      null
    ]
  }
}

Notes

• Bundles are stored locally as a mapping from bundle_id to a list of base-58 signatures.
• Unknown bundle ids appear as null inside the value array; the outer result is never null (Jito-style: per-index reporting).
• Per-signature status resolution uses the same logic as getSignatureStatuses (local store and optional remote datasource).

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.