Sign inGet started
Documentation index

Billing & Tokens

Slipstream uses a token-based billing system. Deposit SOL, receive tokens, and pay per action.

Token Rate

Text
1 token = 50,000 lamports = 0.00005 SOL
1 SOL = 20,000 tokens

Pricing by Action

ActionTokensSOL Equivalent
Single transaction10.00005 SOL
Bundle (2-5 tx)50.00025 SOL
TPU submission (fire-and-forget)20.0001 SOL
RPC proxy call10.00005 SOL
Transaction/bundle simulation1 per tx0.00005 SOL

Tiers

TierRequirementsFeatures
FreeNo depositA small daily token allowance, HTTP only
StandardAny depositAll protocols, auto-region, streams
ProThe SDK's default tier settingAll features
EnterpriseBy arrangementVolume terms and dedicated workers; contact us

The console shows the minimum deposit when you deposit.

Checking Balance

Balance — Rust

Rust
let balance = client.get_balance().await?;
println!("Balance: {} SOL ({} tokens)",
    balance.balance_sol, balance.balance_tokens);
println!("Lamports: {}", balance.balance_lamports);
println!("Grace remaining: {} tokens", balance.grace_remaining_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}")

Depositing SOL

Via Console

  1. Go to AllenHark Console → Slipstream → Billing
  2. Click Deposit SOL
  3. Send SOL to the displayed deposit address
  4. Tokens are credited automatically

Deposit Address via SDK — Rust

Rust
let deposit = client.get_deposit_address().await?;
println!("Send SOL to: {}", deposit.address);

Deposit Address via SDK — TypeScript

TypeScript
const deposit = await client.getDepositAddress();
console.log("Send SOL to:", deposit.address);

Deposit Address via SDK — Python

Python
deposit = await client.get_deposit_address()
print(f"Send SOL to: {deposit.address}")

Pending Deposits

Check if a deposit is being confirmed:

Pending — Rust

Rust
let pending = client.get_pending_deposit().await?;
println!("Pending: {:?}", pending);

Pending — TypeScript

TypeScript
const pending = await client.getPendingDeposit();
console.log("Pending:", pending);

Usage History

Usage — Rust

Rust
use allenhark_slipstream::UsageHistoryOptions;

let history = client.get_usage_history(UsageHistoryOptions::default()).await?;
for entry in &history {
    println!("{}: {} tokens", entry.date, entry.tokens_used);
}

Usage — TypeScript

TypeScript
const history = await client.getUsageHistory();
for (const entry of history) {
    console.log(`${entry.date}: ${entry.tokensUsed} tokens`);
}

Usage — Python

Python
history = await client.get_usage_history()
for entry in history:
    print(f"{entry.date}: {entry.tokens_used} tokens")

Deposit History

Deposits — Rust

Rust
let deposits = client.get_deposit_history(DepositHistoryOptions::default()).await?;
for entry in &deposits {
    println!("{}: {} SOL → {} tokens", entry.date, entry.amount_sol, entry.tokens_credited);
}

Deposits — TypeScript

TypeScript
const deposits = await client.getDepositHistory();
for (const entry of deposits) {
    console.log(`${entry.date}: ${entry.amountSol} SOL → ${entry.tokensCredited} tokens`);
}

Free Tier Usage

Free Tier — Rust

Rust
let free = client.get_free_tier_usage().await?;
println!("Used: {}/{} daily tokens", free.used, free.limit);

Free Tier — TypeScript

TypeScript
const free = await client.getFreeTierUsage();
console.log(`Used: ${free.used}/${free.limit} daily tokens`);

Next Steps