> For the complete documentation index, see [llms.txt](https://docs.triton.one/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.triton.one/solana/sending-transactions/3rd-party-apis/jito-bundles.md).

# Jito Bundle Simulation

Test Jito bundles with simulateBundle on Triton's Jito-enabled RPC before you send them with sendBundle to the Jito Block Engine.

Triton supports Jito's `simulateBundle` method on every plan, so you can test atomic transaction bundles on a Jito-enabled RPC before submitting them. For more information, see the [Jito searcher examples](https://github.com/jito-labs/searcher-examples) and [Jito's low-latency transactions documentation](https://docs.jito.wtf/lowlatencytxnsend).

{% hint style="warning" %}
**Triton simulates Jito bundles but does not forward them.** `simulateBundle` runs on Triton's Jito-enabled RPC nodes. Submitting a bundle for inclusion uses `sendBundle`, a Jito-exclusive call that needs a direct, active connection to the Jito Block Engine.
{% endhint %}

## simulateBundle

Simulates a bundle of signed transactions against one bank and returns a result for each transaction. Send it as a JSON-RPC `POST` to your Triton endpoint.

### Parameters

| Position               | Type   | Description                                                                                                                                                              |
| ---------------------- | ------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `params[0]` (required) | object | `{ "encodedTransactions": [...] }`: the bundle, up to 20 signed transactions, each base64-encoded. Duplicate transactions are rejected.                                  |
| `params[1]`            | object | Optional `RpcSimulateBundleConfig` controlling the simulation. If you pass it, `preExecutionAccountsConfigs` and `postExecutionAccountsConfigs` are required. See below. |

### Example request

```bash
curl https://<your-endpoint>.mainnet.rpcpool.com/<your-token> -s -X POST \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "simulateBundle",
    "params": [
      { "encodedTransactions": ["BASE64_SIGNED_TX_1", "BASE64_SIGNED_TX_2"] },
      {
        "preExecutionAccountsConfigs": [null, null],
        "postExecutionAccountsConfigs": [null, { "addresses": ["ACCOUNT_ADDRESS"] }]
      }
    ]
  }'
```

Each entry in `preExecutionAccountsConfigs` and `postExecutionAccountsConfigs` belongs to the transaction at the same position: `null` returns no accounts for it, and `{ "addresses": [...] }` returns those accounts' state before or after it runs, base64-encoded.

### Response

The JSON-RPC `result` is `{ "context": { "slot": ... }, "value": ... }`, where `value` matches this Rust struct. JSON field names are camelCase (for example `transactionResults` and `unitsConsumed`), and `summary` is either `"succeeded"` or `{ "failed": { "error": ..., "tx_signature": ... } }`.

```rust
pub struct RpcSimulateBundleResult {
    pub summary: RpcBundleSimulationSummary,
    pub transaction_results: Vec<RpcSimulateBundleTransactionResult>,
}

pub enum RpcBundleSimulationSummary {
    // Error and offending transaction signature, if applicable.
    Failed {
        error: RpcBundleExecutionError,
        tx_signature: Option<String>,
    },
    Succeeded,
}

pub struct RpcSimulateBundleTransactionResult {
    pub err: Option<TransactionError>,
    pub logs: Option<Vec<String>>,
    pub pre_execution_accounts: Option<Vec<UiAccount>>,
    pub post_execution_accounts: Option<Vec<UiAccount>>,
    pub units_consumed: Option<u64>,
    pub loaded_accounts_data_size: Option<u32>,
    pub return_data: Option<UiTransactionReturnData>,
    // Set when replace_recent_blockhash is true: the blockhash the simulation used.
    pub replacement_blockhash: Option<RpcBlockhash>,
    pub fee: Option<u64>,
    pub pre_balances: Option<Vec<u64>>,
    pub post_balances: Option<Vec<u64>>,
    pub pre_token_balances: Option<Vec<UiTransactionTokenBalance>>,
    pub post_token_balances: Option<Vec<UiTransactionTokenBalance>>,
    pub loaded_addresses: Option<UiLoadedAddresses>,
}
```

<details>

<summary>RpcBundleExecutionError variants</summary>

```rust
pub enum RpcBundleExecutionError {
    BankProcessingTimeLimitReached,         // hit the max allotted processing time
    BundleLockError,                        // a transaction is malformed
    BundleExecutionTimeout,                 // bundle execution timed out
    ExceedsCostModel,                       // the bundle exceeds the cost model
    InvalidPreOrPostAccounts,               // invalid pre or post accounts
    PohRecordError(String),
    TipError(String),
    TransactionFailure(Signature, String),  // a transaction failed to execute
}
```

</details>

<details>

<summary>RpcSimulateBundleConfig</summary>

```rust
pub struct RpcSimulateBundleConfig {
    // Accounts to return before/after each transaction runs: one entry (or null) per
    // transaction. Required whenever you pass a config.
    pub pre_execution_accounts_configs: Vec<Option<RpcSimulateTransactionAccountsConfig>>,
    pub post_execution_accounts_configs: Vec<Option<RpcSimulateTransactionAccountsConfig>>,
    // Encoding of the contained transactions. Only base64 is accepted.
    pub transaction_encoding: Option<UiTransactionEncoding>,
    // Which bank to simulate against. Default: confirmed commitment.
    pub simulation_bank: Option<SimulationSlotConfig>,
    // Skip sig-verify for faster performance. Default: false.
    pub skip_sig_verify: bool,
    // Replace the recent blockhash to simulate old transactions without re-signing.
    // Requires skip_sig_verify: true. Default: false.
    pub replace_recent_blockhash: bool,
}

pub struct RpcSimulateTransactionAccountsConfig {
    pub encoding: Option<UiAccountEncoding>, // base64 only
    pub addresses: Vec<String>,
}
```

`simulationBank` accepts `{ "commitment": { "commitment": "processed" } }` (any commitment level), `{ "slot": <slot> }` for a specific slot's bank, or `"tip"` for the RPC's highest slot, the working bank.

</details>

## Billing

Simulating bundles on Triton's Jito-enabled RPC is billed as standard RPC. Current rates are on the [pricing page](https://triton.one/pricing). Submitting a bundle goes directly to the Jito Block Engine and is not billed by Triton.

## What's next

<table data-card-size="large" data-view="cards"><thead><tr><th></th><th></th><th data-hidden data-card-target data-type="content-ref"></th></tr></thead><tbody><tr><td><i class="fa-play">:play:</i> <strong>Quickstart</strong></td><td>Send a transaction via Triton endpoints in a few minutes.</td><td><a href="/solana/sending-transactions/quickstart.md">Sending transactions quickstart</a></td></tr><tr><td><i class="fa-list-check">:list-check:</i> <strong>Best practices</strong></td><td>Land your transactions fast and reliably.</td><td><a href="/solana/sending-transactions/best-practices.md">Sending transactions best practices</a></td></tr></tbody></table>

***

<i class="fa-life-ring">:life-ring:</i> Contact support by clicking the chat icon in your [customer dashboard](https://customers.triton.one)\ <i class="fa-briefcase">:briefcase:</i> Sales questions? [Contact us](https://triton.one/contact)\ <i class="fa-sparkles">:sparkles:</i> AI agent? Read [llms.txt](https://docs.triton.one/llms.txt)\ <i class="fa-rss">:rss:</i> Follow updates: [Blog](https://blog.triton.one) · [X](https://x.com/triton_one) · [YouTube](https://www.youtube.com/@triton_one_ltd) · [Telegram](https://t.me/tritonone) · [GitHub](https://github.com/rpcpool)