Sign inGet started
Documentation index

Transactions

Submit individual transactions through Slipstream with smart routing and detailed results. Costs 1 token (0.00005 SOL) per transaction.

Basic Submission

Basic — Rust

Rust
let result = client.submit_transaction(&tx_bytes).await?;
println!("Status: {:?}", result.status);
println!("Signature: {:?}", result.signature);

Basic — TypeScript

TypeScript
const result = await client.submitTransaction(txBytes);
console.log("Status:", result.status);
console.log("Signature:", result.signature);

Basic — Python

Python
result = await client.submit_transaction(tx_bytes)
print(f"Status: {result.status}")
print(f"Signature: {result.signature}")

Submission with Options

Options — Rust

Rust
use allenhark_slipstream::{SubmitOptions, RetryOptions};

let result = client.submit_transaction_with_options(&tx_bytes, &SubmitOptions {
    // Fan-out to all regions (default: false)
    broadcast_mode: false,

    // Force a specific sender (default: auto-select)
    preferred_sender: None,

    // Max retries for this transaction (default: 2)
    max_retries: 2,

    // Timeout in milliseconds (default: 30000)
    timeout_ms: 30_000,

    // Deduplication ID — skip if already seen
    dedup_id: Some("my-unique-tx-id".into()),

    // Retry configuration
    retry: Some(RetryOptions {
        max_retries: 2,
        backoff_base_ms: 100,
        cross_sender_retry: false, // Try different sender on retry
    }),

    // Direct UDP to validator TPU — fire-and-forget, costs 0.0001 SOL
    tpu_submission: false,
}).await?;

Options — TypeScript

TypeScript
const result = await client.submitTransactionWithOptions(txBytes, {
    broadcastMode: false,
    preferredSender: undefined,
    maxRetries: 2,
    timeoutMs: 30_000,
    dedupId: "my-unique-tx-id",
    retry: {
        maxRetries: 2,
        backoffBaseMs: 100,
        crossSenderRetry: false,
    },
    tpuSubmission: false,
});

Options — Python

Python
from allenhark_slipstream import SubmitOptions, RetryOptions

result = await client.submit_transaction_with_options(tx_bytes, SubmitOptions(
    broadcast_mode=False,
    preferred_sender=None,
    max_retries=2,
    timeout_ms=30_000,
    dedup_id="my-unique-tx-id",
    retry=RetryOptions(
        max_retries=2,
        backoff_base_ms=100,
        cross_sender_retry=False,
    ),
    tpu_submission=False,
))

TransactionResult Fields

FieldTypeDescription
request_idstringUnique request identifier
transaction_idstringTransaction identifier
signaturestring?Transaction signature (base58)
statusTransactionStatusCurrent status
slotnumber?Slot when submitted
slot_sentnumber?Slot when sent to network
slot_acceptednumber?Slot when accepted
slot_landednumber?Slot when landed on-chain
slot_deltanumber?Difference between sent and landed slots
commitment_levelstring?Commitment level reached
confirmationsnumber?Number of confirmations
timestampnumberUnix timestamp
routingRoutingInfo?Region, sender, and latency details
errorTransactionError?Error details if failed

Transaction Statuses

StatusDescription
pendingAccepted, not yet processed
processingBeing processed by Slipstream
sentSent to the Solana network
confirmedConfirmed on-chain
failedTransaction failed
duplicateDuplicate detected (via dedup_id)
rate_limitedRate limit exceeded
insufficient_tokensNot enough tokens

TPU Submission

For fire-and-forget scenarios, use tpu_submission: true. This sends the transaction directly via UDP to the validator TPU. It costs 0.0001 SOL per transaction and provides no confirmation receipt.

TPU — Rust

Rust
let result = client.submit_transaction_with_options(&tx_bytes, &SubmitOptions {
    tpu_submission: true,
    ..Default::default()
}).await?;

TPU — TypeScript

TypeScript
const result = await client.submitTransactionWithOptions(txBytes, {
    tpuSubmission: true,
});

TPU — Python

Python
result = await client.submit_transaction_with_options(tx_bytes, SubmitOptions(
    tpu_submission=True,
))

Next Steps