simulateTransaction

simulateTransaction runs a transaction against the current bank state and returns the result it would produce if submitted, without ever broadcasting it. Use it to pre-flight a transaction: confirm it would succeed, read the program logs it would emit, measure the compute units it would consume, and inspect the post-execution state of selected accounts.

This is the right call before sendTransaction when you want to surface errors to the user, estimate a compute-unit budget, or decode a program's return data without paying fees. Because simulation reflects live bank state, the result is advisory — a transaction that simulates cleanly can still fail on submission if state changes in the interim.

By default the transaction's recent blockhash must be valid for simulation to succeed. Set replaceRecentBlockhash: true to have the node substitute the most recent blockhash before simulating, which lets you simulate a transaction whose own blockhash has already expired.

Tier note: this method belongs to the sol_sim_bundle category and is available on pro and business tiers only. Free- and basic-tier keys receive a -32002 tier-insufficient error.

JSON-RPC params is a positional array: [transaction, config?].

Response fields

Each entry in result.value.accounts is an AccountInfo object with data, executable, lamports, owner, rentEpoch, and space fields.

Errors are returned in the standard JSON-RPC error envelope. See the shared errors reference for the full envelope shape and shared codes.

A failing simulation (e.g. an instruction error) is not a JSON-RPC error: the request returns 200 with result.value.err populated and the relevant logs.

JavaScript (fetch)

const tx = "AVXo5X7UMtwHFeqHfwopBLrCftbS5UfPiDoXNi8gO1r..."; // base64-encoded tx


const res = await fetch("https://api.triport.io/v1/sol", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.TRIPORT_API_KEY}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    jsonrpc: "2.0",
    id: 1,
    method: "simulateTransaction",
    params: [tx, { encoding: "base64", replaceRecentBlockhash: true }],
  }),
});


const { result } = await res.json();
if (result.value.err) {
  console.error("Simulation failed:", result.value.err, result.value.logs);
} else {
  console.log(`OK — ${result.value.unitsConsumed} compute units consumed`);
}

TypeScript SDK (@triport/sdk)

import { TriportClient } from "@triport/sdk";


const client = new TriportClient({ apiKey: process.env.TRIPORT_API_KEY });


const { value } = await client.solana.simulateTransaction(tx, {
  encoding: "base64",
  replaceRecentBlockhash: true,
  commitment: "processed",
});


if (value.err) {
  throw new Error(`Simulation failed: ${JSON.stringify(value.err)}`);
}
console.log(`Compute units: ${value.unitsConsumed}`);

Python (triport-sdk)

import os
from triport import TriportClient


client = TriportClient(api_key=os.environ["TRIPORT_API_KEY"])


result = client.solana.simulate_transaction(
    tx,
    encoding="base64",
    replace_recent_blockhash=True,
    commitment="processed",
)


value = result["value"]
if value["err"] is not None:
    raise RuntimeError(f"Simulation failed: {value['err']}")
print(f"Compute units: {value['unitsConsumed']}")

• sigVerify vs replaceRecentBlockhash: these are mutually exclusive. Set sigVerify: true only when you have a fully signed transaction and want the signatures checked; use replaceRecentBlockhash: true to simulate an unsigned or stale-blockhash transaction.
• Compute budgeting: read value.unitsConsumed to size a ComputeBudget instruction before submitting the real transaction with sendTransaction.
• Reading account state: pass config.accounts.addresses to get the post-execution AccountInfo for specific accounts — useful for verifying the effect of a transaction before broadcasting it.
• Advisory result: a clean simulation does not guarantee on-chain success; state can change between simulation and submission.
• Related methods: sendTransaction to submit, getFeeForMessage to price a message, and the bundle simulation methods for multi-transaction pre-flight.