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).

pub fn simulate_bundle( &self, rpc_bundle_request: RpcBundleRequest, config: Option<RpcSimulateBundleConfig>, ) -> impl Future<Output = RpcResult<RpcResponse<RpcSimulateBundleResult>>>

Simulates a bundle of transactions sequentially against an isolated sandbox VM, without committing any of the resulting state changes onto the live VM.

This is the read-only counterpart to Self::send_bundle. Where send_bundle is all-or-nothing (every tx must succeed; on full success the sandbox is committed), simulate_bundle is all-tx-attempted-or-fail-fast: each transaction is processed in order against the sandbox, with subsequent transactions seeing the previous tx’s state mutations, but the moment one transaction errors the loop exits and remaining transactions are not simulated. The sandbox is always discarded — successful or not — so the live VM is byte-identical to its pre-call state regardless of outcome.

Per-tx the response carries:

• err: None on success, the typed TransactionError on failure.
• logs: program logs the SVM emitted while executing the tx.
• units_consumed: compute units burned.
• pre_execution_accounts / post_execution_accounts: pre/post snapshot of the accounts whose pubkeys the caller listed in RpcSimulateBundleConfig.{pre,post}_execution_accounts_configs[i]. Returned in UiAccountEncoding::Base64 (the only encoding simulateBundle supports — the request is rejected with invalid_params for any other encoding hint).
• replacement_blockhash: the bank’s latest blockhash, but only when replace_recent_blockhash is true.
• return_data: the program return data, when present.

The remaining fields on RpcSimulateBundleTransactionResult (pre_token_balances, post_token_balances, loaded_addresses, loaded_accounts_data_size, fee, pre_balances, post_balances) are returned as None. This matches Surfpool’s existing single-tx simulateTransaction behavior; populating them requires layout decoding of SPL Token accounts that has not yet been done on either path. Tracked for a follow-up PR.

Parameters

• rpc_bundle_request: Wrapper struct carrying the array of base64-encoded transactions. Mirrors Jito’s wire format.
• config: Optional. When omitted the bundle simulates with no pre/post account snapshots, sigverify on, and the originally-encoded blockhashes preserved. When replace_recent_blockhash is true, skip_sig_verify MUST also be true (a resigned blockhash invalidates any pre-existing signature) — the request is otherwise rejected with invalid_params.

Returns

RpcResponse<RpcSimulateBundleResult> — the standard Solana contextualized response shape. value.summary is Succeeded when every transaction in the bundle simulated cleanly, otherwise Failed { error, tx_signature } where error carries the typed RpcBundleExecutionError::TransactionFailure(signature, message) for the first failing tx. value.transaction_results[i] corresponds to rpc_bundle_request.encoded_transactions[i]; on early-exit failure the trailing indices contain the empty/skipped tx result (err: None, logs: None, etc.) — they were never simulated.

Example Request (JSON-RPC)

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "simulateBundle",
  "params": [
    { "encodedTransactions": ["base64Tx1", "base64Tx2"] },
    {
      "preExecutionAccountsConfigs": [null, { "addresses": ["..."] }],
      "postExecutionAccountsConfigs": [null, { "addresses": ["..."] }],
      "skipSigVerify": true,
      "replaceRecentBlockhash": true
    }
  ]
}

Notes

• Bundles are limited to a maximum of [MAX_BUNDLE_SIZE] (5) transactions, matching sendBundle and Jito’s documented limit.
• pre_execution_accounts_configs and post_execution_accounts_configs, when provided, MUST have the same length as the bundle.
• simulation_bank is accepted for API parity; Surfpool always simulates against the working SVM regardless of value.
• The sandbox’s storage overlays, buffered Geyser/Simnet events, and cloned LiteSVM state are dropped at end-of-call. No notification fires on the live event channels; no signature/logs subscriber is woken; no chain state is touched.

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.