Documentation index

RPC Proxy

The Slipstream SDK proxies Solana RPC methods and provides transaction/bundle simulation, so you can query chain state and simulate without a separate RPC connection. Costs 1 token per call.

Generic RPC Call

Pass any Solana RPC method name and params directly.

Generic RPC — Rust

Rust

use serde_json::json;

let response = client.rpc("getBalance", json!(["YOUR_WALLET_ADDRESS"])).await?;
if let Some(result) = response.result {
    println!("Balance: {}", result);
}
if let Some(err) = response.error {
    println!("RPC error {}: {}", err.code, err.message);
}

Generic RPC — TypeScript

TypeScript

const response = await client.rpc("getBalance", ["YOUR_WALLET_ADDRESS"]);
console.log("Balance:", response.result);

Generic RPC — Python

Python

response = await client.rpc("getBalance", ["YOUR_WALLET_ADDRESS"])
print(f"Balance: {response.result}")

Common Methods

Any standard Solana JSON-RPC method can be called through rpc(). Common examples:

Rust

// Get balance
let bal = client.rpc("getBalance", json!(["WALLET_ADDRESS"])).await?;

// Get latest blockhash
let bh = client.rpc("getLatestBlockhash", json!([])).await?;

// Get slot
let slot = client.rpc("getSlot", json!([])).await?;

// Get account info
let acct = client.rpc("getAccountInfo", json!(["ACCOUNT_ADDRESS"])).await?;

// Get transaction
let tx = client.rpc("getTransaction", json!(["SIGNATURE"])).await?;

// Get signature statuses
let statuses = client.rpc("getSignatureStatuses", json!([["SIG1", "SIG2"]])).await?;

Transaction Simulation

Simulate a transaction before submitting.

Simulate TX — Rust

Rust

let sim = client.simulate_transaction(&tx_bytes).await?;
if let Some(err) = &sim.err {
    println!("Simulation failed: {:?}", err);
}
println!("CUs consumed: {}", sim.units_consumed);
for log in &sim.logs {
    println!("  {}", log);
}
if let Some(return_data) = &sim.return_data {
    println!("Return data: {:?}", return_data);
}

Simulate TX — TypeScript

TypeScript

const sim = await client.simulateTransaction(txBytes);
if (sim.err) console.log("Simulation failed:", sim.err);
console.log("CUs consumed:", sim.unitsConsumed);
sim.logs.forEach(log => console.log(" ", log));

Simulate TX — Python

Python

sim = await client.simulate_transaction(tx_bytes)
if sim.err:
    print(f"Simulation failed: {sim.err}")
print(f"CUs consumed: {sim.units_consumed}")
for log in sim.logs:
    print(f"  {log}")

Bundle Simulation

Simulate all transactions in a bundle. Costs 1 token per transaction.

Simulate Bundle — Rust

Rust

let results = client.simulate_bundle(&[tx1_bytes, tx2_bytes]).await?;
for (i, sim) in results.iter().enumerate() {
    println!("TX {}: {} CUs, err={:?}", i, sim.units_consumed, sim.err);
}

Simulate Bundle — TypeScript

TypeScript

const results = await client.simulateBundle([tx1Bytes, tx2Bytes]);
results.forEach((sim, i) => {
    console.log(`TX ${i}: ${sim.unitsConsumed} CUs, err=${sim.err}`);
});

Simulate Bundle — Python

Python

results = await client.simulate_bundle([tx1_bytes, tx2_bytes])
for i, sim in enumerate(results):
    print(f"TX {i}: {sim.units_consumed} CUs, err={sim.err}")

SimulationResult Fields

Field	Type	Description
`err`	any?	Error if simulation failed
`logs`	string[]	Program logs
`units_consumed`	number	Compute units consumed
`return_data`	any?	Return data from program

RpcResponse Fields

Field	Type	Description
`jsonrpc`	string	JSON-RPC version
`id`	any	Request ID
`result`	any?	Successful result
`error`	RpcError?	Error with code, message, data

Next Steps

Transactions — Submit transactions
Bundles — Atomic bundles with simulation
Billing & Tokens — Token pricing details