Bundles

Submit 2-5 transactions as an atomic bundle. All transactions execute in order, or none do. Costs 5 tokens (0.00025 SOL) per bundle regardless of transaction count.

submit_bundle

Bundle — Rust

1// Basic bundle submission
2let transactions: Vec<Vec<u8>> = vec![tx1_bytes, tx2_bytes, tx3_bytes];
3let result = client.submit_bundle(&transactions).await?;
4
5println!("Bundle ID: {}", result.bundle_id);
6println!("Accepted: {}", result.accepted);
7for sig in &result.signatures {
8    println!("  TX: {}", sig);
9}

Bundle — TypeScript

1const transactions = [tx1Bytes, tx2Bytes, tx3Bytes];
2const result = await client.submitBundle(transactions);
3
4console.log("Bundle ID:", result.bundleId);
5console.log("Accepted:", result.accepted);
6for (const sig of result.signatures) {
7    console.log("  TX:", sig);
8}

Bundle — Python

1transactions = [tx1_bytes, tx2_bytes, tx3_bytes]
2result = await client.submit_bundle(transactions)
3
4print(f"Bundle ID: {result.bundle_id}")
5print(f"Accepted: {result.accepted}")
6for sig in result.signatures:
7    print(f"  TX: {sig}")

Bundle with Tip

You can specify a tip amount in lamports for priority inclusion.

Tipped Bundle — Rust

1let result = client.submit_bundle_with_tip(
2    &transactions,
3    Some(10_000), // 0.00001 SOL tip in lamports
4).await?;

Tipped Bundle — TypeScript

1const result = await client.submitBundle(transactions, 10_000); // tip in lamports

Tipped Bundle — Python

1result = await client.submit_bundle(transactions, tip_lamports=10_000)

Bundle Rules

  • Minimum: 2 transactions
  • Maximum: 5 transactions
  • Execution: Ordered, atomic — all or nothing
  • Cost: 5 tokens (0.00025 SOL) per bundle, regardless of tx count
  • Tip: Optional, specified in lamports for priority inclusion

BundleResult Fields

FieldTypeDescription
bundle_idstringUnique bundle identifier
acceptedbooleanWhether the bundle was accepted
signaturesstring[]Transaction signatures in order
sender_idstring?Sender used for routing
errorstring?Error message if rejected

Bundle Simulation

Simulate a bundle before submitting to check for errors.

Simulate — Rust

1let results = client.simulate_bundle(&transactions).await?;
2for sim in &results {
3    if let Some(err) = &sim.err {
4        println!("Simulation error: {:?}", err);
5    }
6    println!("CUs consumed: {}", sim.units_consumed);
7    for log in &sim.logs {
8        println!("  {}", log);
9    }
10}

Simulate — TypeScript

1const results = await client.simulateBundle(transactions);
2for (const sim of results) {
3    if (sim.err) console.log("Simulation error:", sim.err);
4    console.log("CUs consumed:", sim.unitsConsumed);
5    sim.logs.forEach(log => console.log(" ", log));
6}

Simulate — Python

1results = await client.simulate_bundle(transactions)
2for sim in results:
3    if sim.err:
4        print(f"Simulation error: {sim.err}")
5    print(f"CUs consumed: {sim.units_consumed}")
6    for log in sim.logs:
7        print(f"  {log}")

Tip Wallet Discovery

Get available senders and their tip wallets via the SDK.

Discover Tips — Rust

1let senders = client.get_senders().await?;
2for sender in &senders {
3    println!("{}: {} tip wallets", sender.display_name, sender.tip_wallets.len());
4    for tier in &sender.tip_tiers {
5        println!("  {} — {} SOL, ~{}ms latency",
6            tier.name, tier.amount_sol, tier.expected_latency_ms);
7    }
8}

Discover Tips — TypeScript

1const senders = await client.getSenders();
2for (const sender of senders) {
3    console.log(`${sender.displayName}: ${sender.tipWallets.length} tip wallets`);
4    for (const tier of sender.tipTiers) {
5        console.log(`  ${tier.name} — ${tier.amountSol} SOL, ~${tier.expectedLatencyMs}ms`);
6    }
7}

Next Steps

PreviousTransactionsNextReal-Time Streams