Submit Batched Transactions

Submit 2-4 transactions as an atomic bundle to NextBlock using Rust. Batched transactions are processed as Jito bundles - either all transactions succeed, or none do.

This example shows bundle construction and the request shape you send to NextBlock. Replace the placeholder generated client types with the client generated from nextblock-proto.

Example

use solana_sdk::{
    instruction::Instruction,
    message::Message,
    pubkey::Pubkey,
    signature::{Keypair, Signature, Signer},
    system_instruction,
    transaction::Transaction,
    hash::Hash,
};
use solana_client::rpc_client::RpcClient;
use rand::seq::SliceRandom;
use std::str::FromStr;

// NextBlock tip wallets
const NEXTBLOCK_TIP_WALLETS: [&str; 8] = [
    "NEXTbLoCkB51HpLBLojQfpyVAMorm3zzKg7w9NFdqid",
    "nextBLoCkPMgmG8ZgJtABeScP35qLa2AMCNKntAP7Xc",
    "NextbLoCkVtMGcV47JzewQdvBpLqT9TxQFozQkN98pE", 
    "NexTbLoCkWykbLuB1NkjXgFWkX9oAtcoagQegygXXA2",
    "NeXTBLoCKs9F1y5PJS9CKrFNNLU1keHW71rfh7KgA1X",
    "NexTBLockJYZ7QD7p2byrUa6df8ndV2WSd8GkbWqfbb",
    "neXtBLock1LeC67jYd1QdAa32kbVeubsfPNTJC1V5At",
    "nEXTBLockYgngeRmRrjDV31mGSekVPqZoMGhQEZtPVG",
];

// Transaction builder for bundle
struct TransactionBundle {
    transactions: Vec<Transaction>,
}

impl TransactionBundle {
    fn new() -> Self {
        Self {
            transactions: Vec::new(),
        }
    }
    
    // Add transaction to bundle
    fn add_transaction(&mut self, transaction: Transaction) -> Self {
        self.transactions.push(transaction);
        self
    }
    
    // Get transactions as base64 strings
    fn to_base64_transactions(&self) -> Result<Vec<String>, Box<dyn std::error::Error>> {
        self.transactions
            .iter()
            .map(|tx| {
                let serialized = bincode::serialize(tx)?;
                Ok(base64::encode(serialized))
            })
            .collect()
    }
}

// Build single transaction with tip
fn build_transaction_with_tip(
    payer: &Keypair,
    recent_blockhash: Hash,
    tip_amount: u64,
    instructions: Vec<Instruction>,
) -> Result<Transaction, Box<dyn std::error::Error>> {
    let mut rng = rand::thread_rng();
    let tip_wallet_str = NEXTBLOCK_TIP_WALLETS.choose(&mut rng)
        .ok_or("No tip wallets available")?;
    let tip_wallet = Pubkey::from_str(tip_wallet_str)?;
    
    // Create tip instruction (should be first)
    let tip_instruction = system_instruction::transfer(
        &payer.pubkey(),
        &tip_wallet,
        tip_amount,
    );
    
    // Combine instructions
    let mut all_instructions = vec![tip_instruction];
    all_instructions.extend(instructions);
    
    // Build and sign transaction
    let message = Message::new(&all_instructions, Some(&payer.pubkey()));
    let mut transaction = Transaction::new_unsigned(message);
    transaction.sign(&[payer], recent_blockhash);
    
    Ok(transaction)
}

// Submit batched transactions
async fn submit_batched_transactions(
    // nextblock_client: &mut YourGeneratedApiClient,
    rpc_client: &RpcClient,
    signer: &Keypair,
) -> Result<String, Box<dyn std::error::Error>> {
    // Get recent blockhash (same for all transactions in bundle)
    let recent_blockhash = rpc_client.get_latest_blockhash()?;
    
    // Build transaction bundle
    let mut bundle = TransactionBundle::new();
    
    // Transaction 1: Setup transaction
    let setup_instructions = vec![
        system_instruction::transfer(
            &signer.pubkey(),
            &Pubkey::from_str("<recipient1-public-key>")?,
            100_000, // 0.0001 SOL
        ),
    ];
    
    let setup_tx = build_transaction_with_tip(
        signer,
        recent_blockhash,
        500_000, // 0.0005 SOL tip
        setup_instructions,
    )?;
    bundle = bundle.add_transaction(setup_tx);
    
    // Transaction 2: Main operation
    let main_instructions = vec![
        system_instruction::transfer(
            &signer.pubkey(),
            &Pubkey::from_str("<recipient2-public-key>")?,
            200_000, // 0.0002 SOL
        ),
    ];
    
    let main_tx = build_transaction_with_tip(
        signer,
        recent_blockhash,
        1_000_000, // 0.001 SOL tip (higher for main transaction)
        main_instructions,
    )?;
    bundle = bundle.add_transaction(main_tx);
    
    // Transaction 3: Cleanup transaction
    let cleanup_instructions = vec![
        system_instruction::transfer(
            &signer.pubkey(),
            &Pubkey::from_str("<recipient3-public-key>")?,
            50_000, // 0.00005 SOL
        ),
    ];
    
    let cleanup_tx = build_transaction_with_tip(
        signer,
        recent_blockhash,
        500_000, // 0.0005 SOL tip
        cleanup_instructions,
    )?;
    bundle = bundle.add_transaction(cleanup_tx);
    
    // Convert to base64 for submission
    let base64_transactions = bundle.to_base64_transactions()?;
    
    // Print transaction signatures for tracking
    for (i, tx) in bundle.transactions.iter().enumerate() {
        println!("Transaction {} signature: {}", i + 1, tx.signatures[0]);
    }
    
    // Submit bundle to NextBlock
    /* Uncomment when you have the generated API client
    let entries: Vec<PostSubmitRequestEntry> = base64_transactions
        .into_iter()
        .map(|tx_base64| PostSubmitRequestEntry {
            transaction: Some(TransactionMessage {
                content: tx_base64,
            }),
        })
        .collect();
    
    let request = tonic::Request::new(PostSubmitBatchRequest {
        entries,
    });
    
    let response = nextblock_client.post_submit_batch_v2(request).await?;
    let submit_response = response.into_inner();
    
    println!("Batch submitted successfully!");
    println!("Bundle signature: {}", submit_response.signature);
    
    Ok(submit_response.signature)
    */
    
    println!("Local bundle prepared with {} transactions.", bundle.transactions.len());
    Ok("".to_string())
}

Arbitrage Bundle Example

// Example: Build arbitrage bundle
async fn build_arbitrage_bundle(
    // nextblock_client: &mut YourGeneratedApiClient,
    rpc_client: &RpcClient,
    signer: &Keypair,
    dex_a_address: Pubkey,
    dex_b_address: Pubkey,
    trade_amount: u64,
) -> Result<String, Box<dyn std::error::Error>> {
    let recent_blockhash = rpc_client.get_latest_blockhash()?;
    let mut bundle = TransactionBundle::new();
    
    // Transaction 1: Buy on DEX A
    let buy_instructions = vec![
        // Add your DEX-specific buy instructions here
        system_instruction::transfer(
            &signer.pubkey(),
            &dex_a_address,
            trade_amount,
        ),
    ];
    
    let buy_tx = build_transaction_with_tip(
        signer,
        recent_blockhash,
        2_000_000, // Higher tip for arbitrage
        buy_instructions,
    )?;
    bundle = bundle.add_transaction(buy_tx);
    
    // Transaction 2: Sell on DEX B
    let sell_instructions = vec![
        // Add your DEX-specific sell instructions here
        system_instruction::transfer(
            &signer.pubkey(),
            &dex_b_address,
            trade_amount,
        ),
    ];
    
    let sell_tx = build_transaction_with_tip(
        signer,
        recent_blockhash,
        2_000_000, // Higher tip for arbitrage
        sell_instructions,
    )?;
    bundle = bundle.add_transaction(sell_tx);
    
    println!("Arbitrage bundle prepared with {} transactions", bundle.transactions.len());
    
    // Submit the bundle
    // Implementation similar to submit_batched_transactions
    Ok("".to_string())
}

Complex DeFi Bundle Example

// Example: Complex DeFi operation bundle
async fn build_defi_operation_bundle(
    // nextblock_client: &mut YourGeneratedApiClient,
    rpc_client: &RpcClient,
    signer: &Keypair,
) -> Result<String, Box<dyn std::error::Error>> {
    let recent_blockhash = rpc_client.get_latest_blockhash()?;
    let mut bundle = TransactionBundle::new();
    
    // Transaction 1: Create token accounts
    let account_creation_instructions = vec![
        // Add token account creation instructions
        system_instruction::create_account(
            &signer.pubkey(),
            &Keypair::new().pubkey(), // New account
            1_000_000, // Rent exemption
            165,       // Token account space
            &spl_token::id(),
        ),
    ];
    
    let account_tx = build_transaction_with_tip(
        signer,
        recent_blockhash,
        500_000,
        account_creation_instructions,
    )?;
    bundle = bundle.add_transaction(account_tx);
    
    // Transaction 2: Execute swap
    let swap_instructions = vec![
        // Add swap instructions (Jupiter, Raydium, etc.)
        system_instruction::transfer(
            &signer.pubkey(),
            &Pubkey::from_str("<swap-program-address>")?,
            0, // No SOL transfer for swap
        ),
    ];
    
    let swap_tx = build_transaction_with_tip(
        signer,
        recent_blockhash,
        1_500_000, // Higher tip for main operation
        swap_instructions,
    )?;
    bundle = bundle.add_transaction(swap_tx);
    
    // Transaction 3: Stake or provide liquidity
    let stake_instructions = vec![
        // Add staking/liquidity instructions
        system_instruction::transfer(
            &signer.pubkey(),
            &Pubkey::from_str("<stake-pool-address>")?,
            0,
        ),
    ];
    
    let stake_tx = build_transaction_with_tip(
        signer,
        recent_blockhash,
        750_000,
        stake_instructions,
    )?;
    bundle = bundle.add_transaction(stake_tx);
    
    println!("DeFi operation bundle prepared with {} transactions", bundle.transactions.len());
    Ok("".to_string())
}

Usage Example

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Initialize configuration
    let signer = Keypair::new(); // Use your actual keypair
    let rpc_client = RpcClient::new("https://api.mainnet-beta.solana.com".to_string());
    
    // Connect to NextBlock (see connection.md)
    // let config = NextBlockConfig::default();
    // let mut nextblock_client = create_nextblock_client(config).await?;
    
    // Submit basic batch
    let bundle_signature = submit_batched_transactions(
        // &mut nextblock_client,
        &rpc_client,
        &signer,
    ).await?;
    
    println!("Batch submitted with signature: {}", bundle_signature);
    
    // Submit arbitrage bundle
    let arb_signature = build_arbitrage_bundle(
        // &mut nextblock_client,
        &rpc_client,
        &signer,
        Pubkey::from_str("<dex-a-address>")?,
        Pubkey::from_str("<dex-b-address>")?,
        1_000_000, // 0.001 SOL
    ).await?;
    
    println!("Arbitrage bundle: {}", arb_signature);
    
    // Submit complex DeFi bundle
    let defi_signature = build_defi_operation_bundle(
        // &mut nextblock_client,
        &rpc_client,
        &signer,
    ).await?;
    
    println!("DeFi bundle: {}", defi_signature);
    
    Ok(())
}

Bundle Best Practices

Size and Composition

• Bundle size: 2-4 transactions (optimal: 2-3)

• Transaction order: Setup → Main operations → Cleanup

• Compute limits: Stay within bundle compute unit limits

Tip Strategy

• Progressive tipping: Higher tips for more critical transactions

• Bundle coherence: All transactions should have meaningful tips

• Market conditions: Adjust tips based on network congestion

Error Handling

// Validate bundle before submission
fn validate_bundle(bundle: &TransactionBundle) -> Result<(), &'static str> {
    if bundle.transactions.is_empty() {
        return Err("Bundle cannot be empty");
    }
    
    if bundle.transactions.len() > 4 {
        return Err("Bundle cannot contain more than 4 transactions");
    }
    
    if bundle.transactions.len() < 2 {
        return Err("Bundle must contain at least 2 transactions");
    }
    
    // Check for signature duplicates
    let mut signatures = std::collections::HashSet::new();
    for tx in &bundle.transactions {
        if !signatures.insert(tx.signatures[0]) {
            return Err("Duplicate transaction signatures in bundle");
        }
    }
    
    Ok(())
}

Common Use Cases

1. Arbitrage: Multi-DEX price differences

2. DeFi operations: Account setup → Trade → Stake

3. NFT operations: Create → Mint → Transfer → List

4. Token operations: Create mint → Create accounts → Transfer

5. Liquidations: Detect → Execute → Collect rewards

Bundle Failure Prevention

• Account validation: Ensure all accounts exist and have sufficient balance

• Instruction compatibility: Avoid conflicting program interactions

• Blockhash freshness: Use recent blockhashes (valid ~60 seconds)

• Compute budget: Monitor total compute units across all transactions