solana-tx-kit 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,675 @@
+import { EventEmitter } from 'node:events';
+import { Transaction, VersionedTransaction, Keypair, Commitment, PublicKey, Connection, TransactionInstruction } from '@solana/web3.js';
+
+interface Logger {
+    debug(msg: string, data?: Record<string, unknown>): void;
+    info(msg: string, data?: Record<string, unknown>): void;
+    warn(msg: string, data?: Record<string, unknown>): void;
+    error(msg: string, data?: Record<string, unknown>): void;
+}
+type SolanaTransaction = Transaction | VersionedTransaction;
+type Result<T, E = Error> = {
+    ok: true;
+    value: T;
+} | {
+    ok: false;
+    error: E;
+};
+
+/** Transaction lifecycle events emitted during send/confirm/bundle operations */
+declare enum TxEvent {
+    SENDING = "sending",
+    SIMULATED = "simulated",
+    SENT = "sent",
+    CONFIRMING = "confirming",
+    CONFIRMED = "confirmed",
+    RETRYING = "retrying",
+    BLOCKHASH_EXPIRED = "blockhash_expired",
+    FAILED = "failed",
+    BUNDLE_SENT = "bundle_sent",
+    BUNDLE_CONFIRMED = "bundle_confirmed",
+    BUNDLE_FAILED = "bundle_failed"
+}
+interface TxEventMap {
+    [TxEvent.SENDING]: {
+        transaction: SolanaTransaction;
+        attempt: number;
+    };
+    [TxEvent.SIMULATED]: {
+        signature: string;
+        unitsConsumed: number;
+        logs: string[];
+    };
+    [TxEvent.SENT]: {
+        signature: string;
+        attempt: number;
+    };
+    [TxEvent.CONFIRMING]: {
+        signature: string;
+        commitment: string;
+    };
+    [TxEvent.CONFIRMED]: {
+        signature: string;
+        slot: number;
+        commitment: string;
+    };
+    [TxEvent.RETRYING]: {
+        attempt: number;
+        maxRetries: number;
+        error: Error;
+        delayMs: number;
+    };
+    [TxEvent.BLOCKHASH_EXPIRED]: {
+        oldBlockhash: string;
+        newBlockhash: string;
+    };
+    [TxEvent.FAILED]: {
+        error: Error;
+        attempt: number;
+    };
+    [TxEvent.BUNDLE_SENT]: {
+        bundleId: string;
+        txCount: number;
+    };
+    [TxEvent.BUNDLE_CONFIRMED]: {
+        bundleId: string;
+        slot: number;
+    };
+    [TxEvent.BUNDLE_FAILED]: {
+        bundleId: string;
+        error: Error;
+    };
+}
+/** Type-safe event emitter for transaction lifecycle events. Subscribe via `.on(TxEvent.*, handler)`. */
+declare class TypedEventEmitter extends EventEmitter {
+    emit<K extends TxEvent>(event: K, data: TxEventMap[K]): boolean;
+    on<K extends TxEvent>(event: K, listener: (data: TxEventMap[K]) => void): this;
+    once<K extends TxEvent>(event: K, listener: (data: TxEventMap[K]) => void): this;
+}
+
+interface JitoConfig {
+    /** Block engine URL (default: mainnet) */
+    blockEngineUrl: string;
+    /** Tip amount in lamports. If not set, uses dynamic calculation */
+    tipLamports?: number;
+    /** Maximum tip in lamports (cap for dynamic tip) */
+    maxTipLamports?: number;
+    /** Minimum tip in lamports (default: 1000 — Jito minimum) */
+    minTipLamports?: number;
+    /** Keypair for signing the tip transaction */
+    tipPayer: Keypair;
+    /** Poll interval for bundle status in ms (default: 2000) */
+    statusPollIntervalMs?: number;
+    /** Maximum time to wait for bundle confirmation in ms (default: 60000) */
+    statusTimeoutMs?: number;
+}
+interface BundleResult {
+    bundleId: string;
+    status: BundleStatus;
+    slot?: number;
+    /** Time from submission to confirmation in ms */
+    latencyMs?: number;
+}
+declare enum BundleStatus {
+    SUBMITTED = "submitted",
+    PENDING = "pending",
+    LANDED = "landed",
+    FAILED = "failed",
+    DROPPED = "dropped",
+    INVALID = "invalid"
+}
+
+interface RpcEndpointConfig {
+    /** RPC URL */
+    url: string;
+    /** Weight for routing (higher = preferred). Default: 1 */
+    weight?: number;
+    /** Maximum requests per second for this endpoint. 0 = unlimited */
+    rateLimit?: number;
+    /** Human-readable label (e.g., "helius-primary") */
+    label?: string;
+}
+interface HealthMetrics {
+    /** Exponential moving average of latency in ms */
+    latencyEma: number;
+    /** Total errors in the sliding window */
+    errorCount: number;
+    /** Total successes in the sliding window */
+    successCount: number;
+    /** Error rate (0-1) */
+    errorRate: number;
+    /** Last known slot from this endpoint */
+    lastSlot: number;
+    /** Delta from the highest known slot across all endpoints */
+    slotLag: number;
+    /** Timestamp of last successful response */
+    lastSuccessAt: number;
+    /** Current circuit breaker state */
+    circuitState: CircuitState;
+}
+declare enum CircuitState {
+    CLOSED = "closed",
+    OPEN = "open",
+    HALF_OPEN = "half_open"
+}
+interface CircuitBreakerConfig {
+    /** Number of errors to trip the breaker (default: 5) */
+    failureThreshold: number;
+    /** Time in OPEN state before transitioning to HALF_OPEN (default: 30000ms) */
+    resetTimeoutMs: number;
+    /** Sliding window size in ms for counting failures (default: 60000ms) */
+    windowMs: number;
+}
+interface ConnectionPoolConfig {
+    endpoints: RpcEndpointConfig[];
+    /** Strategy for selecting endpoints */
+    strategy?: "weighted-round-robin" | "latency-based";
+    /** How often to run health checks in ms (default: 10000) */
+    healthCheckIntervalMs?: number;
+    /** Circuit breaker settings */
+    circuitBreaker?: Partial<CircuitBreakerConfig>;
+    /** Commitment for health check calls (default: "confirmed") */
+    healthCheckCommitment?: Commitment;
+}
+
+interface BlockhashInfo {
+    blockhash: string;
+    lastValidBlockHeight: number;
+    fetchedAt: number;
+}
+interface BlockhashManagerConfig {
+    /** Time-to-live for cached blockhash in ms (default: 60_000) */
+    ttlMs: number;
+    /** Background refresh interval in ms (default: 30_000) */
+    refreshIntervalMs: number;
+    /** Commitment for fetching (default: "confirmed") */
+    commitment: Commitment;
+}
+
+interface ConfirmationConfig {
+    /** Target commitment level (default: "confirmed") */
+    commitment: Commitment;
+    /** Total timeout in ms (default: 60_000) */
+    timeoutMs: number;
+    /** Polling interval for fallback polling in ms (default: 2_000) */
+    pollIntervalMs: number;
+    /** Whether to use WebSocket subscription (default: true) */
+    useWebSocket: boolean;
+}
+interface ConfirmationResult {
+    status: "confirmed" | "finalized" | "expired" | "failed";
+    slot?: number;
+    error?: {
+        code: number;
+        message: string;
+    };
+    /** Time from submission to confirmation in ms */
+    latencyMs: number;
+}
+
+interface FeeEstimateConfig {
+    /** Percentile to target: 50, 75, or 90 (default: 75) */
+    targetPercentile: 50 | 75 | 90;
+    /** Maximum micro-lamports per CU (default: 1_000_000) */
+    maxMicroLamports: number;
+    /** Minimum micro-lamports per CU (default: 1_000) */
+    minMicroLamports: number;
+    /** Writable accounts for account-specific estimation */
+    writableAccounts?: PublicKey[];
+}
+interface FeeEstimateResult {
+    /** Recommended micro-lamports per CU */
+    microLamports: number;
+    /** The percentile values observed */
+    percentiles: {
+        p50: number;
+        p75: number;
+        p90: number;
+    };
+    /** Number of fee samples used */
+    sampleCount: number;
+}
+interface ComputeBudgetConfig {
+    /** Compute unit limit to request (default: 200_000) */
+    computeUnits: number;
+    /** Micro-lamports per compute unit */
+    microLamports: number;
+}
+
+interface RetryConfig {
+    /** Maximum number of retry attempts (default: 3) */
+    maxRetries: number;
+    /** Initial delay in ms before first retry (default: 500) */
+    baseDelayMs: number;
+    /** Maximum delay cap in ms (default: 10000) */
+    maxDelayMs: number;
+    /** Exponential multiplier (default: 2) */
+    backoffMultiplier: number;
+    /** Custom predicate: return true to retry, false to fail immediately */
+    retryPredicate?: (error: Error, attempt: number) => boolean;
+    /** Called before each retry — hook for re-signing, logging, etc. */
+    onRetry?: (error: Error, attempt: number, delayMs: number) => void | Promise<void>;
+}
+interface RetryContext {
+    attempt: number;
+    totalAttempts: number;
+    elapsed: number;
+    lastError?: Error | undefined;
+}
+
+interface SimulationConfig {
+    /** Commitment level for simulation (default: "confirmed") */
+    commitment?: Commitment;
+    /** Whether to replace the blockhash for simulation (default: true) */
+    replaceRecentBlockhash?: boolean;
+    /** Whether to verify signatures during simulation (default: false — faster) */
+    sigVerify?: boolean;
+}
+interface SimulationResult {
+    success: boolean;
+    unitsConsumed: number;
+    logs: string[];
+    error?: {
+        code: number;
+        message: string;
+        instructionError?: {
+            index: number;
+            message: string;
+        } | undefined;
+    } | undefined;
+    returnData?: {
+        programId: string;
+        data: string;
+    } | undefined;
+}
+
+/**
+ * Fluent builder for constructing a TransactionSender.
+ *
+ * Usage:
+ *   const sender = TransactionSender.builder()
+ *     .rpc("https://api.mainnet-beta.solana.com")
+ *     .signer(keypair)
+ *     .withPriorityFees({ targetPercentile: 90 })
+ *     .withJito({ tipLamports: 10_000, tipPayer: keypair })
+ *     .withRetry({ maxRetries: 5 })
+ *     .build();
+ */
+declare class TransactionSenderBuilder {
+    private config;
+    /** Set a single RPC endpoint */
+    rpc(url: string): this;
+    /** Set multiple RPC endpoints with failover */
+    rpcPool(endpoints: RpcEndpointConfig[], options?: {
+        strategy?: "weighted-round-robin" | "latency-based";
+        healthCheckIntervalMs?: number;
+    }): this;
+    /** Set the transaction signer */
+    signer(keypair: Keypair): this;
+    /** Configure priority fee estimation */
+    withPriorityFees(config?: Partial<FeeEstimateConfig>): this;
+    /** Disable automatic priority fee estimation */
+    disablePriorityFees(): this;
+    /** Configure Jito bundle submission */
+    withJito(config: JitoConfig): this;
+    /** Configure retry behavior */
+    withRetry(config: Partial<RetryConfig>): this;
+    /** Configure transaction simulation */
+    withSimulation(config?: Partial<SimulationConfig>): this;
+    /** Disable pre-flight simulation */
+    disableSimulation(): this;
+    /** Configure confirmation tracking */
+    withConfirmation(config: Partial<ConfirmationConfig>): this;
+    /** Configure blockhash management */
+    withBlockhash(config: Partial<BlockhashManagerConfig>): this;
+    /** Set the logger */
+    withLogger(logger: Logger): this;
+    /** Set the default commitment */
+    commitment(level: Commitment): this;
+    /** Build and return the TransactionSender */
+    build(): TransactionSender;
+}
+
+interface SenderConfig {
+    /** RPC connection(s) configuration */
+    rpc: ConnectionPoolConfig | {
+        url: string;
+    };
+    /** Transaction signer */
+    signer: Keypair;
+    /** Retry configuration */
+    retry?: Partial<RetryConfig>;
+    /** Priority fee configuration. Set to false to disable */
+    priorityFee?: Partial<FeeEstimateConfig> | false;
+    /** Jito configuration. Set to false to disable (default: disabled) */
+    jito?: JitoConfig | false;
+    /** Simulation configuration. Set to false to skip simulation */
+    simulation?: Partial<SimulationConfig> | false;
+    /** Confirmation configuration */
+    confirmation?: Partial<ConfirmationConfig>;
+    /** Blockhash management configuration */
+    blockhash?: Partial<BlockhashManagerConfig>;
+    /** Logger instance */
+    logger?: Logger;
+    /** Default commitment level for all operations */
+    commitment?: Commitment;
+}
+interface SendResult {
+    /** Transaction signature (base58) */
+    signature: string;
+    /** Slot at which the transaction was confirmed */
+    slot: number;
+    /** Confirmation commitment achieved */
+    commitment: string;
+    /** Number of attempts (1 = first try succeeded) */
+    attempts: number;
+    /** Total time from send to confirmation in ms */
+    totalLatencyMs: number;
+    /** Compute units consumed (from simulation if run) */
+    unitsConsumed?: number | undefined;
+    /** Priority fee paid in micro-lamports per CU */
+    priorityFee?: number | undefined;
+}
+interface SendOptions {
+    /** Override priority fee for this send only */
+    priorityFee?: Partial<FeeEstimateConfig> | {
+        microLamports: number;
+    };
+    /** Override compute units for this send only */
+    computeUnits?: number;
+    /** Override retry config for this send only */
+    retry?: Partial<RetryConfig>;
+    /** Skip simulation for this send (speed over safety) */
+    skipSimulation?: boolean;
+    /** Skip confirmation — return after send, do not wait */
+    skipConfirmation?: boolean;
+    /** Custom commitment for this send only */
+    commitment?: Commitment;
+}
+
+/**
+ * Main orchestrator class. Composes all modules to send transactions
+ * with retry, priority fees, simulation, confirmation, and optional Jito bundling.
+ */
+declare class TransactionSender {
+    readonly events: TypedEventEmitter;
+    private readonly pool;
+    private readonly blockhashManager;
+    private readonly confirmer;
+    private readonly jitoBundleSender?;
+    private readonly logger;
+    private readonly config;
+    /** @param config - Full sender configuration. Prefer using {@link TransactionSender.builder} for construction. */
+    constructor(config: SenderConfig);
+    /** Create a fluent builder for configuring and constructing a TransactionSender */
+    static builder(): TransactionSenderBuilder;
+    /**
+     * Send a single transaction with the full pipeline:
+     *   1. Estimate priority fees (if enabled)
+     *   2. Fetch fresh blockhash
+     *   3. Add compute budget instructions
+     *   4. Sign transaction
+     *   5. Simulate (if enabled)
+     *   6. Send via RPC (with retry + failover)
+     *   7. Confirm (WebSocket + polling)
+     *
+     * @param transaction - A legacy or versioned Solana transaction. Not mutated for legacy transactions.
+     * @param options - Per-send overrides for priority fee, simulation, confirmation, and retry.
+     * @returns The confirmed transaction result including signature, slot, and timing info.
+     * @throws {SolTxError} On simulation failure, non-retryable errors, or exhausted retries.
+     */
+    send(transaction: SolanaTransaction, options?: SendOptions): Promise<SendResult>;
+    /**
+     * Send a bundle of 1-5 transactions via Jito.
+     * Automatically appends tip instruction to the last transaction.
+     */
+    sendJitoBundle(transactions: SolanaTransaction[], options?: {
+        tipLamports?: number;
+        waitForConfirmation?: boolean;
+    }): Promise<BundleResult>;
+    /** Get current RPC health metrics */
+    getHealthReport(): Map<string, HealthMetrics>;
+    /** Clean up: stop background tasks, clear intervals */
+    destroy(): void;
+    /** Build a working copy of the transaction with compute budget instructions prepended */
+    private prepareTransaction;
+    /** Set blockhash, fee payer, and sign the transaction */
+    private signTransaction;
+    /** Run simulation if enabled; returns compute units consumed */
+    private runSimulation;
+    /** Send serialized transaction via the connection pool with fallback */
+    private sendRawTransaction;
+    /** Confirm a transaction and return its slot, or throw on failure/expiry */
+    private awaitConfirmation;
+    /** Construct a SendResult */
+    private buildResult;
+    private resolvePriorityFee;
+}
+
+/**
+ * Execute `fn` with retries. Returns the result or throws after exhausting retries.
+ * Generic so it can wrap any async operation, not just transaction sending.
+ */
+declare function withRetry<T>(fn: (context: RetryContext) => Promise<T>, config?: Partial<RetryConfig>): Promise<T>;
+
+interface ErrorClassification {
+    retryable: boolean;
+    /** If true, the transaction must be re-signed with a fresh blockhash before retrying */
+    needsResign: boolean;
+    errorType: string;
+}
+/** Classify an error as retryable or non-retryable based on message patterns and error codes */
+declare function classifyError(error: Error): ErrorClassification;
+declare function isBlockhashExpired(error: Error): boolean;
+declare function isRateLimited(error: Error): boolean;
+
+/**
+ * Estimates priority fees by calling getRecentPrioritizationFees,
+ * sorting the results, and computing the target percentile.
+ */
+declare function estimatePriorityFee(connection: Connection, config?: Partial<FeeEstimateConfig>): Promise<FeeEstimateResult>;
+
+/**
+ * Returns [SetComputeUnitLimit, SetComputeUnitPrice] instructions.
+ * Always returns both — the sender prepends them to the transaction.
+ */
+declare function createComputeBudgetInstructions(config: ComputeBudgetConfig): [TransactionInstruction, TransactionInstruction];
+
+/**
+ * Sends a bundle of 1-5 transactions to the Jito block engine.
+ * Uses raw fetch() — no dependency on jito-ts or jito-js-rpc.
+ */
+declare class JitoBundleSender {
+    private readonly config;
+    private readonly logger?;
+    private readonly events?;
+    private readonly blockEngineUrl;
+    private readonly pollIntervalMs;
+    private readonly timeoutMs;
+    constructor(config: JitoConfig, logger?: Logger | undefined, events?: TypedEventEmitter | undefined);
+    /** Submit a bundle and optionally wait for confirmation */
+    sendBundle(transactions: (Transaction | VersionedTransaction)[], options?: {
+        waitForConfirmation?: boolean;
+    }): Promise<BundleResult>;
+    /** Poll getBundleStatuses until landed, failed, or timeout */
+    waitForBundleStatus(bundleId: string): Promise<BundleResult>;
+    private static validateUrl;
+    /** Raw JSON-RPC call to the block engine */
+    private rpcCall;
+}
+
+/** Get the next tip account using round-robin rotation */
+declare function getNextTipAccount(): PublicKey;
+/** Reset the tip rotation index (useful for testing) */
+declare function resetTipRotation(): void;
+/** Create a SOL transfer instruction to a Jito tip account */
+declare function createTipInstruction(payer: PublicKey, lamports: number): TransactionInstruction;
+
+/**
+ * Manages multiple RPC connections with health tracking, circuit breakers,
+ * and selection strategies (weighted round-robin or latency-based).
+ */
+declare class ConnectionPool {
+    private readonly logger?;
+    private readonly trackers;
+    private healthCheckInterval?;
+    private roundRobinIndex;
+    private readonly strategy;
+    constructor(config: ConnectionPoolConfig, logger?: Logger | undefined);
+    /** Get the best available connection based on strategy */
+    getConnection(): Connection;
+    /** Get a connection, falling back through endpoints if the first fails */
+    withFallback<T>(fn: (connection: Connection) => Promise<T>): Promise<T>;
+    /** Get health metrics for all endpoints */
+    getHealthReport(): Map<string, HealthMetrics>;
+    /** Stop background health checks */
+    destroy(): void;
+    private selectByLatency;
+    private selectByWeight;
+    private runHealthChecks;
+}
+
+/**
+ * Circuit breaker per endpoint.
+ *
+ * State transitions:
+ *   CLOSED --[failureThreshold exceeded]--> OPEN
+ *   OPEN   --[resetTimeout elapsed]------> HALF_OPEN
+ *   HALF_OPEN --[probe succeeds]----------> CLOSED
+ *   HALF_OPEN --[probe fails]-------------> OPEN
+ */
+declare class CircuitBreaker {
+    private state;
+    private failures;
+    private lastOpenedAt;
+    private readonly config;
+    constructor(config?: Partial<CircuitBreakerConfig>);
+    get currentState(): CircuitState;
+    recordSuccess(): void;
+    recordFailure(): void;
+    canExecute(): boolean;
+    reset(): void;
+}
+
+/** Tracks health metrics (latency EMA, error rate, slot lag) for a single RPC endpoint */
+declare class HealthTracker {
+    readonly endpoint: RpcEndpointConfig;
+    private readonly connection;
+    private readonly logger?;
+    private readonly breaker;
+    private metrics;
+    constructor(endpoint: RpcEndpointConfig, connection: Connection, logger?: Logger | undefined, circuitBreakerConfig?: Partial<CircuitBreakerConfig>);
+    healthCheck(): Promise<void>;
+    recordSuccess(latencyMs: number, slot?: number): void;
+    recordFailure(error: Error): void;
+    isAvailable(): boolean;
+    getMetrics(): Readonly<HealthMetrics>;
+    updateSlotLag(highestSlot: number): void;
+    getConnection(): Connection;
+    private updateErrorRate;
+}
+
+/**
+ * Wraps Connection.simulateTransaction with:
+ * - Structured result parsing
+ * - Log extraction
+ * - Error decoding
+ * - Compute unit extraction
+ */
+declare function simulateTransaction(connection: Connection, transaction: VersionedTransaction | Transaction, config?: SimulationConfig, logger?: Logger): Promise<SimulationResult>;
+
+/**
+ * Confirms a transaction by signature.
+ *
+ * Strategy:
+ * 1. Subscribe via WebSocket (onSignature) — fastest notification
+ * 2. Simultaneously poll getSignatureStatuses as fallback
+ * 3. Also poll getBlockHeight to detect blockhash expiry
+ * 4. First signal wins via Promise.race; losers cleaned up in finally
+ */
+declare class TransactionConfirmer {
+    private readonly logger?;
+    private readonly events?;
+    constructor(logger?: Logger | undefined, events?: TypedEventEmitter | undefined);
+    confirm(connection: Connection, signature: string, lastValidBlockHeight: number, config?: Partial<ConfirmationConfig>): Promise<ConfirmationResult>;
+    private subscribeWebSocket;
+    private pollForConfirmation;
+}
+
+/**
+ * Manages blockhash caching, TTL-based staleness, and background refresh.
+ * Uses promise coalescing to avoid redundant RPC calls.
+ */
+declare class BlockhashManager {
+    private readonly connection;
+    private readonly logger?;
+    private cache;
+    private refreshInterval?;
+    private fetchPromise;
+    private readonly config;
+    constructor(connection: Connection, config?: Partial<BlockhashManagerConfig>, logger?: Logger | undefined);
+    /** Start background refresh loop */
+    start(): void;
+    /** Get a valid blockhash. Fetches fresh one if cache is stale or missing */
+    getBlockhash(): Promise<BlockhashInfo>;
+    /** Force a fresh fetch (used after blockhash expiry during retry) */
+    refreshBlockhash(): Promise<BlockhashInfo>;
+    /** Check if the current blockhash is still valid by comparing block heights */
+    isBlockhashValid(): Promise<boolean>;
+    /** Get cached info without fetching */
+    getCachedBlockhash(): BlockhashInfo | null;
+    /** Stop background refresh */
+    destroy(): void;
+    private isStale;
+    private fetchBlockhash;
+}
+
+/** Error codes for all solana-tx-kit error types */
+declare enum SolTxErrorCode {
+    RETRIES_EXHAUSTED = "RETRIES_EXHAUSTED",
+    NON_RETRYABLE = "NON_RETRYABLE",
+    BLOCKHASH_EXPIRED = "BLOCKHASH_EXPIRED",
+    BLOCKHASH_FETCH_FAILED = "BLOCKHASH_FETCH_FAILED",
+    SIMULATION_FAILED = "SIMULATION_FAILED",
+    INSUFFICIENT_FUNDS = "INSUFFICIENT_FUNDS",
+    CONFIRMATION_TIMEOUT = "CONFIRMATION_TIMEOUT",
+    TRANSACTION_FAILED = "TRANSACTION_FAILED",
+    ALL_ENDPOINTS_UNHEALTHY = "ALL_ENDPOINTS_UNHEALTHY",
+    RATE_LIMITED = "RATE_LIMITED",
+    BUNDLE_FAILED = "BUNDLE_FAILED",
+    BUNDLE_DROPPED = "BUNDLE_DROPPED",
+    TIP_TOO_LOW = "TIP_TOO_LOW",
+    FEE_ESTIMATION_FAILED = "FEE_ESTIMATION_FAILED"
+}
+/** Structured error with a machine-readable code and optional cause/context */
+declare class SolTxError extends Error {
+    readonly code: SolTxErrorCode;
+    readonly cause?: Error | undefined;
+    readonly context?: Record<string, unknown> | undefined;
+    constructor(code: SolTxErrorCode, message: string, options?: {
+        cause?: Error | undefined;
+        context?: Record<string, unknown> | undefined;
+    });
+}
+/** A SolTxError that indicates the operation can be retried after a delay */
+declare class RetryableError extends SolTxError {
+    readonly retryAfterMs?: number | undefined;
+    constructor(code: SolTxErrorCode, message: string, options?: {
+        cause?: Error | undefined;
+        context?: Record<string, unknown> | undefined;
+        retryAfterMs?: number | undefined;
+    });
+}
+
+/** Type guard: returns true if the transaction is a VersionedTransaction */
+declare function isVersionedTransaction(tx: SolanaTransaction): tx is VersionedTransaction;
+/** Type guard: returns true if the transaction is a legacy Transaction */
+declare function isLegacyTransaction(tx: SolanaTransaction): tx is Transaction;
+
+declare const JITO_TIP_ACCOUNTS: readonly PublicKey[];
+declare const JITO_BLOCK_ENGINE_URL = "https://mainnet.block-engine.jito.wtf";
+
+/** Create a console-based logger with `[solana-tx-kit]` prefix. Pass your own Logger to override. */
+declare function createDefaultLogger(): Logger;
+
+export { type BlockhashInfo, BlockhashManager, type BlockhashManagerConfig, type BundleResult, BundleStatus, CircuitBreaker, type CircuitBreakerConfig, CircuitState, type ComputeBudgetConfig, type ConfirmationConfig, type ConfirmationResult, ConnectionPool, type ConnectionPoolConfig, type ErrorClassification, type FeeEstimateConfig, type FeeEstimateResult, type HealthMetrics, HealthTracker, JITO_BLOCK_ENGINE_URL, JITO_TIP_ACCOUNTS, JitoBundleSender, type JitoConfig, type Logger, type Result, type RetryConfig, type RetryContext, RetryableError, type RpcEndpointConfig, type SendOptions, type SendResult, type SenderConfig, type SimulationConfig, type SimulationResult, SolTxError, SolTxErrorCode, type SolanaTransaction, TransactionConfirmer, TransactionSender, TransactionSenderBuilder, TxEvent, type TxEventMap, TypedEventEmitter, classifyError, createComputeBudgetInstructions, createDefaultLogger, createTipInstruction, estimatePriorityFee, getNextTipAccount, isBlockhashExpired, isLegacyTransaction, isRateLimited, isVersionedTransaction, resetTipRotation, simulateTransaction, withRetry };