Transactions

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

Basic Submission

Basic — Rust

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

Basic — TypeScript

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

Basic — Python

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

Submission with Options

Options — Rust

1use allenhark_slipstream::{SubmitOptions, RetryOptions};
2
3let result = client.submit_transaction_with_options(&tx_bytes, &SubmitOptions {
4    // Fan-out to all regions (default: false)
5    broadcast_mode: false,
6
7    // Force a specific sender (default: auto-select)
8    preferred_sender: None,
9
10    // Max retries for this transaction (default: 2)
11    max_retries: 2,
12
13    // Timeout in milliseconds (default: 30000)
14    timeout_ms: 30_000,
15
16    // Deduplication ID — skip if already seen
17    dedup_id: Some("my-unique-tx-id".into()),
18
19    // Retry configuration
20    retry: Some(RetryOptions {
21        max_retries: 2,
22        backoff_base_ms: 100,
23        cross_sender_retry: false, // Try different sender on retry
24    }),
25
26    // Direct UDP to validator TPU — fire-and-forget, costs 0.0001 SOL
27    tpu_submission: false,
28}).await?;

Options — TypeScript

1const result = await client.submitTransactionWithOptions(txBytes, {
2    broadcastMode: false,
3    preferredSender: undefined,
4    maxRetries: 2,
5    timeoutMs: 30_000,
6    dedupId: "my-unique-tx-id",
7    retry: {
8        maxRetries: 2,
9        backoffBaseMs: 100,
10        crossSenderRetry: false,
11    },
12    tpuSubmission: false,
13});

Options — Python

1from allenhark_slipstream import SubmitOptions, RetryOptions
2
3result = await client.submit_transaction_with_options(tx_bytes, SubmitOptions(
4    broadcast_mode=False,
5    preferred_sender=None,
6    max_retries=2,
7    timeout_ms=30_000,
8    dedup_id="my-unique-tx-id",
9    retry=RetryOptions(
10        max_retries=2,
11        backoff_base_ms=100,
12        cross_sender_retry=False,
13    ),
14    tpu_submission=False,
15))

TransactionResult Fields

Field	Type	Description
`request_id`	string	Unique request identifier
`transaction_id`	string	Transaction identifier
`signature`	string?	Transaction signature (base58)
`status`	TransactionStatus	Current status
`slot`	number?	Slot when submitted
`slot_sent`	number?	Slot when sent to network
`slot_accepted`	number?	Slot when accepted
`slot_landed`	number?	Slot when landed on-chain
`slot_delta`	number?	Difference between sent and landed slots
`commitment_level`	string?	Commitment level reached
`confirmations`	number?	Number of confirmations
`timestamp`	number	Unix timestamp
`routing`	RoutingInfo?	Region, sender, and latency details
`error`	TransactionError?	Error details if failed

Transaction Statuses

Status	Description
`pending`	Accepted, not yet processed
`processing`	Being processed by Slipstream
`sent`	Sent to the Solana network
`confirmed`	Confirmed on-chain
`failed`	Transaction failed
`duplicate`	Duplicate detected (via dedup_id)
`rate_limited`	Rate limit exceeded
`insufficient_tokens`	Not 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

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

TPU — TypeScript

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

TPU — Python

1result = await client.submit_transaction_with_options(tx_bytes, SubmitOptions(
2    tpu_submission=True,
3))

Next Steps

Bundles — Atomic multi-transaction bundles
Real-Time Streams — Subscribe to leader hints
Error Handling — Handle failures gracefully