Sign inGet started
Documentation index

Quick Start

Get your first transaction submitted through Slipstream in 5 minutes.

Prerequisites

  • An AllenHark account with an API key (sk_live_*)
  • A funded Solana wallet for token deposits
  • Rust 1.70+, Node.js 18+, or Python 3.10+

Step 1: Install the SDK

Install — Rust

TOML
[dependencies]
allenhark-slipstream = "0.3"
tokio = { version = "1", features = ["full"] }
solana-sdk = "1.18"

Install — TypeScript

Terminal
npm install @allenhark/slipstream @solana/web3.js

Install — Python

Terminal
pip install AllenHarkSlipstream solana

Step 2: Get Your API Key

  1. Log in to the AllenHark Console
  2. Navigate to Slipstream → API Keys
  3. Create a new key — it will start with sk_live_
  4. Copy the key securely; it won't be shown again

Step 3: Connect and Submit

The SDK auto-discovers the nearest region via the discovery service, probes latency to all available workers, and connects over the first protocol in the fallback chain that answers (QUIC, then gRPC, WebSocket, HTTP).

Connect — Rust

Rust
use allenhark_slipstream::{Config, SlipstreamClient};

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let config = Config::builder()
        .api_key("sk_live_your_key_here")
        .build()?;

    let client = SlipstreamClient::connect(config).await?;

    // Check connection info
    let info = client.connection_info();
    println!("Connected! Session: {}, Protocol: {:?}, Region: {:?}",
        info.session_id, info.protocol, info.region);

    // Submit a transaction (raw bytes)
    let result = client.submit_transaction(&tx_bytes).await?;
    println!("Signature: {:?}", result.signature);
    println!("Status: {:?}", result.status);
    println!("Routing: {:?}", result.routing);

    Ok(())
}

Connect — TypeScript

TypeScript
import { SlipstreamClient, configBuilder } from "@allenhark/slipstream";

const config = configBuilder()
    .apiKey("sk_live_your_key_here")
    .build();

const client = await SlipstreamClient.connect(config);

// Check connection info
const info = client.connectionInfo();
console.log("Connected!", info.sessionId, info.protocol, info.region);

// Submit a transaction (Uint8Array)
const result = await client.submitTransaction(txBytes);
console.log("Signature:", result.signature);
console.log("Status:", result.status);
console.log("Routing:", result.routing);

Connect — Python

Python
from allenhark_slipstream import SlipstreamClient, config_builder

config = config_builder() \
    .api_key("sk_live_your_key_here") \
    .build()

client = await SlipstreamClient.connect(config)

# Check connection info
info = client.connection_info()
print(f"Connected! Session: {info.session_id}, Protocol: {info.protocol}, Region: {info.region}")

# Submit a transaction (bytes)
result = await client.submit_transaction(tx_bytes)
print(f"Signature: {result.signature}")
print(f"Status: {result.status}")
print(f"Routing: {result.routing}")

Step 4: Check Your Balance

Balance — Rust

Rust
let balance = client.get_balance().await?;
println!("Balance: {} SOL ({} tokens)", balance.balance_sol, balance.balance_tokens);
println!("Tier: {:?}", balance.tier);

Balance — TypeScript

TypeScript
const balance = await client.getBalance();
console.log(`Balance: ${balance.balanceSol} SOL (${balance.balanceTokens} tokens)`);
console.log("Tier:", balance.tier);

Balance — Python

Python
balance = await client.get_balance()
print(f"Balance: {balance.balance_sol} SOL ({balance.balance_tokens} tokens)")
print(f"Tier: {balance.tier}")

What Happened?

  1. The SDK queried the discovery service at https://discovery.allenhark.network to find available regions and workers
  2. It probed latency to each worker and connected to the one with the lowest measured round trip
  3. Protocol fallback chain was used: QUIC (2s) → gRPC (3s) → WebSocket (3s) → HTTP (5s)
  4. Your transaction was routed to the sender closest to the current slot leader
  5. 1 token (0.00005 SOL / 50,000 lamports) was deducted from your balance

Next Steps