fix(sdk-provider-solana): prevent false TransactionExpired for confirmed txs

packages/sdk-provider-solana/src/actions/sendAndConfirmBundle.ts

@@ -8,6 +8,7 @@ import {
 } from '@solana/kit'
 
 import { getJitoRpcs } from '../rpc/registry.js'
+import { extractBlockhash } from '../utils/extractBlockhash.js'
 
 type SignatureStatus = {
   slot: bigint
@@ -48,6 +49,8 @@ export async function sendAndConfirmBundle(
     getBase64EncodedWireTransaction(tx)
   )
 
+  const txBlockhash = extractBlockhash(signedTransactions[0])
+
   const abortController = new AbortController()
 
   const confirmPromises = jitoRpcs.map(async (jitoRpc) => {
@@ -60,26 +63,18 @@ export async function sendAndConfirmBundle(
         return null
       }
 
-      const [{ value: blockhashResult }, initialBlockHeight] =
-        await Promise.all([
-          jitoRpc
-            .getLatestBlockhash({
-              commitment: 'confirmed',
-            })
-            .send(),
-          jitoRpc
-            .getBlockHeight({
-              commitment: 'confirmed',
-            })
-            .send(),
-        ])
-
-      let currentBlockHeight = initialBlockHeight
-
-      while (
-        currentBlockHeight < blockhashResult.lastValidBlockHeight &&
-        !abortController.signal.aborted
-      ) {
+      let blockhashValid = true
+
+      // For durable nonce txs, fall back to block-height-based timeout
+      let expiryBlockHeight: bigint | undefined
+      if (!txBlockhash) {
+        const { value: blockhashResult } = await jitoRpc
+          .getLatestBlockhash({ commitment: 'confirmed' })
+          .send()
+        expiryBlockHeight = blockhashResult.lastValidBlockHeight
+      }
+
+      while (blockhashValid && !abortController.signal.aborted) {
         const statusResponse = await jitoRpc
           .getBundleStatuses([bundleId])
           .send()
@@ -117,11 +112,48 @@ export async function sendAndConfirmBundle(
 
         await sleep(400)
         if (!abortController.signal.aborted) {
-          currentBlockHeight = await jitoRpc
-            .getBlockHeight({
-              commitment: 'confirmed',
-            })
+          if (txBlockhash) {
+            const { value: isValid } = await jitoRpc
+              .isBlockhashValid(txBlockhash, {
+                commitment: 'confirmed',
+              })
+              .send()
+            blockhashValid = isValid
+          } else {
+            const blockHeight = await jitoRpc
+              .getBlockHeight({ commitment: 'confirmed' })
+              .send()
+            blockhashValid = blockHeight < expiryBlockHeight!
+          }
+        }
+      }
+
+      // Final status check — the bundle may have confirmed between the
+      // last poll and the blockhash expiring.
+      if (!abortController.signal.aborted) {
+        const statusResponse = await jitoRpc
+          .getBundleStatuses([bundleId])
+          .send()
+
+        const bundleStatus = statusResponse.value[0]
+        if (
+          bundleStatus &&
+          (bundleStatus.confirmation_status === 'confirmed' ||
+            bundleStatus.confirmation_status === 'finalized')
+        ) {
+          const txSignatures = bundleStatus.transactions
+          const sigResponse = await jitoRpc
+            .getSignatureStatuses(txSignatures)
             .send()
+
+          if (sigResponse?.value && Array.isArray(sigResponse.value)) {
+            abortController.abort()
+            return {
+              bundleId,
+              txSignatures,
+              signatureResults: sigResponse.value,
+            }
+          }
         }
       }
 

packages/sdk-provider-solana/src/actions/sendAndConfirmTransaction.ts

@@ -7,6 +7,7 @@ import {
   type TransactionError,
 } from '@solana/kit'
 import { getSolanaRpcs } from '../rpc/registry.js'
+import { extractBlockhash } from '../utils/extractBlockhash.js'
 
 type SignatureStatus = {
   slot: bigint
@@ -21,6 +22,22 @@ type ConfirmedTransactionResult = {
   txSignature: string
 }
 
+function getConfirmedStatus(
+  statusResponse: Readonly<{
+    value: readonly (SignatureStatus | null)[]
+  }>
+): SignatureStatus | null {
+  const status = statusResponse.value[0]
+  if (
+    status &&
+    (status.confirmationStatus === 'confirmed' ||
+      status.confirmationStatus === 'finalized')
+  ) {
+    return status
+  }
+  return null
+}
+
 /**
  * Sends a Solana transaction to multiple RPC endpoints and returns the confirmation
  * as soon as any of them confirm the transaction.
@@ -35,13 +52,14 @@ export async function sendAndConfirmTransaction(
   const solanaRpcs = await getSolanaRpcs(client)
 
   const signedTxSerialized = getBase64EncodedWireTransaction(signedTransaction)
-  // Create transaction hash (signature)
   const txSignature = getSignatureFromTransaction(signedTransaction)
 
   if (!txSignature) {
     throw new Error('Transaction signature is missing.')
   }
 
+  const txBlockhash = extractBlockhash(signedTransaction)
+
   const rawTransactionOptions = {
     // We can skip preflight check after the first transaction has been sent
     // https://solana.com/docs/advanced/retry#the-cost-of-skipping-preflight
@@ -66,51 +84,52 @@ export async function sendAndConfirmTransaction(
         // Continue with confirmation even if initial send fails
       }
 
-      const [{ value: blockhashResult }, initialBlockHeight] =
-        await Promise.all([
-          rpc
-            .getLatestBlockhash({
-              commitment: 'confirmed',
-            })
-            .send(),
-          rpc
-            .getBlockHeight({
-              commitment: 'confirmed',
-            })
-            .send(),
-        ])
-
       let signatureResult: SignatureStatus | null = null
-      let blockHeight = initialBlockHeight
+      let blockhashValid = true
+
+      // For durable nonce txs, fall back to block-height-based timeout
+      let expiryBlockHeight: bigint | undefined
+      if (!txBlockhash) {
+        const { value: blockhashResult } = await rpc
+          .getLatestBlockhash({ commitment: 'confirmed' })
+          .send()
+        expiryBlockHeight = blockhashResult.lastValidBlockHeight
+      }
+
       const pollingPromise = (async () => {
-        while (
-          blockHeight < blockhashResult.lastValidBlockHeight &&
-          !abortController.signal.aborted
-        ) {
-          const statusResponse = await rpc
-            .getSignatureStatuses([txSignature])
-            .send()
-
-          const status = statusResponse.value[0]
-          if (
-            status &&
-            (status.confirmationStatus === 'confirmed' ||
-              status.confirmationStatus === 'finalized')
-          ) {
-            signatureResult = status
-            // Immediately abort all other RPCs when we find a result
+        while (blockhashValid && !abortController.signal.aborted) {
+          const confirmed = getConfirmedStatus(
+            await rpc.getSignatureStatuses([txSignature]).send()
+          )
+          if (confirmed) {
+            signatureResult = confirmed
             abortController.abort()
-            return status
+            return confirmed
           }
 
           await sleep(400)
         }
+
+        // Final status check — the tx may have confirmed between the last
+        // poll and the blockhash expiring.
+        if (!abortController.signal.aborted) {
+          const confirmed = getConfirmedStatus(
+            await rpc.getSignatureStatuses([txSignature]).send()
+          )
+          if (confirmed) {
+            signatureResult = confirmed
+            abortController.abort()
+            return confirmed
+          }
+        }
+
         return null
       })()
 
+      // Sending loop runs in the background — only pollingPromise produces results.
       const sendingPromise = (async () => {
         while (
-          blockHeight < blockhashResult.lastValidBlockHeight &&
+          blockhashValid &&
           !abortController.signal.aborted &&
           !signatureResult
         ) {
@@ -124,18 +143,25 @@ export async function sendAndConfirmTransaction(
 
           await sleep(1000)
           if (!abortController.signal.aborted) {
-            blockHeight = await rpc
-              .getBlockHeight({
-                commitment: 'confirmed',
-              })
-              .send()
+            if (txBlockhash) {
+              const { value: isValid } = await rpc
+                .isBlockhashValid(txBlockhash, {
+                  commitment: 'confirmed',
+                })
+                .send()
+              blockhashValid = isValid
+            } else {
+              const blockHeight = await rpc
+                .getBlockHeight({ commitment: 'confirmed' })
+                .send()
+              blockhashValid = blockHeight < expiryBlockHeight!
+            }
           }
         }
-        return null
       })()
+      sendingPromise.catch(() => {})
 
-      // Wait for polling to find the result
-      const result = await Promise.race([pollingPromise, sendingPromise])
+      const result = await pollingPromise
       return result
     } catch (error) {
       if (abortController.signal.aborted) {

packages/sdk-provider-solana/src/core/tasks/SolanaStandardWaitForTransactionTask.ts

@@ -53,7 +53,6 @@ export class SolanaStandardWaitForTransactionTask extends BaseStepExecutionTask
           connection
             .simulateTransaction(encodedTransaction, {
               commitment: 'confirmed',
-              replaceRecentBlockhash: true,
               encoding: 'base64',
             })
             .send()

packages/sdk-provider-solana/src/utils/extractBlockhash.ts

@@ -0,0 +1,18 @@
+import {
+  type Blockhash,
+  getCompiledTransactionMessageDecoder,
+  isTransactionWithDurableNonceLifetime,
+  type Transaction,
+} from '@solana/kit'
+
+const decoder = getCompiledTransactionMessageDecoder()
+
+export function extractBlockhash(
+  signedTransaction: Transaction
+): Blockhash | null {
+  if (isTransactionWithDurableNonceLifetime(signedTransaction)) {
+    return null
+  }
+  const compiledMessage = decoder.decode(signedTransaction.messageBytes)
+  return compiledMessage.lifetimeToken as Blockhash
+}