fix: ensure STX status updates across all networks

src/SmartTransactionsController.test.ts

@@ -447,7 +447,7 @@
 
         controller.timeoutHandle = setTimeout(() => ({}));
 
         controller.poll(1000);
 
         expect(updateSmartTransactionsSpy).toHaveBeenCalled();
       });
@@ -1578,6 +1578,76 @@
       );
     });
 
+    it('iterates over transactions from all networks when updating statuses', async () => {
+      // Setup: Create controller with pending transactions on two different networks
+      const mainnetPendingTx = {
+        uuid: 'mainnet-tx',
+        status: SmartTransactionStatuses.PENDING,
+        chainId: ChainId.mainnet,
+        networkClientId: NetworkType.mainnet,
+      };
+
+      const sepoliaPendingTx = {
+        uuid: 'sepolia-tx',
+        status: SmartTransactionStatuses.PENDING,
+        chainId: ChainId.sepolia,
+        networkClientId: NetworkType.sepolia,
+      };
+
+      await withController(
+        {
+          options: {
+            supportedChainIds: [ChainId.mainnet, ChainId.sepolia],
+            state: {
+              smartTransactionsState: {
+                ...getDefaultSmartTransactionsControllerState()
+                  .smartTransactionsState,
+                smartTransactions: {
+                  [ChainId.mainnet]: [mainnetPendingTx] as SmartTransaction[],
+                  [ChainId.sepolia]: [sepoliaPendingTx] as SmartTransaction[],
+                },
+              },
+            },
+          },
+        },
+        async ({ controller }) => {
+          // Mock the API responses for both networks
+          nock(API_BASE_URL)
+            .get(`/networks/1/batchStatus?uuids=mainnet-tx`)
+            .reply(200, { 'mainnet-tx': {} });
+
+          nock(API_BASE_URL)
+            .get(`/networks/11155111/batchStatus?uuids=sepolia-tx`)
+            .reply(200, { 'sepolia-tx': {} });
+
+          const fetchStatusSpy = jest.spyOn(
+            controller,
+            'fetchSmartTransactionsStatus',
+          );
+
+          // Call updateSmartTransactions
+          await controller.updateSmartTransactions();
+
+          // Verify both calls were made with correct parameters
+          expect(fetchStatusSpy).toHaveBeenCalledTimes(2);
+          expect(fetchStatusSpy).toHaveBeenNthCalledWith(1, [
+            expect.objectContaining({
+              uuid: 'mainnet-tx',
+              chainId: ChainId.mainnet,
+              networkClientId: NetworkType.mainnet,
+            }),
+          ]);
+          expect(fetchStatusSpy).toHaveBeenNthCalledWith(2, [
+            expect.objectContaining({
+              uuid: 'sepolia-tx',
+              chainId: ChainId.sepolia,
+              networkClientId: NetworkType.sepolia,
+            }),
+          ]);
+        },
+      );
+    });
+
     it('does not call updateTransaction when smart transaction is cancelled but returnTxHashAsap is false', async () => {
       const mockUpdateTransaction = jest.fn();
       await withController(
@@ -2559,7 +2629,7 @@
       triggerNetworStateChange,
     });
   } finally {
     controller.stop();
     controller.stopAllPolling();
   }
 }

src/SmartTransactionsController.ts

@@ -348,9 +348,9 @@
       isSmartTransactionPending,
     );
     if (!this.timeoutHandle && pendingTransactions?.length > 0) {
       this.poll();
     } else if (this.timeoutHandle && pendingTransactions?.length === 0) {
       this.stop();
     }
   }
 
@@ -375,7 +375,7 @@
     }
 
     this.timeoutHandle = setInterval(() => {
       safelyExecute(async () => this.updateSmartTransactions());
     }, this.#interval);
     await safelyExecute(async () => this.updateSmartTransactions());
   }
@@ -442,7 +442,7 @@
       ethQuery = new EthQuery(provider);
     }
 
     this.#createOrUpdateSmartTransaction(smartTransaction, {
       chainId,
       ethQuery,
     });
@@ -622,23 +622,24 @@
       if (chainIds && !chainIds.includes(chainId as Hex)) {
         continue;
       }
-      // Filter pending transactions and map them to the desired shape
+
+      // Filter pending transactions for this chainId
       const pendingTransactions = transactions
         .filter(isSmartTransactionPending)
         .map((pendingSmartTransaction) => {
-          // Use the transaction's chainId (from the key) to derive a networkClientId
+          // Use the transaction's chainId to derive a networkClientId
           const networkClientIdToUse = this.#getNetworkClientId({
             chainId: chainId as Hex,
           });
           return {
             uuid: pendingSmartTransaction.uuid,
             networkClientId: networkClientIdToUse,
-            chainId: pendingSmartTransaction.chainId as Hex, // same as the key, but explicit on the transaction
+            chainId: chainId as Hex,
           };
         });
 
       if (pendingTransactions.length > 0) {
-        // Since each group is per chain, all transactions share the same chainId.
+        // Fetch status updates for all pending transactions on this chain
         await this.fetchSmartTransactionsStatus(pendingTransactions);
       }
     }
@@ -729,7 +730,7 @@
             : originalTxMeta;
 
         if (this.#doesTransactionNeedConfirmation(txHash)) {
           this.#confirmExternalTransaction(
             // TODO: Replace 'as' assertion with correct typing for `txMeta`
             txMeta as TransactionMeta,
             transactionReceipt,