solana-tx-kit 0.1.0

package/dist/index.cjs

@@ -0,0 +1,1297 @@
+'use strict';
+
+var web3_js = require('@solana/web3.js');
+var events = require('events');
+
+// src/sender/transaction-sender.ts
+var JITO_TIP_ACCOUNTS = Object.freeze([
+  new web3_js.PublicKey("96gYZGLnJYVFmbjzopPSU6QiEV5fGqZNyN9nmNhvrZU5"),
+  new web3_js.PublicKey("HFqU5x63VTqvQss8hp11i4wVV8bD44PvwucfZ2bU7gRe"),
+  new web3_js.PublicKey("Cw8CFyM9FkoMi7K7Crf6HNQqf4uEMzpKw6QNghXLvLkY"),
+  new web3_js.PublicKey("ADaUMid9yfUytqMBgopwjb2DTLSokTSzL1zt6iGPaS49"),
+  new web3_js.PublicKey("DfXygSm4jCyNCybVYYK6DwvWqjKee8pbDmJGcLWNDXjh"),
+  new web3_js.PublicKey("ADuUkR4vqLUMWXxW9gh6D6L8pMSawimctcNZ5pGwDcEt"),
+  new web3_js.PublicKey("DttWaMuVvTiduZRnguLF7jNxTgiMBZ1hyAumKUiL2KRL"),
+  new web3_js.PublicKey("3AVi9Tg9Uo68tJfuvoKvqKNWKkC5wPdSSdeBnizKZ6jT")
+]);
+var JITO_BLOCK_ENGINE_URL = "https://mainnet.block-engine.jito.wtf";
+var JITO_MIN_TIP_LAMPORTS = 1e3;
+var DEFAULT_RETRY_CONFIG = {
+  maxRetries: 3,
+  baseDelayMs: 500,
+  maxDelayMs: 1e4,
+  backoffMultiplier: 2
+};
+var DEFAULT_PRIORITY_FEE_CONFIG = {
+  targetPercentile: 75,
+  maxMicroLamports: 1e6,
+  minMicroLamports: 1e3,
+  defaultComputeUnits: 2e5
+};
+var DEFAULT_CONFIRMATION_CONFIG = {
+  commitment: "confirmed",
+  timeoutMs: 6e4,
+  pollIntervalMs: 2e3,
+  useWebSocket: true
+};
+var DEFAULT_BLOCKHASH_CONFIG = {
+  ttlMs: 6e4,
+  refreshIntervalMs: 3e4,
+  commitment: "confirmed"
+};
+
+// src/errors.ts
+var SolTxErrorCode = /* @__PURE__ */ ((SolTxErrorCode2) => {
+  SolTxErrorCode2["RETRIES_EXHAUSTED"] = "RETRIES_EXHAUSTED";
+  SolTxErrorCode2["NON_RETRYABLE"] = "NON_RETRYABLE";
+  SolTxErrorCode2["BLOCKHASH_EXPIRED"] = "BLOCKHASH_EXPIRED";
+  SolTxErrorCode2["BLOCKHASH_FETCH_FAILED"] = "BLOCKHASH_FETCH_FAILED";
+  SolTxErrorCode2["SIMULATION_FAILED"] = "SIMULATION_FAILED";
+  SolTxErrorCode2["INSUFFICIENT_FUNDS"] = "INSUFFICIENT_FUNDS";
+  SolTxErrorCode2["CONFIRMATION_TIMEOUT"] = "CONFIRMATION_TIMEOUT";
+  SolTxErrorCode2["TRANSACTION_FAILED"] = "TRANSACTION_FAILED";
+  SolTxErrorCode2["ALL_ENDPOINTS_UNHEALTHY"] = "ALL_ENDPOINTS_UNHEALTHY";
+  SolTxErrorCode2["RATE_LIMITED"] = "RATE_LIMITED";
+  SolTxErrorCode2["BUNDLE_FAILED"] = "BUNDLE_FAILED";
+  SolTxErrorCode2["BUNDLE_DROPPED"] = "BUNDLE_DROPPED";
+  SolTxErrorCode2["TIP_TOO_LOW"] = "TIP_TOO_LOW";
+  SolTxErrorCode2["FEE_ESTIMATION_FAILED"] = "FEE_ESTIMATION_FAILED";
+  return SolTxErrorCode2;
+})(SolTxErrorCode || {});
+var SolTxError = class extends Error {
+  code;
+  cause;
+  context;
+  constructor(code, message, options) {
+    super(message);
+    this.name = "SolTxError";
+    this.code = code;
+    this.cause = options?.cause;
+    this.context = options?.context;
+  }
+};
+var RetryableError = class extends SolTxError {
+  retryAfterMs;
+  constructor(code, message, options) {
+    super(code, message, options);
+    this.name = "RetryableError";
+    this.retryAfterMs = options?.retryAfterMs;
+  }
+};
+
+// src/blockhash/blockhash-manager.ts
+var BlockhashManager = class {
+  constructor(connection, config, logger) {
+    this.connection = connection;
+    this.logger = logger;
+    this.config = { ...DEFAULT_BLOCKHASH_CONFIG, ...config };
+  }
+  cache = null;
+  refreshInterval;
+  fetchPromise = null;
+  config;
+  /** Start background refresh loop */
+  start() {
+    if (this.refreshInterval) return;
+    this.refreshInterval = setInterval(() => {
+      this.refreshBlockhash().catch((err) => {
+        this.logger?.warn("Background blockhash refresh failed", { error: String(err) });
+      });
+    }, this.config.refreshIntervalMs);
+  }
+  /** Get a valid blockhash. Fetches fresh one if cache is stale or missing */
+  async getBlockhash() {
+    if (this.cache && !this.isStale(this.cache)) {
+      return this.cache;
+    }
+    return this.refreshBlockhash();
+  }
+  /** Force a fresh fetch (used after blockhash expiry during retry) */
+  async refreshBlockhash() {
+    if (this.fetchPromise) {
+      return this.fetchPromise;
+    }
+    this.fetchPromise = this.fetchBlockhash();
+    try {
+      const info = await this.fetchPromise;
+      this.cache = info;
+      return info;
+    } finally {
+      this.fetchPromise = null;
+    }
+  }
+  /** Check if the current blockhash is still valid by comparing block heights */
+  async isBlockhashValid() {
+    if (!this.cache) return false;
+    try {
+      const currentHeight = await this.connection.getBlockHeight(this.config.commitment);
+      return currentHeight < this.cache.lastValidBlockHeight;
+    } catch {
+      return false;
+    }
+  }
+  /** Get cached info without fetching */
+  getCachedBlockhash() {
+    if (this.cache && !this.isStale(this.cache)) {
+      return this.cache;
+    }
+    return null;
+  }
+  /** Stop background refresh */
+  destroy() {
+    if (this.refreshInterval) {
+      clearInterval(this.refreshInterval);
+      this.refreshInterval = void 0;
+    }
+  }
+  isStale(info) {
+    return Date.now() - info.fetchedAt > this.config.ttlMs;
+  }
+  async fetchBlockhash() {
+    try {
+      const result = await this.connection.getLatestBlockhash(this.config.commitment);
+      const info = {
+        blockhash: result.blockhash,
+        lastValidBlockHeight: result.lastValidBlockHeight,
+        fetchedAt: Date.now()
+      };
+      this.logger?.debug("Fetched new blockhash", { blockhash: `${info.blockhash.slice(0, 12)}...` });
+      return info;
+    } catch (err) {
+      throw new SolTxError(
+        "BLOCKHASH_FETCH_FAILED" /* BLOCKHASH_FETCH_FAILED */,
+        "Failed to fetch blockhash. Verify your RPC endpoint is reachable and responding.",
+        { cause: err instanceof Error ? err : new Error(String(err)) }
+      );
+    }
+  }
+};
+var TxEvent = /* @__PURE__ */ ((TxEvent2) => {
+  TxEvent2["SENDING"] = "sending";
+  TxEvent2["SIMULATED"] = "simulated";
+  TxEvent2["SENT"] = "sent";
+  TxEvent2["CONFIRMING"] = "confirming";
+  TxEvent2["CONFIRMED"] = "confirmed";
+  TxEvent2["RETRYING"] = "retrying";
+  TxEvent2["BLOCKHASH_EXPIRED"] = "blockhash_expired";
+  TxEvent2["FAILED"] = "failed";
+  TxEvent2["BUNDLE_SENT"] = "bundle_sent";
+  TxEvent2["BUNDLE_CONFIRMED"] = "bundle_confirmed";
+  TxEvent2["BUNDLE_FAILED"] = "bundle_failed";
+  return TxEvent2;
+})(TxEvent || {});
+var TypedEventEmitter = class extends events.EventEmitter {
+  emit(event, data) {
+    return super.emit(event, data);
+  }
+  on(event, listener) {
+    return super.on(event, listener);
+  }
+  once(event, listener) {
+    return super.once(event, listener);
+  }
+};
+
+// src/confirmation/confirmer.ts
+var TransactionConfirmer = class {
+  constructor(logger, events) {
+    this.logger = logger;
+    this.events = events;
+  }
+  async confirm(connection, signature, lastValidBlockHeight, config) {
+    const resolved = { ...DEFAULT_CONFIRMATION_CONFIG, ...config };
+    const startTime = Date.now();
+    const latencyMs = () => Date.now() - startTime;
+    this.events?.emit("confirming" /* CONFIRMING */, { signature, commitment: resolved.commitment });
+    const cleanups = [];
+    try {
+      const races = [];
+      races.push(
+        new Promise((resolve) => {
+          const timer = setTimeout(() => resolve({ status: "expired", latencyMs: latencyMs() }), resolved.timeoutMs);
+          cleanups.push(() => clearTimeout(timer));
+        })
+      );
+      if (resolved.useWebSocket) {
+        races.push(this.subscribeWebSocket(connection, signature, resolved, latencyMs, cleanups));
+      }
+      races.push(this.pollForConfirmation(connection, signature, lastValidBlockHeight, resolved, latencyMs, cleanups));
+      return await Promise.race(races);
+    } finally {
+      for (const cleanup of cleanups) cleanup();
+    }
+  }
+  subscribeWebSocket(connection, signature, config, latencyMs, cleanups) {
+    return new Promise((resolve) => {
+      try {
+        const subId = connection.onSignature(
+          signature,
+          (result, context) => {
+            if (result.err) {
+              const errorMsg = typeof result.err === "string" ? result.err : JSON.stringify(result.err);
+              resolve({
+                status: "failed",
+                slot: context.slot,
+                error: { code: -1, message: errorMsg },
+                latencyMs: latencyMs()
+              });
+            } else {
+              resolve({
+                status: config.commitment === "finalized" ? "finalized" : "confirmed",
+                slot: context.slot,
+                latencyMs: latencyMs()
+              });
+            }
+          },
+          config.commitment
+        );
+        cleanups.push(() => {
+          connection.removeSignatureListener(subId).catch(() => {
+          });
+        });
+      } catch (err) {
+        this.logger?.warn("WebSocket subscription failed, relying on polling", { error: String(err) });
+      }
+    });
+  }
+  pollForConfirmation(connection, signature, lastValidBlockHeight, config, latencyMs, cleanups) {
+    return new Promise((resolve) => {
+      const timer = setInterval(async () => {
+        try {
+          const blockHeight = await connection.getBlockHeight(config.commitment);
+          if (blockHeight > lastValidBlockHeight) {
+            resolve({ status: "expired", latencyMs: latencyMs() });
+            return;
+          }
+          const statuses = await connection.getSignatureStatuses([signature]);
+          const status = statuses.value[0];
+          if (!status) return;
+          if (status.err) {
+            const errorMsg = typeof status.err === "string" ? status.err : JSON.stringify(status.err);
+            resolve({
+              status: "failed",
+              slot: status.slot,
+              error: { code: -1, message: errorMsg },
+              latencyMs: latencyMs()
+            });
+            return;
+          }
+          if (status.confirmationStatus === "finalized") {
+            resolve({ status: "finalized", slot: status.slot, latencyMs: latencyMs() });
+            return;
+          }
+          if ((status.confirmationStatus === "confirmed" || status.confirmationStatus === "processed") && config.commitment !== "finalized") {
+            resolve({ status: "confirmed", slot: status.slot, latencyMs: latencyMs() });
+          }
+        } catch (err) {
+          this.logger?.warn("Confirmation polling error", { error: String(err) });
+        }
+      }, config.pollIntervalMs);
+      cleanups.push(() => clearInterval(timer));
+    });
+  }
+};
+
+// src/utils.ts
+function isVersionedTransaction(tx) {
+  return "version" in tx;
+}
+function isLegacyTransaction(tx) {
+  return !isVersionedTransaction(tx);
+}
+
+// src/jito/types.ts
+var BundleStatus = /* @__PURE__ */ ((BundleStatus2) => {
+  BundleStatus2["SUBMITTED"] = "submitted";
+  BundleStatus2["PENDING"] = "pending";
+  BundleStatus2["LANDED"] = "landed";
+  BundleStatus2["FAILED"] = "failed";
+  BundleStatus2["DROPPED"] = "dropped";
+  BundleStatus2["INVALID"] = "invalid";
+  return BundleStatus2;
+})(BundleStatus || {});
+
+// src/jito/bundle-sender.ts
+function serializeTransaction(tx) {
+  if (isVersionedTransaction(tx)) {
+    return Buffer.from(tx.serialize()).toString("base64");
+  }
+  return tx.serialize().toString("base64");
+}
+var JitoBundleSender = class _JitoBundleSender {
+  constructor(config, logger, events) {
+    this.config = config;
+    this.logger = logger;
+    this.events = events;
+    this.blockEngineUrl = _JitoBundleSender.validateUrl(config.blockEngineUrl ?? JITO_BLOCK_ENGINE_URL);
+    this.pollIntervalMs = config.statusPollIntervalMs ?? 2e3;
+    this.timeoutMs = config.statusTimeoutMs ?? 6e4;
+  }
+  blockEngineUrl;
+  pollIntervalMs;
+  timeoutMs;
+  /** Submit a bundle and optionally wait for confirmation */
+  async sendBundle(transactions, options) {
+    if (transactions.length === 0 || transactions.length > 5) {
+      throw new SolTxError(
+        "BUNDLE_FAILED" /* BUNDLE_FAILED */,
+        `Bundle must contain 1-5 transactions, got ${transactions.length}`
+      );
+    }
+    const serialized = transactions.map(serializeTransaction);
+    const bundleId = await this.rpcCall("sendBundle", [serialized]);
+    this.logger?.info("Bundle submitted", { bundleId, txCount: transactions.length });
+    this.events?.emit("bundle_sent" /* BUNDLE_SENT */, { bundleId, txCount: transactions.length });
+    if (options?.waitForConfirmation) {
+      return this.waitForBundleStatus(bundleId);
+    }
+    return { bundleId, status: "submitted" /* SUBMITTED */ };
+  }
+  /** Poll getBundleStatuses until landed, failed, or timeout */
+  async waitForBundleStatus(bundleId) {
+    const startTime = Date.now();
+    while (Date.now() - startTime < this.timeoutMs) {
+      const statuses = await this.rpcCall("getBundleStatuses", [[bundleId]]);
+      const bundleInfo = statuses.value[0];
+      if (bundleInfo) {
+        if (bundleInfo.confirmation_status === "finalized" || bundleInfo.confirmation_status === "confirmed") {
+          const result2 = {
+            bundleId,
+            status: "landed" /* LANDED */,
+            slot: bundleInfo.slot,
+            latencyMs: Date.now() - startTime
+          };
+          this.events?.emit("bundle_confirmed" /* BUNDLE_CONFIRMED */, { bundleId, slot: bundleInfo.slot });
+          return result2;
+        }
+        if (bundleInfo.err?.Err) {
+          const result2 = {
+            bundleId,
+            status: "failed" /* FAILED */,
+            latencyMs: Date.now() - startTime
+          };
+          this.events?.emit("bundle_failed" /* BUNDLE_FAILED */, {
+            bundleId,
+            error: new Error(JSON.stringify(bundleInfo.err.Err))
+          });
+          return result2;
+        }
+      }
+      await new Promise((r) => setTimeout(r, this.pollIntervalMs));
+    }
+    const result = {
+      bundleId,
+      status: "dropped" /* DROPPED */,
+      latencyMs: Date.now() - startTime
+    };
+    this.events?.emit("bundle_failed" /* BUNDLE_FAILED */, { bundleId, error: new Error("Bundle status polling timed out") });
+    return result;
+  }
+  static validateUrl(url) {
+    if (!url.startsWith("https://") && !url.startsWith("http://")) {
+      throw new SolTxError(
+        "BUNDLE_FAILED" /* BUNDLE_FAILED */,
+        `Invalid block engine URL: must start with https:// or http://, got "${url}"`
+      );
+    }
+    return url.replace(/\/+$/, "");
+  }
+  /** Raw JSON-RPC call to the block engine */
+  async rpcCall(method, params) {
+    const url = `${this.blockEngineUrl}/api/v1/bundles`;
+    const response = await fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        jsonrpc: "2.0",
+        id: 1,
+        method,
+        params
+      })
+    });
+    if (!response.ok) {
+      throw new SolTxError("BUNDLE_FAILED" /* BUNDLE_FAILED */, `Jito block engine returned HTTP ${response.status}`, {
+        context: { status: response.status, method }
+      });
+    }
+    const json = await response.json();
+    if (json.error) {
+      throw new SolTxError("BUNDLE_FAILED" /* BUNDLE_FAILED */, `Jito RPC error: ${json.error.message}`, {
+        context: { code: json.error.code, method }
+      });
+    }
+    return json.result;
+  }
+};
+var tipIndex = 0;
+function getNextTipAccount() {
+  const idx = tipIndex % JITO_TIP_ACCOUNTS.length;
+  tipIndex++;
+  const account = JITO_TIP_ACCOUNTS[idx];
+  if (!account) throw new Error(`Invalid tip account index: ${idx}`);
+  return account;
+}
+function resetTipRotation() {
+  tipIndex = 0;
+}
+function createTipInstruction(payer, lamports) {
+  const tipAccount = getNextTipAccount();
+  return web3_js.SystemProgram.transfer({
+    fromPubkey: payer,
+    toPubkey: tipAccount,
+    lamports: Math.max(lamports, JITO_MIN_TIP_LAMPORTS)
+  });
+}
+
+// src/logger.ts
+function createDefaultLogger() {
+  return {
+    debug(msg, data) {
+      console.debug(`[solana-tx-kit] ${msg}`, data ?? "");
+    },
+    info(msg, data) {
+      console.info(`[solana-tx-kit] ${msg}`, data ?? "");
+    },
+    warn(msg, data) {
+      console.warn(`[solana-tx-kit] ${msg}`, data ?? "");
+    },
+    error(msg, data) {
+      console.error(`[solana-tx-kit] ${msg}`, data ?? "");
+    }
+  };
+}
+function createComputeBudgetInstructions(config) {
+  return [
+    web3_js.ComputeBudgetProgram.setComputeUnitLimit({ units: config.computeUnits }),
+    web3_js.ComputeBudgetProgram.setComputeUnitPrice({ microLamports: config.microLamports })
+  ];
+}
+
+// src/priority-fee/fee-estimator.ts
+function percentile(sorted, p) {
+  if (sorted.length === 0) return 0;
+  const index = Math.ceil(p / 100 * sorted.length) - 1;
+  return sorted[Math.max(0, index)] ?? 0;
+}
+async function estimatePriorityFee(connection, config) {
+  const resolved = { ...DEFAULT_PRIORITY_FEE_CONFIG, ...config };
+  try {
+    const accounts = resolved.writableAccounts?.map((a) => a.toBase58());
+    const fees = await connection.getRecentPrioritizationFees(
+      accounts ? { lockedWritableAccounts: accounts.map((a) => ({ toBase58: () => a })) } : void 0
+    );
+    const feeValues = fees.map((f) => f.prioritizationFee).filter((f) => f > 0);
+    feeValues.sort((a, b) => a - b);
+    const p50 = percentile(feeValues, 50);
+    const p75 = percentile(feeValues, 75);
+    const p90 = percentile(feeValues, 90);
+    let target;
+    switch (resolved.targetPercentile) {
+      case 50:
+        target = p50;
+        break;
+      case 90:
+        target = p90;
+        break;
+      default:
+        target = p75;
+    }
+    const clamped = Math.min(Math.max(target, resolved.minMicroLamports), resolved.maxMicroLamports);
+    return {
+      microLamports: clamped,
+      percentiles: { p50, p75, p90 },
+      sampleCount: feeValues.length
+    };
+  } catch (err) {
+    throw new SolTxError(
+      "FEE_ESTIMATION_FAILED" /* FEE_ESTIMATION_FAILED */,
+      "Failed to estimate priority fees. Use disablePriorityFees() or pass { priorityFee: { microLamports: N } } as a static override.",
+      { cause: err instanceof Error ? err : new Error(String(err)) }
+    );
+  }
+}
+
+// src/retry/error-classifier.ts
+var RETRYABLE_MESSAGES = [
+  "blockhash not found",
+  "block height exceeded",
+  "TransactionExpiredBlockheightExceeded",
+  "Node is behind",
+  "node is unhealthy",
+  "Service unavailable",
+  "Too many requests"
+];
+var NEEDS_RESIGN_MESSAGES = ["blockhash not found", "block height exceeded", "TransactionExpiredBlockheightExceeded"];
+var NETWORK_ERROR_CODES = ["ECONNRESET", "ETIMEDOUT", "ENOTFOUND", "ECONNREFUSED", "EAI_AGAIN", "EPIPE"];
+var NON_RETRYABLE_MESSAGES = [
+  "insufficient funds",
+  "Insufficient funds",
+  "invalid account data",
+  "Account not found",
+  "Signature verification failed",
+  "Transaction simulation failed: Error processing Instruction",
+  "Program failed to complete",
+  "already been processed"
+];
+function classifyError(error) {
+  const msg = error.message ?? "";
+  const code = error.code;
+  for (const pattern of NON_RETRYABLE_MESSAGES) {
+    if (msg.includes(pattern)) {
+      return { retryable: false, needsResign: false, errorType: pattern };
+    }
+  }
+  if (code && NETWORK_ERROR_CODES.includes(code)) {
+    return { retryable: true, needsResign: false, errorType: code };
+  }
+  if (msg.includes("429") || msg.includes("Too many requests")) {
+    return { retryable: true, needsResign: false, errorType: "RATE_LIMITED" };
+  }
+  if (msg.includes("503") || msg.includes("Service unavailable")) {
+    return { retryable: true, needsResign: false, errorType: "SERVICE_UNAVAILABLE" };
+  }
+  for (const pattern of RETRYABLE_MESSAGES) {
+    if (msg.includes(pattern)) {
+      const needsResign = NEEDS_RESIGN_MESSAGES.some((p) => msg.includes(p));
+      return { retryable: true, needsResign, errorType: pattern };
+    }
+  }
+  return { retryable: false, needsResign: false, errorType: "UNKNOWN" };
+}
+function isBlockhashExpired(error) {
+  const msg = error.message ?? "";
+  return NEEDS_RESIGN_MESSAGES.some((pattern) => msg.includes(pattern));
+}
+function isRateLimited(error) {
+  const msg = error.message ?? "";
+  return msg.includes("429") || msg.includes("Too many requests");
+}
+
+// src/retry/retry.ts
+function computeDelay(attempt, config) {
+  const exponential = config.baseDelayMs * config.backoffMultiplier ** attempt;
+  const capped = Math.min(exponential, config.maxDelayMs);
+  return Math.random() * capped;
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function withRetry(fn, config) {
+  const resolved = { ...DEFAULT_RETRY_CONFIG, ...config };
+  const startTime = Date.now();
+  let lastError;
+  for (let attempt = 0; attempt <= resolved.maxRetries; attempt++) {
+    const context = {
+      attempt,
+      totalAttempts: resolved.maxRetries + 1,
+      elapsed: Date.now() - startTime,
+      lastError
+    };
+    try {
+      return await fn(context);
+    } catch (err) {
+      const error = err instanceof Error ? err : new Error(String(err));
+      lastError = error;
+      if (attempt >= resolved.maxRetries) {
+        break;
+      }
+      if (resolved.retryPredicate) {
+        if (!resolved.retryPredicate(error, attempt)) {
+          throw new SolTxError("NON_RETRYABLE" /* NON_RETRYABLE */, `Non-retryable (custom predicate): ${error.message}`, {
+            cause: error,
+            context: { attempt }
+          });
+        }
+      } else {
+        const classification = classifyError(error);
+        if (!classification.retryable) {
+          throw new SolTxError("NON_RETRYABLE" /* NON_RETRYABLE */, `Non-retryable: ${error.message}`, {
+            cause: error,
+            context: { attempt, errorType: classification.errorType }
+          });
+        }
+      }
+      const delayMs = computeDelay(attempt, resolved);
+      if (resolved.onRetry) {
+        await resolved.onRetry(error, attempt, delayMs);
+      }
+      await sleep(delayMs);
+    }
+  }
+  throw new SolTxError("RETRIES_EXHAUSTED" /* RETRIES_EXHAUSTED */, `All ${resolved.maxRetries + 1} attempts failed`, {
+    cause: lastError ?? new Error("Unknown error"),
+    context: { maxRetries: resolved.maxRetries, elapsed: Date.now() - startTime }
+  });
+}
+
+// src/rpc/types.ts
+var CircuitState = /* @__PURE__ */ ((CircuitState2) => {
+  CircuitState2["CLOSED"] = "closed";
+  CircuitState2["OPEN"] = "open";
+  CircuitState2["HALF_OPEN"] = "half_open";
+  return CircuitState2;
+})(CircuitState || {});
+
+// src/rpc/circuit-breaker.ts
+var DEFAULT_CIRCUIT_BREAKER_CONFIG = {
+  failureThreshold: 5,
+  resetTimeoutMs: 3e4,
+  windowMs: 6e4
+};
+var CircuitBreaker = class {
+  state = "closed" /* CLOSED */;
+  failures = [];
+  lastOpenedAt = 0;
+  config;
+  constructor(config) {
+    this.config = { ...DEFAULT_CIRCUIT_BREAKER_CONFIG, ...config };
+  }
+  get currentState() {
+    if (this.state === "open" /* OPEN */) {
+      if (Date.now() - this.lastOpenedAt >= this.config.resetTimeoutMs) {
+        this.state = "half_open" /* HALF_OPEN */;
+      }
+    }
+    return this.state;
+  }
+  recordSuccess() {
+    if (this.state === "half_open" /* HALF_OPEN */) {
+      this.state = "closed" /* CLOSED */;
+      this.failures = [];
+    }
+  }
+  recordFailure() {
+    const now = Date.now();
+    if (this.state === "half_open" /* HALF_OPEN */) {
+      this.state = "open" /* OPEN */;
+      this.lastOpenedAt = now;
+      return;
+    }
+    this.failures = this.failures.filter((t) => now - t < this.config.windowMs);
+    this.failures.push(now);
+    if (this.failures.length >= this.config.failureThreshold) {
+      this.state = "open" /* OPEN */;
+      this.lastOpenedAt = now;
+    }
+  }
+  canExecute() {
+    const current = this.currentState;
+    return current === "closed" /* CLOSED */ || current === "half_open" /* HALF_OPEN */;
+  }
+  reset() {
+    this.state = "closed" /* CLOSED */;
+    this.failures = [];
+    this.lastOpenedAt = 0;
+  }
+};
+
+// src/rpc/health-tracker.ts
+var EMA_ALPHA = 0.3;
+var HealthTracker = class {
+  constructor(endpoint, connection, logger, circuitBreakerConfig) {
+    this.endpoint = endpoint;
+    this.connection = connection;
+    this.logger = logger;
+    this.breaker = new CircuitBreaker(circuitBreakerConfig);
+  }
+  breaker;
+  metrics = {
+    latencyEma: 0,
+    errorCount: 0,
+    successCount: 0,
+    errorRate: 0,
+    lastSlot: 0,
+    slotLag: 0,
+    lastSuccessAt: 0,
+    circuitState: "closed" /* CLOSED */
+  };
+  async healthCheck() {
+    const start = Date.now();
+    try {
+      const slot = await this.connection.getSlot();
+      const latency = Date.now() - start;
+      this.recordSuccess(latency, slot);
+    } catch (err) {
+      this.recordFailure(err instanceof Error ? err : new Error(String(err)));
+    }
+  }
+  recordSuccess(latencyMs, slot) {
+    this.metrics.successCount++;
+    this.metrics.lastSuccessAt = Date.now();
+    if (this.metrics.latencyEma === 0) {
+      this.metrics.latencyEma = latencyMs;
+    } else {
+      this.metrics.latencyEma = EMA_ALPHA * latencyMs + (1 - EMA_ALPHA) * this.metrics.latencyEma;
+    }
+    if (slot !== void 0) {
+      this.metrics.lastSlot = slot;
+    }
+    this.breaker.recordSuccess();
+    this.updateErrorRate();
+    this.metrics.circuitState = this.breaker.currentState;
+  }
+  recordFailure(error) {
+    this.metrics.errorCount++;
+    this.breaker.recordFailure();
+    this.updateErrorRate();
+    this.metrics.circuitState = this.breaker.currentState;
+    this.logger?.warn(`RPC endpoint ${this.endpoint.label ?? this.endpoint.url} error`, {
+      error: error.message,
+      circuitState: this.metrics.circuitState
+    });
+  }
+  isAvailable() {
+    return this.breaker.canExecute();
+  }
+  getMetrics() {
+    this.metrics.circuitState = this.breaker.currentState;
+    return { ...this.metrics };
+  }
+  updateSlotLag(highestSlot) {
+    this.metrics.slotLag = highestSlot - this.metrics.lastSlot;
+  }
+  getConnection() {
+    return this.connection;
+  }
+  updateErrorRate() {
+    const total = this.metrics.successCount + this.metrics.errorCount;
+    this.metrics.errorRate = total > 0 ? this.metrics.errorCount / total : 0;
+  }
+};
+
+// src/rpc/connection-pool.ts
+var ConnectionPool = class {
+  constructor(config, logger) {
+    this.logger = logger;
+    this.strategy = config.strategy ?? "weighted-round-robin";
+    for (const endpoint of config.endpoints) {
+      const connection = new web3_js.Connection(endpoint.url, {
+        commitment: config.healthCheckCommitment ?? "confirmed"
+      });
+      const tracker = new HealthTracker(endpoint, connection, logger, config.circuitBreaker);
+      this.trackers.push(tracker);
+    }
+    const interval = config.healthCheckIntervalMs ?? 1e4;
+    this.healthCheckInterval = setInterval(() => {
+      this.runHealthChecks();
+    }, interval);
+  }
+  trackers = [];
+  healthCheckInterval;
+  roundRobinIndex = 0;
+  strategy;
+  /** Get the best available connection based on strategy */
+  getConnection() {
+    const available = this.trackers.filter((t) => t.isAvailable());
+    if (available.length === 0) {
+      this.logger?.warn("All RPC endpoints unhealthy, using first endpoint as fallback");
+      const fallback = this.trackers[0];
+      if (!fallback) {
+        throw new SolTxError(
+          "ALL_ENDPOINTS_UNHEALTHY" /* ALL_ENDPOINTS_UNHEALTHY */,
+          "No RPC endpoints configured. Call .rpc() or .rpcPool() in the builder."
+        );
+      }
+      return fallback.getConnection();
+    }
+    if (this.strategy === "latency-based") {
+      return this.selectByLatency(available);
+    }
+    return this.selectByWeight(available);
+  }
+  /** Get a connection, falling back through endpoints if the first fails */
+  async withFallback(fn) {
+    const available = this.trackers.filter((t) => t.isAvailable());
+    const ordered = available.length > 0 ? available : this.trackers;
+    let lastError;
+    for (const tracker of ordered) {
+      const start = Date.now();
+      try {
+        const result = await fn(tracker.getConnection());
+        tracker.recordSuccess(Date.now() - start);
+        return result;
+      } catch (err) {
+        const error = err instanceof Error ? err : new Error(String(err));
+        tracker.recordFailure(error);
+        lastError = error;
+        this.logger?.warn(`Failover: ${tracker.endpoint.label ?? tracker.endpoint.url} failed`, {
+          error: error.message
+        });
+      }
+    }
+    throw new SolTxError(
+      "ALL_ENDPOINTS_UNHEALTHY" /* ALL_ENDPOINTS_UNHEALTHY */,
+      "All RPC endpoints failed. Check endpoint health via getHealthReport() or add backup endpoints with .rpcPool().",
+      { cause: lastError ?? new Error("No endpoints available") }
+    );
+  }
+  /** Get health metrics for all endpoints */
+  getHealthReport() {
+    const report = /* @__PURE__ */ new Map();
+    for (const tracker of this.trackers) {
+      const key = tracker.endpoint.label ?? tracker.endpoint.url;
+      report.set(key, tracker.getMetrics());
+    }
+    return report;
+  }
+  /** Stop background health checks */
+  destroy() {
+    if (this.healthCheckInterval) {
+      clearInterval(this.healthCheckInterval);
+      this.healthCheckInterval = void 0;
+    }
+  }
+  selectByLatency(available) {
+    const sorted = [...available].sort((a, b) => {
+      const aMetrics = a.getMetrics();
+      const bMetrics = b.getMetrics();
+      return aMetrics.latencyEma - bMetrics.latencyEma;
+    });
+    const best = sorted[0];
+    if (!best) throw new SolTxError("ALL_ENDPOINTS_UNHEALTHY" /* ALL_ENDPOINTS_UNHEALTHY */, "No endpoints available");
+    return best.getConnection();
+  }
+  selectByWeight(available) {
+    let totalWeight = 0;
+    for (const tracker of available) {
+      totalWeight += tracker.endpoint.weight ?? 1;
+    }
+    const position = this.roundRobinIndex % totalWeight;
+    this.roundRobinIndex++;
+    let cumulative = 0;
+    for (const tracker of available) {
+      cumulative += tracker.endpoint.weight ?? 1;
+      if (position < cumulative) {
+        return tracker.getConnection();
+      }
+    }
+    throw new SolTxError("ALL_ENDPOINTS_UNHEALTHY" /* ALL_ENDPOINTS_UNHEALTHY */, "No weighted endpoint available");
+  }
+  runHealthChecks() {
+    const promises = this.trackers.map((t) => t.healthCheck());
+    Promise.all(promises).then(() => {
+      let highestSlot = 0;
+      for (const tracker of this.trackers) {
+        const metrics = tracker.getMetrics();
+        if (metrics.lastSlot > highestSlot) {
+          highestSlot = metrics.lastSlot;
+        }
+      }
+      for (const tracker of this.trackers) {
+        tracker.updateSlotLag(highestSlot);
+      }
+    }).catch((err) => {
+      this.logger?.warn("Health check round failed", { error: String(err) });
+    });
+  }
+};
+
+// src/simulation/simulator.ts
+async function simulateTransaction(connection, transaction, config, logger) {
+  const commitment = config?.commitment ?? "confirmed";
+  const replaceRecentBlockhash = config?.replaceRecentBlockhash ?? true;
+  const sigVerify = config?.sigVerify ?? false;
+  try {
+    let err;
+    let logs = null;
+    let unitsConsumed;
+    if (isVersionedTransaction(transaction)) {
+      const result = await connection.simulateTransaction(transaction, {
+        commitment,
+        replaceRecentBlockhash,
+        sigVerify
+      });
+      err = result.value.err;
+      logs = result.value.logs;
+      unitsConsumed = result.value.unitsConsumed;
+    } else {
+      const result = await connection.simulateTransaction(transaction);
+      err = result.value.err;
+      logs = result.value.logs;
+      unitsConsumed = result.value.unitsConsumed;
+    }
+    if (err) {
+      const errorMessage = typeof err === "string" ? err : JSON.stringify(err);
+      logger?.warn("Simulation failed", { error: errorMessage });
+      let instructionError;
+      if (typeof err === "object" && err !== null && "InstructionError" in err) {
+        const ie = err.InstructionError;
+        instructionError = {
+          index: ie[0],
+          message: typeof ie[1] === "string" ? ie[1] : JSON.stringify(ie[1])
+        };
+      }
+      return {
+        success: false,
+        unitsConsumed: unitsConsumed ?? 0,
+        logs: logs ?? [],
+        error: {
+          code: typeof err === "object" && err !== null && "code" in err ? err.code : -1,
+          message: errorMessage,
+          ...instructionError ? { instructionError } : {}
+        }
+      };
+    }
+    logger?.debug("Simulation succeeded", { unitsConsumed: unitsConsumed ?? 0 });
+    return {
+      success: true,
+      unitsConsumed: unitsConsumed ?? 0,
+      logs: logs ?? []
+    };
+  } catch (err) {
+    const cause = err instanceof Error ? err : new Error(String(err));
+    throw new SolTxError("SIMULATION_FAILED" /* SIMULATION_FAILED */, `Transaction simulation failed: ${cause.message}`, {
+      cause
+    });
+  }
+}
+
+// src/sender/builder.ts
+var TransactionSenderBuilder = class {
+  config = {};
+  /** Set a single RPC endpoint */
+  rpc(url) {
+    this.config.rpc = { url };
+    return this;
+  }
+  /** Set multiple RPC endpoints with failover */
+  rpcPool(endpoints, options) {
+    const poolConfig = { endpoints };
+    if (options?.strategy) poolConfig.strategy = options.strategy;
+    if (options?.healthCheckIntervalMs) poolConfig.healthCheckIntervalMs = options.healthCheckIntervalMs;
+    this.config.rpc = poolConfig;
+    return this;
+  }
+  /** Set the transaction signer */
+  signer(keypair) {
+    this.config.signer = keypair;
+    return this;
+  }
+  /** Configure priority fee estimation */
+  withPriorityFees(config) {
+    this.config.priorityFee = config ?? {};
+    return this;
+  }
+  /** Disable automatic priority fee estimation */
+  disablePriorityFees() {
+    this.config.priorityFee = false;
+    return this;
+  }
+  /** Configure Jito bundle submission */
+  withJito(config) {
+    this.config.jito = config;
+    return this;
+  }
+  /** Configure retry behavior */
+  withRetry(config) {
+    this.config.retry = config;
+    return this;
+  }
+  /** Configure transaction simulation */
+  withSimulation(config) {
+    this.config.simulation = config ?? {};
+    return this;
+  }
+  /** Disable pre-flight simulation */
+  disableSimulation() {
+    this.config.simulation = false;
+    return this;
+  }
+  /** Configure confirmation tracking */
+  withConfirmation(config) {
+    this.config.confirmation = config;
+    return this;
+  }
+  /** Configure blockhash management */
+  withBlockhash(config) {
+    this.config.blockhash = config;
+    return this;
+  }
+  /** Set the logger */
+  withLogger(logger) {
+    this.config.logger = logger;
+    return this;
+  }
+  /** Set the default commitment */
+  commitment(level) {
+    this.config.commitment = level;
+    return this;
+  }
+  /** Build and return the TransactionSender */
+  build() {
+    if (!this.config.rpc) {
+      throw new Error("TransactionSenderBuilder: at least one RPC endpoint is required. Call .rpc() or .rpcPool()");
+    }
+    if (!this.config.signer) {
+      throw new Error("TransactionSenderBuilder: signer is required. Call .signer()");
+    }
+    return new TransactionSender(this.config);
+  }
+};
+
+// src/sender/types.ts
+function isConnectionPoolConfig(config) {
+  return "endpoints" in config;
+}
+function isStaticFee(config) {
+  return "microLamports" in config && !("targetPercentile" in config);
+}
+
+// src/sender/transaction-sender.ts
+var TransactionSender = class {
+  events;
+  pool;
+  blockhashManager;
+  confirmer;
+  jitoBundleSender;
+  logger;
+  config;
+  /** @param config - Full sender configuration. Prefer using {@link TransactionSender.builder} for construction. */
+  constructor(config) {
+    this.config = config;
+    this.logger = config.logger ?? createDefaultLogger();
+    this.events = new TypedEventEmitter();
+    if (isConnectionPoolConfig(config.rpc)) {
+      this.pool = new ConnectionPool(config.rpc, this.logger);
+    } else {
+      this.pool = new ConnectionPool({ endpoints: [{ url: config.rpc.url }] }, this.logger);
+    }
+    const primaryConnection = this.pool.getConnection();
+    this.blockhashManager = new BlockhashManager(primaryConnection, config.blockhash, this.logger);
+    this.blockhashManager.start();
+    this.confirmer = new TransactionConfirmer(this.logger, this.events);
+    if (config.jito) {
+      this.jitoBundleSender = new JitoBundleSender(config.jito, this.logger, this.events);
+    }
+  }
+  /** Create a fluent builder for configuring and constructing a TransactionSender */
+  static builder() {
+    return new 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.
+   */
+  async send(transaction, options) {
+    const startTime = Date.now();
+    const commitment = options?.commitment ?? this.config.commitment ?? "confirmed";
+    const { tx, feeAmount } = await this.prepareTransaction(transaction, options);
+    return withRetry(
+      async (ctx) => {
+        const blockhashInfo = await this.blockhashManager.getBlockhash();
+        this.signTransaction(tx, blockhashInfo);
+        const unitsConsumed = await this.runSimulation(tx, options);
+        this.events.emit("sending" /* SENDING */, { transaction: tx, attempt: ctx.attempt });
+        const signature = await this.sendRawTransaction(tx);
+        this.events.emit("sent" /* SENT */, { signature, attempt: ctx.attempt });
+        if (options?.skipConfirmation) {
+          return this.buildResult(signature, 0, commitment, ctx.attempt, startTime, unitsConsumed, feeAmount);
+        }
+        const slot = await this.awaitConfirmation(signature, blockhashInfo.lastValidBlockHeight, commitment);
+        return this.buildResult(signature, slot, commitment, ctx.attempt, startTime, unitsConsumed, feeAmount);
+      },
+      {
+        ...this.config.retry,
+        ...options?.retry,
+        onRetry: async (error, attempt, delayMs) => {
+          this.events.emit("retrying" /* RETRYING */, {
+            attempt,
+            maxRetries: this.config.retry?.maxRetries ?? 3,
+            error,
+            delayMs
+          });
+          if (isBlockhashExpired(error)) {
+            const oldBlockhash = this.blockhashManager.getCachedBlockhash()?.blockhash ?? "";
+            await this.blockhashManager.refreshBlockhash();
+            const newBlockhash = this.blockhashManager.getCachedBlockhash()?.blockhash ?? "";
+            this.events.emit("blockhash_expired" /* BLOCKHASH_EXPIRED */, { oldBlockhash, newBlockhash });
+          }
+        }
+      }
+    );
+  }
+  /**
+   * Send a bundle of 1-5 transactions via Jito.
+   * Automatically appends tip instruction to the last transaction.
+   */
+  async sendJitoBundle(transactions, options) {
+    if (!this.jitoBundleSender) {
+      throw new SolTxError("BUNDLE_FAILED" /* BUNDLE_FAILED */, "Jito is not configured. Use .withJito() in the builder.");
+    }
+    const jitoConfig = this.config.jito;
+    const tipLamports = options?.tipLamports ?? jitoConfig.tipLamports ?? 1e4;
+    const lastTx = transactions[transactions.length - 1];
+    if (lastTx && isLegacyTransaction(lastTx)) {
+      const tipIx = createTipInstruction(jitoConfig.tipPayer.publicKey, tipLamports);
+      lastTx.add(tipIx);
+    }
+    for (const tx of transactions) {
+      const blockhashInfo = await this.blockhashManager.getBlockhash();
+      if (isLegacyTransaction(tx)) {
+        tx.recentBlockhash = blockhashInfo.blockhash;
+        tx.feePayer = this.config.signer.publicKey;
+        tx.sign(this.config.signer);
+      } else {
+        tx.message.recentBlockhash = blockhashInfo.blockhash;
+        tx.sign([this.config.signer]);
+      }
+    }
+    return this.jitoBundleSender.sendBundle(transactions, {
+      waitForConfirmation: options?.waitForConfirmation ?? true
+    });
+  }
+  /** Get current RPC health metrics */
+  getHealthReport() {
+    return this.pool.getHealthReport();
+  }
+  /** Clean up: stop background tasks, clear intervals */
+  destroy() {
+    this.pool.destroy();
+    this.blockhashManager.destroy();
+    this.events.removeAllListeners();
+  }
+  /** Build a working copy of the transaction with compute budget instructions prepended */
+  async prepareTransaction(transaction, options) {
+    if (this.config.priorityFee !== false && isLegacyTransaction(transaction)) {
+      const feeAmount = await this.resolvePriorityFee(options);
+      const computeUnits = options?.computeUnits ?? DEFAULT_PRIORITY_FEE_CONFIG.defaultComputeUnits;
+      const budgetInstructions = createComputeBudgetInstructions({
+        computeUnits,
+        microLamports: feeAmount
+      });
+      const copy = new web3_js.Transaction();
+      for (const ix of budgetInstructions) copy.add(ix);
+      for (const ix of transaction.instructions) copy.add(ix);
+      return { tx: copy, feeAmount };
+    }
+    return { tx: transaction, feeAmount: void 0 };
+  }
+  /** Set blockhash, fee payer, and sign the transaction */
+  signTransaction(tx, blockhashInfo) {
+    if (isLegacyTransaction(tx)) {
+      tx.recentBlockhash = blockhashInfo.blockhash;
+      tx.feePayer = this.config.signer.publicKey;
+      tx.sign(this.config.signer);
+    } else {
+      tx.message.recentBlockhash = blockhashInfo.blockhash;
+      tx.sign([this.config.signer]);
+    }
+  }
+  /** Run simulation if enabled; returns compute units consumed */
+  async runSimulation(tx, options) {
+    const skip = options?.skipSimulation ?? this.config.simulation === false;
+    if (skip) return void 0;
+    const conn = this.pool.getConnection();
+    const simConfig = this.config.simulation !== false ? this.config.simulation : void 0;
+    const simResult = await simulateTransaction(conn, tx, simConfig, this.logger);
+    this.events.emit("simulated" /* SIMULATED */, {
+      signature: "",
+      unitsConsumed: simResult.unitsConsumed,
+      logs: simResult.logs
+    });
+    if (!simResult.success) {
+      throw new SolTxError(
+        "SIMULATION_FAILED" /* SIMULATION_FAILED */,
+        `Simulation failed: ${simResult.error?.message ?? "unknown error"}`,
+        { context: { logs: simResult.logs } }
+      );
+    }
+    return simResult.unitsConsumed;
+  }
+  /** Send serialized transaction via the connection pool with fallback */
+  async sendRawTransaction(tx) {
+    return this.pool.withFallback(async (conn) => {
+      const serialized = tx.serialize();
+      return conn.sendRawTransaction(serialized, {
+        skipPreflight: true,
+        maxRetries: 0
+      });
+    });
+  }
+  /** Confirm a transaction and return its slot, or throw on failure/expiry */
+  async awaitConfirmation(signature, lastValidBlockHeight, commitment) {
+    const conn = this.pool.getConnection();
+    const confirmResult = await this.confirmer.confirm(conn, signature, lastValidBlockHeight, this.config.confirmation);
+    if (confirmResult.status === "failed") {
+      throw new SolTxError(
+        "TRANSACTION_FAILED" /* TRANSACTION_FAILED */,
+        confirmResult.error?.message ?? "Transaction failed on chain"
+      );
+    }
+    if (confirmResult.status === "expired") {
+      throw new SolTxError("BLOCKHASH_EXPIRED" /* BLOCKHASH_EXPIRED */, "Blockhash expired during confirmation");
+    }
+    this.events.emit("confirmed" /* CONFIRMED */, { signature, slot: confirmResult.slot ?? 0, commitment });
+    return confirmResult.slot ?? 0;
+  }
+  /** Construct a SendResult */
+  buildResult(signature, slot, commitment, attempt, startTime, unitsConsumed, priorityFee) {
+    return {
+      signature,
+      slot,
+      commitment,
+      attempts: attempt + 1,
+      totalLatencyMs: Date.now() - startTime,
+      unitsConsumed,
+      priorityFee
+    };
+  }
+  async resolvePriorityFee(options) {
+    if (options?.priorityFee && isStaticFee(options.priorityFee)) {
+      return options.priorityFee.microLamports;
+    }
+    const conn = this.pool.getConnection();
+    let feeConfig;
+    if (options?.priorityFee && !isStaticFee(options.priorityFee)) {
+      feeConfig = options.priorityFee;
+    } else if (this.config.priorityFee !== false && this.config.priorityFee !== void 0) {
+      feeConfig = this.config.priorityFee;
+    }
+    const result = await estimatePriorityFee(conn, feeConfig);
+    return result.microLamports;
+  }
+};
+
+exports.BlockhashManager = BlockhashManager;
+exports.BundleStatus = BundleStatus;
+exports.CircuitBreaker = CircuitBreaker;
+exports.CircuitState = CircuitState;
+exports.ConnectionPool = ConnectionPool;
+exports.HealthTracker = HealthTracker;
+exports.JITO_BLOCK_ENGINE_URL = JITO_BLOCK_ENGINE_URL;
+exports.JITO_TIP_ACCOUNTS = JITO_TIP_ACCOUNTS;
+exports.JitoBundleSender = JitoBundleSender;
+exports.RetryableError = RetryableError;
+exports.SolTxError = SolTxError;
+exports.SolTxErrorCode = SolTxErrorCode;
+exports.TransactionConfirmer = TransactionConfirmer;
+exports.TransactionSender = TransactionSender;
+exports.TransactionSenderBuilder = TransactionSenderBuilder;
+exports.TxEvent = TxEvent;
+exports.TypedEventEmitter = TypedEventEmitter;
+exports.classifyError = classifyError;
+exports.createComputeBudgetInstructions = createComputeBudgetInstructions;
+exports.createDefaultLogger = createDefaultLogger;
+exports.createTipInstruction = createTipInstruction;
+exports.estimatePriorityFee = estimatePriorityFee;
+exports.getNextTipAccount = getNextTipAccount;
+exports.isBlockhashExpired = isBlockhashExpired;
+exports.isLegacyTransaction = isLegacyTransaction;
+exports.isRateLimited = isRateLimited;
+exports.isVersionedTransaction = isVersionedTransaction;
+exports.resetTipRotation = resetTipRotation;
+exports.simulateTransaction = simulateTransaction;
+exports.withRetry = withRetry;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map