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 using the fastest protocol available.

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 fastest one
  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