Lightspeed SDK for Rust

Fast, reliable transaction processing for Solana using Solana Vibe Station's Lightspeed RPC service.

Overview

Lightspeed SDK provides a simple, efficient way to submit prioritized transactions to the Solana blockchain through Solana Vibe Station's optimized RPC infrastructure. The SDK handles tip management, connection pooling, and transaction prioritization automatically.

Features

• 🚀 Automatic Tip Management - Transactions automatically include appropriate priority tips
• ⚡ Multiple Priority Levels - Choose between Minimum, Standard, Rush, or Custom priority
• 🔄 Connection Keep-Alive - Maintains persistent connections for optimal performance
• 📦 Full Solana SDK Compatibility - Works seamlessly with existing Solana code
• 🔐 Secure Authentication - API key authentication via HTTP headers
• 📊 Transaction Tracking - Returns signatures and tip amounts for monitoring

Installation

Add this to your Cargo.toml:

[dependencies]
lightspeed-sdk = "0.1.3"
solana-sdk = "2.1"
tokio = { version = "1", features = ["full"] }

Quick Start

use lightspeed_sdk::{LightspeedClientBuilder, Priority};
use solana_sdk::{
    signature::Keypair,
    signer::Signer,
    system_instruction,
    hash::Hash,
};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Initialize client
    let client = LightspeedClientBuilder::new("your-api-key")
        .svs_rpc_url("https://basic.rpc.solanavibestation.com")
        .default_priority(Priority::Standard)
        .build()?;

    // Start keep-alive for connection management
    client.start_keep_alive().await?;

    // Create a transaction
    let payer = Keypair::new();
    let recipient = solana_sdk::pubkey::Pubkey::new_unique();
    
    let instruction = system_instruction::transfer(
        &payer.pubkey(),
        &recipient,
        1_000_000, // 0.001 SOL
    );

    // Send with automatic tip injection
    let result = client.send_transaction(
        vec![instruction],
        &payer.pubkey(),
        &[&payer],
        Hash::default(), // Use real blockhash in production
    ).await?;

    println!("Transaction sent: {}", result.signature);
    println!("Tip paid: {} lamports", result.tip_amount);

    Ok(())
}

Usage Examples

Different Priority Levels

use lightspeed_sdk::Priority;

// Standard priority (0.001 SOL tip)
let result = client.send_transaction(
    instructions,
    &payer.pubkey(),
    &[&payer],
    blockhash,
).await?;

// Minimum priority (0.0001 SOL tip)
let result = client.send_transaction_with_priority(
    instructions,
    &payer.pubkey(),
    &[&payer],
    blockhash,
    Priority::Minimum,
).await?;


// Rush priority (0.005 SOL tip)
let result = client.send_transaction_with_priority(
    instructions,
    &payer.pubkey(),
    &[&payer],
    blockhash,
    Priority::Rush,
).await?;

// Custom tip amount (0.01 SOL)
let result = client.send_transaction_with_tip(
    instructions,
    &payer.pubkey(),
    &[&payer],
    blockhash,
    10_000_000, // lamports
).await?;

Manual Tip Control

// Create tip instruction manually
let tip_instruction = client.create_tip_instruction_with_priority(
    &payer.pubkey(),
    Priority::Rush,
);

// Build transaction with tip
let mut transaction = Transaction::new_with_payer(
    &[transfer_instruction, tip_instruction],
    Some(&payer.pubkey()),
);

// Sign and send
transaction.sign(&[&payer], blockhash);
let signature = client.send_prebuilt_transaction(&transaction).await?;

Configuration Options

use std::time::Duration;

let client = LightspeedClientBuilder::new("your-api-key")
    .svs_rpc_url("https://elite.rpc.solanavibestation.com") // SVS RPC URL
    .default_priority(Priority::Rush)                       // Default priority
    .timeout(Duration::from_secs(60))                       // Request timeout
    .keep_alive_interval(Duration::from_secs(30))           // Keep-alive interval
    .debug(true)                                            // Enable debug logging
    .build()?;

API Documentation

Core Methods

Priority Levels

Getting Started

1. Get an SVS RPC Subscription: Sign up for RPC services at Solana Vibe Station to get access to Lightspeed with your RPC url and API Key

2. Install the SDK: Add the dependency to your Cargo.toml

3. Start Building: Use the examples above to integrate Lightspeed into your application

Requirements

• Rust 1.75.0 or later
• Tokio runtime for async operations
• Valid Staked RPC/Lightspeed API key from Solana Vibe Station

Examples

Check out the examples directory for more detailed usage examples:

• basic_usage.rs - Complete example showing all features
• More examples coming soon!

Support

• Documentation: docs.rs/lightspeed-sdk
• Issues: GitHub Issues
• Discord: Join our Discord community
• Email: support@solanavibestation.com

Contributing

We welcome contributions! Please see our Contributing Guide for details.

1. Fork the repository
2. Create your feature branch (git checkout -b feature/amazing-feature)
3. Commit your changes (git commit -m 'Add amazing feature')
4. Push to the branch (git push origin feature/amazing-feature)
5. Open a Pull Request

License

Licensed under either of

• Apache License, Version 2.0 (LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0)
• MIT license (LICENSE-MIT or http://opensource.org/licenses/MIT)

at your option.

Contribution

Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in the work by you, as defined in the Apache-2.0 license, shall be dual licensed as above, without any additional terms or conditions.

About Solana Vibe Station

Solana Vibe Station provides high-performance RPC infrastructure for the Solana blockchain. Our Lightspeed service offers prioritized transaction processing with guaranteed delivery and minimal latency.

Built with ❤️ by the Solana Vibe Station team