@lifi/sdk 3.14.0-alpha.0 → 3.14.0

package/src/_types/types/internal.d.ts

@@ -1,5 +1,7 @@
 import type { ChainId, ExtendedChain, RouteOptions } from '@lifi/types';
 import type { SDKProvider } from '../core/types.js';
+import type { ExtendedRequestInit } from './request.js';
+export type RequestInterceptor = (request: ExtendedRequestInit) => ExtendedRequestInit | Promise<ExtendedRequestInit>;
 export interface SDKBaseConfig {
     apiKey?: string;
     apiUrl: string;
@@ -13,6 +15,7 @@ export interface SDKBaseConfig {
     widgetVersion?: string;
     preloadChains: boolean;
     debug: boolean;
+    requestInterceptor?: RequestInterceptor;
 }
 export interface SDKConfig extends Partial<Omit<SDKBaseConfig, 'integrator'>> {
     integrator: string;

package/src/_types/types/internal.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"internal.d.ts","sourceRoot":"","sources":["../../types/internal.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AACvE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAA;AAEnD,MAAM,WAAW,aAAa;IAC5B,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,MAAM,EAAE,MAAM,CAAA;IACd,UAAU,EAAE,MAAM,CAAA;IAClB,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,SAAS,EAAE,WAAW,EAAE,CAAA;IACxB,YAAY,CAAC,EAAE,YAAY,CAAA;IAC3B,OAAO,EAAE,OAAO,CAAA;IAChB,MAAM,EAAE,aAAa,EAAE,CAAA;IACvB,mBAAmB,CAAC,EAAE,OAAO,CAAA;IAC7B,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB,aAAa,EAAE,OAAO,CAAA;IACtB,KAAK,EAAE,OAAO,CAAA;CACf;AAED,MAAM,WAAW,SAAU,SAAQ,OAAO,CAAC,IAAI,CAAC,aAAa,EAAE,YAAY,CAAC,CAAC;IAC3E,UAAU,EAAE,MAAM,CAAA;CACnB;AAED,MAAM,MAAM,OAAO,GAAG,OAAO,CAAC,MAAM,CAAC,OAAO,EAAE,MAAM,EAAE,CAAC,CAAC,CAAA"}
+{"version":3,"file":"internal.d.ts","sourceRoot":"","sources":["../../types/internal.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AACvE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAA;AACnD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAA;AAEvD,MAAM,MAAM,kBAAkB,GAAG,CAC/B,OAAO,EAAE,mBAAmB,KACzB,mBAAmB,GAAG,OAAO,CAAC,mBAAmB,CAAC,CAAA;AAEvD,MAAM,WAAW,aAAa;IAC5B,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,MAAM,EAAE,MAAM,CAAA;IACd,UAAU,EAAE,MAAM,CAAA;IAClB,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,SAAS,EAAE,WAAW,EAAE,CAAA;IACxB,YAAY,CAAC,EAAE,YAAY,CAAA;IAC3B,OAAO,EAAE,OAAO,CAAA;IAChB,MAAM,EAAE,aAAa,EAAE,CAAA;IACvB,mBAAmB,CAAC,EAAE,OAAO,CAAA;IAC7B,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB,aAAa,EAAE,OAAO,CAAA;IACtB,KAAK,EAAE,OAAO,CAAA;IACd,kBAAkB,CAAC,EAAE,kBAAkB,CAAA;CACxC;AAED,MAAM,WAAW,SAAU,SAAQ,OAAO,CAAC,IAAI,CAAC,aAAa,EAAE,YAAY,CAAC,CAAC;IAC3E,UAAU,EAAE,MAAM,CAAA;CACnB;AAED,MAAM,MAAM,OAAO,GAAG,OAAO,CAAC,MAAM,CAAC,OAAO,EAAE,MAAM,EAAE,CAAC,CAAC,CAAA"}

package/src/_types/version.d.ts

@@ -1,3 +1,3 @@
 export declare const name = "@lifi/sdk";
-export declare const version = "3.14.0-alpha.0";
+export declare const version = "3.14.0";
 //# sourceMappingURL=version.d.ts.map

package/src/_types/version.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"version.d.ts","sourceRoot":"","sources":["../version.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,IAAI,cAAc,CAAA;AAC/B,eAAO,MAAM,OAAO,mBAAmB,CAAA"}
+{"version":3,"file":"version.d.ts","sourceRoot":"","sources":["../version.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,IAAI,cAAc,CAAA;AAC/B,eAAO,MAAM,OAAO,WAAW,CAAA"}

package/src/core/EVM/EVMStepExecutor.ts

@@ -222,6 +222,7 @@ export class EVMStepExecutor extends BaseStepExecutor {
   }
 
   private prepareUpdatedStep = async (
+    client: Client,
     step: LiFiStepExtended,
     signedTypedData?: SignedTypedData[]
   ) => {
@@ -280,6 +281,7 @@ export class EVMStepExecutor extends BaseStepExecutor {
     let transactionRequest: TransactionParameters | undefined
     if (step.transactionRequest) {
       transactionRequest = {
+        chainId: step.transactionRequest.chainId,
         to: step.transactionRequest.to,
         from: step.transactionRequest.from,
         data: step.transactionRequest.data,
@@ -296,8 +298,8 @@ export class EVMStepExecutor extends BaseStepExecutor {
         //   ? BigInt(step.transactionRequest.maxFeePerGas as string)
         //   : undefined,
         maxPriorityFeePerGas:
-          this.client.account?.type === 'local'
-            ? await getMaxPriorityFeePerGas(this.client)
+          client.account?.type === 'local'
+            ? await getMaxPriorityFeePerGas(client)
             : step.transactionRequest.maxPriorityFeePerGas
               ? BigInt(step.transactionRequest.maxPriorityFeePerGas)
               : undefined,
@@ -525,9 +527,15 @@ export class EVMStepExecutor extends BaseStepExecutor {
 
       await checkBalance(this.client.account!.address, step)
 
+      // Make sure that the client and chain is still correct
+      const updatedClient = await this.checkClient(step, process)
+      if (!updatedClient) {
+        return step
+      }
+
       // Try to prepare a new transaction request and update the step with typed data
       let { transactionRequest, isRelayerTransaction } =
-        await this.prepareUpdatedStep(step, signedTypedData)
+        await this.prepareUpdatedStep(updatedClient, step, signedTypedData)
 
       process = this.statusManager.updateProcess(
         step,

package/src/core/Solana/SolanaStepExecutor.ts

@@ -198,7 +198,7 @@ export class SolanaStepExecutor extends BaseStepExecutor {
           )
         }
 
-        let confirmedTx: any
+        let confirmedTransaction: any
 
         if (shouldUseJitoBundle) {
           // Use Jito bundle for multiple transactions
@@ -235,17 +235,17 @@ export class SolanaStepExecutor extends BaseStepExecutor {
 
           // Use the first transaction's signature result for reporting
           // (all transactions succeeded if we reach here)
-          confirmedTx = {
+          confirmedTransaction = {
             signatureResult: bundleResult.signatureResults[0],
             txSignature: bundleResult.txSignatures[0],
             bundleId: bundleResult.bundleId,
           }
         } else {
           // Use regular transaction for single transaction
-          const signedTx = signedTransactions[0]
+          const signedTransaction = signedTransactions[0]
 
           const simulationResult = await callSolanaWithRetry((connection) =>
-            connection.simulateTransaction(signedTx, {
+            connection.simulateTransaction(signedTransaction, {
               commitment: 'confirmed',
               replaceRecentBlockhash: true,
             })
@@ -258,21 +258,22 @@ export class SolanaStepExecutor extends BaseStepExecutor {
             )
           }
 
-          confirmedTx = await sendAndConfirmTransaction(signedTx)
+          confirmedTransaction =
+            await sendAndConfirmTransaction(signedTransaction)
         }
 
-        if (!confirmedTx.signatureResult) {
+        if (!confirmedTransaction.signatureResult) {
           throw new TransactionError(
             LiFiErrorCode.TransactionExpired,
             'Transaction has expired: The block height has exceeded the maximum allowed limit.'
           )
         }
 
-        if (confirmedTx.signatureResult.err) {
+        if (confirmedTransaction.signatureResult.err) {
           const reason =
-            typeof confirmedTx.signatureResult.err === 'object'
-              ? JSON.stringify(confirmedTx.signatureResult.err)
-              : confirmedTx.signatureResult.err
+            typeof confirmedTransaction.signatureResult.err === 'object'
+              ? JSON.stringify(confirmedTransaction.signatureResult.err)
+              : confirmedTransaction.signatureResult.err
           throw new TransactionError(
             LiFiErrorCode.TransactionFailed,
             `Transaction failed: ${reason}`
@@ -285,8 +286,8 @@ export class SolanaStepExecutor extends BaseStepExecutor {
           process.type,
           'PENDING',
           {
-            txHash: confirmedTx.txSignature,
-            txLink: `${fromChain.metamask.blockExplorerUrls[0]}tx/${confirmedTx.txSignature}`,
+            txHash: confirmedTransaction.txSignature,
+            txLink: `${fromChain.metamask.blockExplorerUrls[0]}tx/${confirmedTransaction.txSignature}`,
           }
         )
 

package/src/core/Solana/connection.ts

@@ -1,23 +1,8 @@
 import { ChainId } from '@lifi/types'
-import { type Cluster, Connection } from '@solana/web3.js'
+import { Connection } from '@solana/web3.js'
 import { getRpcUrls } from '../rpc.js'
-import { isJitoRpc } from './jito/isJitoRpc.js'
 import { JitoConnection } from './jito/JitoConnection.js'
 
-/**
- * Detect the cluster (network) from an RPC URL
- */
-const detectCluster = (rpcUrl: string): Cluster => {
-  const url = rpcUrl.toLowerCase()
-  if (url.includes('devnet')) {
-    return 'devnet'
-  }
-  if (url.includes('testnet')) {
-    return 'testnet'
-  }
-  return 'mainnet-beta'
-}
-
 const connections = new Map<string, Connection | JitoConnection>()
 
 /**
@@ -28,8 +13,8 @@ const ensureConnections = async (): Promise<void> => {
   const rpcUrls = await getRpcUrls(ChainId.SOL)
   for (const rpcUrl of rpcUrls) {
     if (!connections.get(rpcUrl)) {
-      const connection = (await isJitoRpc(rpcUrl))
-        ? new JitoConnection(rpcUrl, detectCluster(rpcUrl))
+      const connection = (await JitoConnection.isJitoRpc(rpcUrl))
+        ? new JitoConnection(rpcUrl)
         : new Connection(rpcUrl)
       connections.set(rpcUrl, connection)
     }
@@ -38,17 +23,19 @@ const ensureConnections = async (): Promise<void> => {
 
 /**
  * Wrapper around getting the connection (RPC provider) for Solana
- * @returns - Solana RPC connections
+ * Returns only non-Jito RPC connections (excludes JitoConnection instances)
+ * @returns - Solana RPC connections (excluding Jito connections)
  */
-export const getSolanaConnections = async (): Promise<
-  (Connection | JitoConnection)[]
-> => {
+export const getSolanaConnections = async (): Promise<Connection[]> => {
   await ensureConnections()
-  return Array.from(connections.values())
+  return Array.from(connections.values()).filter(
+    (conn): conn is Connection =>
+      conn instanceof Connection && !(conn instanceof JitoConnection)
+  )
 }
 
 /**
- * Get Jito-enabled connections only
+ * Get Jito-enabled connections only.
  * @returns - Array of JitoConnection instances
  */
 export const getJitoConnections = async (): Promise<JitoConnection[]> => {
@@ -78,5 +65,5 @@ export async function callSolanaWithRetry<R>(
     }
   }
   // Throw the last encountered error
-  throw lastError
+  throw lastError || new Error('No Solana RPC connections available')
 }

package/src/core/Solana/jito/JitoConnection.ts

@@ -1,8 +1,4 @@
-import {
-  type Cluster,
-  Connection,
-  type VersionedTransaction,
-} from '@solana/web3.js'
+import { Connection, type VersionedTransaction } from '@solana/web3.js'
 import { uint8ArrayToBase64 } from '../../../utils/uint8ArrayToBase64.js'
 import { JITO_TIP_ACCOUNTS } from './constants.js'
 
@@ -17,41 +13,92 @@ export type SimulateBundleResult = {
   }
 }
 
+export type BundleStatus = {
+  bundle_id: string
+  transactions: string[]
+  slot: number
+  confirmation_status: 'processed' | 'confirmed' | 'finalized'
+  err:
+    | {
+        Ok: null
+      }
+    | any
+}
+
+export type BundleStatusResult = {
+  context: {
+    slot: number
+  }
+  value: BundleStatus[]
+}
+
+/**
+ * Makes a direct RPC request to an endpoint
+ *
+ */
+async function rpcRequest<T>(
+  endpoint: string,
+  method: string,
+  params: any[]
+): Promise<T> {
+  const response = await fetch(endpoint, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+    },
+    body: JSON.stringify({
+      jsonrpc: '2.0',
+      id: 1,
+      method,
+      params,
+    }),
+  })
+  if (!response.ok) {
+    throw new Error(`Jito RPC Error: ${response.status} ${response.statusText}`)
+  }
+  const data = await response.json()
+  if (data.error) {
+    throw new Error(`Jito RPC Error: ${data.error.message}`)
+  }
+  return data.result
+}
+
 /**
  * Extended Connection class with Jito bundle support
  * Adds simulateBundle, sendBundle, and getTipAccounts methods
  */
 export class JitoConnection extends Connection {
   private tipAccountsCache: string[] | null = null
-  private cluster: Cluster
 
-  constructor(endpoint: string, cluster: Cluster = 'mainnet-beta') {
-    super(endpoint)
-    this.cluster = cluster
+  /**
+   * Check if an RPC endpoint supports Jito bundles
+   * @param rpcUrl - The RPC endpoint URL to check
+   * @returns true if the endpoint supports Jito bundle methods
+   */
+  static async isJitoRpc(rpcUrl: string): Promise<boolean> {
+    try {
+      // method exists if the request is successfull and doesn't throw an error
+      await rpcRequest(rpcUrl, 'getTipAccounts', [])
+      return true
+    } catch {
+      return false
+    }
   }
 
   /**
    * Makes a direct RPC request to the Jito-enabled endpoint
    */
-  private async rpcRequest<T>(method: string, params: any[]): Promise<T> {
-    const response = await fetch(this.rpcEndpoint, {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-      },
-      body: JSON.stringify({
-        jsonrpc: '2.0',
-        id: 1,
-        method,
+  protected async rpcRequest<T>(method: string, params: any[]): Promise<T> {
+    try {
+      return await rpcRequest(this.rpcEndpoint, method, params)
+    } catch (error) {
+      console.error(`Jito RPC request failed: ${method}`, {
+        endpoint: this.rpcEndpoint,
         params,
-      }),
-    })
-
-    const data = await response.json()
-    if (data.error) {
-      throw new Error(`Jito RPC Error: ${data.error.message}`)
+        error,
+      })
+      throw error
     }
-    return data.result
   }
 
   /**
@@ -62,7 +109,7 @@ export class JitoConnection extends Connection {
   }
 
   /**
-   * Get the tip accounts from the Jito endpoint
+   * Get the tip accounts from the Jito endpoint, using fallbacks if results are empty
    * Results are cached to avoid repeated RPC calls
    */
   async getTipAccounts(): Promise<string[]> {
@@ -72,12 +119,15 @@ export class JitoConnection extends Connection {
 
     try {
       const accounts = await this.rpcRequest<string[]>('getTipAccounts', [])
+      if (!accounts.length) {
+        throw new Error('RPC has no tip accounts')
+      }
       this.tipAccountsCache = accounts
       return accounts
     } catch (error) {
-      const fallbackAccounts = JITO_TIP_ACCOUNTS[this.cluster]
+      const fallbackAccounts = JITO_TIP_ACCOUNTS
       console.warn(
-        `Failed to fetch tip accounts from RPC, using ${this.cluster} fallback:`,
+        `Failed to fetch tip accounts from RPC, using  fallback`,
         error
       )
       return fallbackAccounts
@@ -92,6 +142,15 @@ export class JitoConnection extends Connection {
     return accounts[Math.floor(Math.random() * accounts.length)]
   }
 
+  /**
+   * Manually refresh the tip accounts cache
+   * Useful for long-running processes that may need updated tip accounts
+   */
+  async refreshTipAccounts(): Promise<string[]> {
+    this.tipAccountsCache = null
+    return this.getTipAccounts()
+  }
+
   /**
    * Simulate a bundle before sending it
    * @param bundle - Array of signed transactions
@@ -119,4 +178,13 @@ export class JitoConnection extends Connection {
     )
     return this.rpcRequest<string>('sendBundle', [encodedTransactions])
   }
+
+  /**
+   * Get the status of submitted bundles
+   * @param bundleIds - Array of bundle UUIDs to check
+   * @returns Bundle status information
+   */
+  async getBundleStatuses(bundleIds: string[]): Promise<BundleStatusResult> {
+    return this.rpcRequest<BundleStatusResult>('getBundleStatuses', [bundleIds])
+  }
 }

package/src/core/Solana/jito/constants.ts

@@ -1,26 +1,11 @@
-import type { Cluster } from '@solana/web3.js'
-
 // Jito Tip accounts gotten from https://jito-foundation.gitbook.io/mev/mev-payment-and-distribution/on-chain-addresses
-export const JITO_TIP_ACCOUNTS: Record<Cluster, string[]> = {
-  'mainnet-beta': [
-    'Cw8CFyM9FkoMi7K7Crf6HNQqf4uEMzpKw6QNghXLvLkY',
-    'DttWaMuVvTiduZRnguLF7jNxTgiMBZ1hyAumKUiL2KRL',
-    '96gYZGLnJYVFmbjzopPSU6QiEV5fGqZNyN9nmNhvrZU5',
-    '3AVi9Tg9Uo68tJfuvoKvqKNWKkC5wPdSSdeBnizKZ6jT',
-    'HFqU5x63VTqvQss8hp11i4wVV8bD44PvwucfZ2bU7gRe',
-    'ADaUMid9yfUytqMBgopwjb2DTLSokTSzL1zt6iGPaS49',
-    'ADuUkR4vqLUMWXxW9gh6D6L8pMSawimctcNZ5pGwDcEt',
-    'DfXygSm4jCyNCybVYYK6DwvWqjKee8pbDmJGcLWNDXjh',
-  ],
-  devnet: [],
-  testnet: [
-    'BkMx5bRzQeP6tUZgzEs3xeDWJfQiLYvNDqSgmGZKYJDq',
-    'CwWZzvRgmxj9WLLhdoWUVrHZ1J8db3w2iptKuAitHqoC',
-    '4uRnem4BfVpZBv7kShVxUYtcipscgZMSHi3B9CSL6gAA',
-    'AzfhMPcx3qjbvCK3UUy868qmc5L451W341cpFqdL3EBe',
-    '84DrGKhycCUGfLzw8hXsUYX9SnWdh2wW3ozsTPrC5xyg',
-    '7aewvu8fMf1DK4fKoMXKfs3h3wpAQ7r7D8T1C71LmMF',
-    'G2d63CEgKBdgtpYT2BuheYQ9HFuFCenuHLNyKVpqAuSD',
-    'F7ThiQUBYiEcyaxpmMuUeACdoiSLKg4SZZ8JSfpFNwAf',
-  ],
-}
+export const JITO_TIP_ACCOUNTS = [
+  'Cw8CFyM9FkoMi7K7Crf6HNQqf4uEMzpKw6QNghXLvLkY',
+  'DttWaMuVvTiduZRnguLF7jNxTgiMBZ1hyAumKUiL2KRL',
+  '96gYZGLnJYVFmbjzopPSU6QiEV5fGqZNyN9nmNhvrZU5',
+  '3AVi9Tg9Uo68tJfuvoKvqKNWKkC5wPdSSdeBnizKZ6jT',
+  'HFqU5x63VTqvQss8hp11i4wVV8bD44PvwucfZ2bU7gRe',
+  'ADaUMid9yfUytqMBgopwjb2DTLSokTSzL1zt6iGPaS49',
+  'ADuUkR4vqLUMWXxW9gh6D6L8pMSawimctcNZ5pGwDcEt',
+  'DfXygSm4jCyNCybVYYK6DwvWqjKee8pbDmJGcLWNDXjh',
+]

package/src/core/Solana/jito/sendAndConfirmBundle.ts

@@ -1,5 +1,4 @@
 import type { SignatureResult, VersionedTransaction } from '@solana/web3.js'
-import bs58 from 'bs58'
 import { sleep } from '../../../utils/sleep.js'
 import { getJitoConnections } from '../connection.js'
 
@@ -13,8 +12,8 @@ export type BundleResult = {
  * Send and confirm a bundle of transactions using Jito
  * Automatically selects a Jito-enabled RPC connection and polls for confirmation
  * across multiple Jito RPCs in parallel
- * @param signedTransactions - Array of signed transactions
- * @returns Bundle ID, transaction signatures, and confirmation results
+ * @param signedTransactions - an Array of signed transactions
+ * @returns - {@link BundleResult} object containing Bundle ID, transaction signatures, and confirmation results
  */
 export async function sendAndConfirmBundle(
   signedTransactions: VersionedTransaction[]
@@ -27,147 +26,67 @@ export async function sendAndConfirmBundle(
     )
   }
 
-  // Validate bundle requirements
-  if (signedTransactions.length === 0) {
-    throw new Error('Bundle must contain at least one transaction')
-  }
-
-  // Check that all transactions have the same blockhash (required for bundles)
-  const firstBlockhash = signedTransactions[0].message.recentBlockhash
-  const allSameBlockhash = signedTransactions.every(
-    (tx) => tx.message.recentBlockhash === firstBlockhash
-  )
-
-  if (!allSameBlockhash) {
-    console.warn(
-      'Bundle transactions have different blockhashes:',
-      signedTransactions.map((tx) => tx.message.recentBlockhash)
-    )
-  }
-
-  // Extract transaction signatures
-  const txSignatures = signedTransactions.map((tx, index) => {
-    if (!tx.signatures[0]) {
-      throw new Error(
-        `Transaction signature is missing for transaction at index ${index}.`
-      )
-    }
-    const signature = bs58.encode(tx.signatures[0])
-    return signature
-  })
-
   const abortController = new AbortController()
-  let bundleId: string | null = null
 
-  // Try to simulate and send bundle with the first connection
-  for (const jitoConnection of jitoConnections) {
+  const confirmPromises = jitoConnections.map(async (jitoConnection) => {
     try {
-      // Simulate bundle first
-      const simulationResult =
-        await jitoConnection.simulateBundle(signedTransactions)
-
-      if (simulationResult.value.summary !== 'succeeded') {
-        const summary = simulationResult.value.summary as {
-          failed: { error: any; tx_signature: string }
-        }
-
-        // Extract readable error message from TransactionFailure
-        const errorMsg =
-          summary.failed?.error?.TransactionFailure?.[1] ||
-          JSON.stringify(summary.failed?.error) ||
-          'Unknown simulation error'
-
-        throw new Error(`Bundle simulation failed: ${errorMsg}`)
-      }
-
-      // Send bundle using JitoConnection method
-      bundleId = await jitoConnection.sendBundle(signedTransactions)
-      break
-    } catch (error) {
-      // Try next connection if this one fails
-      if (jitoConnection === jitoConnections[jitoConnections.length - 1]) {
-        throw error
+      // Send initial bundle for this connection
+      let bundleId: string
+      try {
+        bundleId = await jitoConnection.sendBundle(signedTransactions)
+      } catch (_) {
+        return null
       }
-    }
-  }
 
-  if (!bundleId) {
-    throw new Error('Failed to send bundle to any Jito connection')
-  }
-
-  // Now confirm the bundle across all Jito connections in parallel
-  const confirmPromises = jitoConnections.map(async (jitoConnection) => {
-    try {
-      // Get initial blockhash and block height
       const [blockhashResult, initialBlockHeight] = await Promise.all([
         jitoConnection.getLatestBlockhash('confirmed'),
         jitoConnection.getBlockHeight('confirmed'),
       ])
-      let signatureResults: (SignatureResult | null)[] = txSignatures.map(
-        () => null
-      )
-
-      const pollingPromise = (async () => {
-        let pollingBlockHeight = initialBlockHeight
-        while (
-          pollingBlockHeight < blockhashResult.lastValidBlockHeight &&
-          !abortController.signal.aborted
+      let currentBlockHeight = initialBlockHeight
+
+      while (
+        currentBlockHeight < blockhashResult.lastValidBlockHeight &&
+        !abortController.signal.aborted
+      ) {
+        const statusResponse = await jitoConnection.getBundleStatuses([
+          bundleId,
+        ])
+
+        const bundleStatus = statusResponse.value[0]
+
+        // Check if bundle is confirmed or finalized
+        if (
+          bundleStatus &&
+          (bundleStatus.confirmation_status === 'confirmed' ||
+            bundleStatus.confirmation_status === 'finalized')
         ) {
-          const statusResponse =
+          // Bundle confirmed! Extract transaction signatures from bundle status
+          const txSignatures = bundleStatus.transactions
+          // Fetch individual signature results
+          const sigResponse =
             await jitoConnection.getSignatureStatuses(txSignatures)
 
-          const allConfirmed = statusResponse.value.every(
-            (status) =>
-              status &&
-              (status.confirmationStatus === 'confirmed' ||
-                status.confirmationStatus === 'finalized')
-          )
-
-          if (allConfirmed) {
-            signatureResults = statusResponse.value
-            // Immediately abort all other connections when we find results
-            abortController.abort()
-            return signatureResults
+          if (!sigResponse?.value || !Array.isArray(sigResponse.value)) {
+            // Keep polling, if can't find signature results.
+            continue
           }
 
-          await sleep(400)
-          // Update block height independently to avoid stale reads
-          if (!abortController.signal.aborted) {
-            pollingBlockHeight =
-              await jitoConnection.getBlockHeight('confirmed')
+          // Immediately abort all other connections when we find a result
+          abortController.abort()
+          return {
+            bundleId,
+            txSignatures,
+            signatureResults: sigResponse.value,
           }
         }
-        return null
-      })()
-
-      const sendingPromise = (async (): Promise<
-        (SignatureResult | null)[] | null
-      > => {
-        let sendingBlockHeight = initialBlockHeight
-        while (
-          sendingBlockHeight < blockhashResult.lastValidBlockHeight &&
-          !abortController.signal.aborted &&
-          signatureResults.every((r) => r === null)
-        ) {
-          try {
-            // Re-send bundle periodically
-            await jitoConnection.sendBundle(signedTransactions)
-          } catch (_) {
-            // Silently retry on send failures - polling will detect success
-          }
 
-          await sleep(1000)
-          if (!abortController.signal.aborted) {
-            sendingBlockHeight =
-              await jitoConnection.getBlockHeight('confirmed')
-          }
+        await sleep(400)
+        if (!abortController.signal.aborted) {
+          currentBlockHeight = await jitoConnection.getBlockHeight('confirmed')
         }
-        return null
-      })()
+      }
 
-      // Wait for polling to find the results
-      const result = await Promise.race([pollingPromise, sendingPromise])
-      return result
+      return null
     } catch (error) {
       if (abortController.signal.aborted) {
         return null // Don't treat abortion as an error
@@ -176,20 +95,16 @@ export async function sendAndConfirmBundle(
     }
   })
 
-  // Wait for the first connection to return (either success or timeout)
-  // If a connection finds confirmation, it aborts all others via abortController
-  // If all connections reject (throw errors), catch and return null array
-  const signatureResults =
-    (await Promise.any(confirmPromises).catch(() => null)) ??
-    txSignatures.map(() => null)
+  // Wait for first successful confirmation
+  const result = await Promise.any(confirmPromises).catch(() => null)
 
   if (!abortController.signal.aborted) {
     abortController.abort()
   }
 
-  return {
-    bundleId,
-    txSignatures,
-    signatureResults,
+  if (!result) {
+    throw new Error('Failed to send and confirm bundle')
   }
+
+  return result
 }