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

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

Install — TypeScript

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

Install — Python

1pip 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

1use allenhark_slipstream::{Config, SlipstreamClient};
2
3#[tokio::main]
4async fn main() -> anyhow::Result<()> {
5    let config = Config::builder()
6        .api_key("sk_live_your_key_here")
7        .build()?;
8
9    let client = SlipstreamClient::connect(config).await?;
10
11    // Check connection info
12    let info = client.connection_info();
13    println!("Connected! Session: {}, Protocol: {:?}, Region: {:?}",
14        info.session_id, info.protocol, info.region);
15
16    // Submit a transaction (raw bytes)
17    let result = client.submit_transaction(&tx_bytes).await?;
18    println!("Signature: {:?}", result.signature);
19    println!("Status: {:?}", result.status);
20    println!("Routing: {:?}", result.routing);
21
22    Ok(())
23}

Connect — TypeScript

1import { SlipstreamClient, configBuilder } from "@allenhark/slipstream";
2
3const config = configBuilder()
4    .apiKey("sk_live_your_key_here")
5    .build();
6
7const client = await SlipstreamClient.connect(config);
8
9// Check connection info
10const info = client.connectionInfo();
11console.log("Connected!", info.sessionId, info.protocol, info.region);
12
13// Submit a transaction (Uint8Array)
14const result = await client.submitTransaction(txBytes);
15console.log("Signature:", result.signature);
16console.log("Status:", result.status);
17console.log("Routing:", result.routing);

Connect — Python

1from allenhark_slipstream import SlipstreamClient, config_builder
2
3config = config_builder() \
4    .api_key("sk_live_your_key_here") \
5    .build()
6
7client = await SlipstreamClient.connect(config)
8
9# Check connection info
10info = client.connection_info()
11print(f"Connected! Session: {info.session_id}, Protocol: {info.protocol}, Region: {info.region}")
12
13# Submit a transaction (bytes)
14result = await client.submit_transaction(tx_bytes)
15print(f"Signature: {result.signature}")
16print(f"Status: {result.status}")
17print(f"Routing: {result.routing}")

Step 4: Check Your Balance

Balance — Rust

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

Balance — TypeScript

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

Balance — Python

1balance = await client.get_balance()
2print(f"Balance: {balance.balance_sol} SOL ({balance.balance_tokens} tokens)")
3print(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

PreviousSlipstreamNextConfiguration