@@ -211,6 +211,88 @@ describe("transaction", () => {
     unsubscribe()
   })
 
+  test("should fall back to legacy polling if WebSocket receives no data within timeout", async () => {
+    jest.useFakeTimers()
+
+    const txId =
+      "5234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef"
+    const onData = jest.fn()
+    const onError = jest.fn()
+
+    // Use a short wsTimeout
+    transaction(txId, {wsTimeout: 5000}).subscribe(onData, onError)
+
+    // Flush the event loop for init()
+    await jest.advanceTimersByTimeAsync(0)
+
+    // Verify WebSocket subscription was attempted
+    expect(subscribe).toHaveBeenCalled()
+
+    const subscribeParams = jest.mocked(subscribe).mock
+      .calls[0][0] as Parameters<
+      typeof subscribe<SubscriptionTopic.TRANSACTION_STATUSES>
+    >[0]
+
+    expect(subscribeParams).toStrictEqual({
+      topic: SubscriptionTopic.TRANSACTION_STATUSES,
+      args: {transactionId: txId},
+      onData: expect.any(Function),
+      onError: expect.any(Function),
+    })
+
+    // Do NOT send any data via WebSocket — simulate a hung connection
+    // Advance past the timeout
+    await jest.advanceTimersByTimeAsync(5000)
+
+    // Should have fallen back to legacy polling
+    expect(legacyTransaction).toHaveBeenCalledWith(txId, {
+      wsTimeout: 5000,
+    })
+
+    // WebSocket subscription should have been unsubscribed
+    const unsubMock = jest.mocked(subscribe).mock.results[0].value
+    expect(unsubMock.unsubscribe).toHaveBeenCalledTimes(1)
+
+    jest.useRealTimers()
+  })
+
+  test("should NOT fall back to polling if WebSocket receives data before timeout", async () => {
+    jest.useFakeTimers()
+
+    const txId =
+      "6234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef"
+    const onData = jest.fn()
+    const onError = jest.fn()
+
+    transaction(txId, {wsTimeout: 5000}).subscribe(onData, onError)
+
+    // Flush the event loop for init()
+    await jest.advanceTimersByTimeAsync(0)
+
+    const subscribeParams = jest.mocked(subscribe).mock
+      .calls[0][0] as Parameters<
+      typeof subscribe<SubscriptionTopic.TRANSACTION_STATUSES>
+    >[0]
+
+    // Send data before the timeout
+    subscribeParams.onData({
+      status: TransactionExecutionStatus.PENDING,
+      blockId: "",
+      statusCode: 0,
+      errorMessage: "",
+      events: [],
+      statusString: "PENDING",
+    })
+
+    // Advance past the timeout
+    await jest.advanceTimersByTimeAsync(5000)
+
+    // Should NOT have fallen back to legacy polling
+    expect(legacyTransaction).not.toHaveBeenCalled()
+
+    jest.useRealTimers()
+  })
+
   test("should fall back to legacy polling if the Flow emulator is detected", async () => {
     mockGetChainId.mockResolvedValue("local")
 
 
@@ -14,9 +14,10 @@ import {
   scoped,
 } from "./utils"
 import {TXID_REGEXP} from "./constants"
-import {isUnknown, SubscriptionsNotSupportedError} from "@onflow/sdk"
+import {isUnknown, SubscriptionsNotSupportedError, send as fclSend, decode, getTransactionStatus} from "@onflow/sdk"
 import {TransactionError} from "./transaction-error"
-import {transaction as legacyTransaction} from "./legacy-polling"
+// legacy-polling.js actor-based polling is no longer used for the fallback
+// due to reliability issues (see https://github.com/onflow/fcl-js/issues/2792)
 import {createGetChainId} from "../utils"
 import {FCLContext} from "../context"
 import {createPartialGlobalFCLContext} from "../context/global"
@@ -114,6 +115,7 @@ export function createTransaction(context: Pick<FCLContext, "sdk" | "config">) {
     opts: {
       pollRate?: number
       txNotFoundTimeout?: number
+      wsTimeout?: number
     } = {txNotFoundTimeout: 12500, pollRate: 1000}
   ): {
     snapshot: () => Promise<TransactionStatus>
@@ -216,7 +218,7 @@ export const transaction = /* @__PURE__ */ createTransaction(
 function createObservable(
   context: Pick<FCLContext, "sdk" | "config">,
   txId: string,
-  opts: {pollRate?: number; txNotFoundTimeout?: number}
+  opts: {pollRate?: number; txNotFoundTimeout?: number; wsTimeout?: number}
 ) {
   const observers = new Set<{
     onData: (txStatus: TransactionStatus) => void
@@ -261,11 +263,20 @@ function createObservable(
 
   // Subscribe to transaction status updates
   function subscribeTransactionStatuses() {
+    const WS_TIMEOUT = opts.wsTimeout ?? 30000
+    let receivedData = false
+
     // Subscribe to transaction status updates
     const subscription = context.sdk.subscribe({
       topic: SubscriptionTopic.TRANSACTION_STATUSES,
       args: {transactionId: txId},
       onData: txStatus => {
+        receivedData = true
+        if (wsTimeoutId != null) {
+          clearTimeout(wsTimeoutId)
+          wsTimeoutId = null
+        }
+
         if (isDiff(value, txStatus)) {
           value = txStatus
           next(txStatus)
@@ -282,6 +293,11 @@ function createObservable(
         }
       },
       onError: (err: Error) => {
+        if (wsTimeoutId != null) {
+          clearTimeout(wsTimeoutId)
+          wsTimeoutId = null
+        }
+
         if (err instanceof SubscriptionsNotSupportedError) {
           console.warn(
             "Failed to subscribe to transaction status updates using real-time streaming (are you using the deprecated GRPC transport?), falling back to polling."
@@ -292,28 +308,68 @@ function createObservable(
         }
       },
     })
+
+    // If no data is received within the timeout, fall back to legacy polling
+    // This handles cases where the Access Node never pushes data (e.g., tx already sealed)
+    let wsTimeoutId: ReturnType<typeof setTimeout> | null = setTimeout(() => {
+      if (!receivedData) {
+        console.warn(
+          `No transaction status data received via WebSocket within ${WS_TIMEOUT}ms, falling back to polling.`
+        )
+        subscription.unsubscribe()
+        fallbackLegacyPolling()
+      }
+    }, WS_TIMEOUT)
   }
 
   function fallbackLegacyPolling() {
-    // Poll for transaction status updates
-    const unsubscribe = legacyTransaction(txId, opts).subscribe(
-      (txStatus?: TransactionStatus, err?: Error) => {
-        if (err) {
-          error(err)
-        } else if (txStatus && isDiff(value, txStatus)) {
-          value = txStatus
-          next(txStatus)
+    // Simple direct polling — bypasses the actor system which has reliability
+    // issues with fresh transactions (see https://github.com/onflow/fcl-js/issues/2792)
+    let cancelled = false
+
+    const poll = async () => {
+      const pollRate = opts.pollRate ?? 1000
+      const txNotFoundTimeout = opts.txNotFoundTimeout ?? 12500
+      const startTime = Date.now()
 
-          // Clean up the subscription if the transaction is sealed
-          // Wait for next tick to ensure unsubscribe is defined
-          if (isSealed(txStatus)) {
-            new Promise(resolve => setTimeout(resolve, 0)).then(() => {
-              unsubscribe()
-            })
+      while (!cancelled) {
+        try {
+          const response = await fclSend([getTransactionStatus(txId)])
+          const txStatus: TransactionStatus = await decode(response)
+
+          if (isDiff(value, txStatus)) {
+            value = txStatus
+            next(txStatus)
+          }
+
+          // Stop polling if the transaction has reached a terminal state
+          if (isSealed(txStatus) || isExpired(txStatus) || txStatus.statusCode === 1) {
+            return
+          }
+        } catch (e: any) {
+          // Ignore not-found errors during initial propagation
+          const isNotFound =
+            (e?.statusCode === 404) ||
+            (e?.message?.includes?.("not found"))
+          if (!isNotFound) {
+            // If we haven't found the transaction within the timeout, report error
+            if (Date.now() - startTime > txNotFoundTimeout) {
+              error(e instanceof Error ? e : new Error(String(e)))
+              return
+            }
           }
         }
+
+        await new Promise(resolve => setTimeout(resolve, pollRate))
       }
-    )
+    }
+
+    poll()
+
+    // Return cleanup function (used by createObservable if all observers unsubscribe)
+    return () => {
+      cancelled = true
+    }
   }
 
   function next(txStatus: TransactionStatus) {