feat(STX-433): add try catch block to make sure result is returned

Author: rarquevaux

app/scripts/messenger-client-init/confirmations/transaction-controller-init.test.ts

@@ -582,6 +582,98 @@ describe('Transaction Controller Init', () => {
         properties: { transaction_submission_method: 'sentinel_stx' },
       });
     });
+
+    it('returns transaction hash even if upsertTransactionUIMetricsFragment throws on sentinel_relay path', async () => {
+      const delegation7702HookFn: jest.MockedFn<PublishHook> = jest.fn();
+      delegation7702HookFn.mockResolvedValue({ transactionHash: '0xdelHash' });
+      jest.mocked(Delegation7702PublishHook).mockImplementation(
+        () =>
+          ({
+            getHook: () => delegation7702HookFn,
+          }) as unknown as Delegation7702PublishHook,
+      );
+
+      type PHArgs = Parameters<typeof publishHook>[0];
+      const result = await publishHook({
+        flatState: {} as PHArgs['flatState'],
+        getTransactionMetricsRequest: () =>
+          ({
+            upsertTransactionUIMetricsFragment: jest
+              .fn()
+              .mockImplementation(() => {
+                throw new Error('metrics error');
+              }),
+          }) as unknown as ReturnType<PHArgs['getTransactionMetricsRequest']>,
+        initMessenger: {
+          call: jest.fn(),
+        } as unknown as TransactionControllerInitMessenger,
+        keyringController: {
+          getKeyringForAccount: jest
+            .fn()
+            .mockResolvedValue({ type: 'HD Key Tree' }),
+        },
+        signedTx: '0xsigned',
+        smartTransactionsController:
+          {} as PHArgs['smartTransactionsController'],
+        transactionController: {
+          isAtomicBatchSupported: jest.fn(),
+        } as unknown as PHArgs['transactionController'],
+        transactionMeta: {
+          ...mockTransactionMeta,
+          isExternalSign: true,
+        } as TransactionMeta,
+      });
+
+      expect(result).toStrictEqual({ transactionHash: '0xdelHash' });
+    });
+
+    it('returns transaction hash even if upsertTransactionUIMetricsFragment throws on sentinel_stx path', async () => {
+      jest
+        .mocked(smartTransactionsModule.getSmartTransactionCommonParams)
+        .mockReturnValue({
+          isSmartTransaction: true,
+          featureFlags: {
+            extensionReturnTxHashAsap: false,
+            extensionReturnTxHashAsapBatch: false,
+            extensionSkipSmartTransactionStatusPage: false,
+            mobileActive: false,
+            extensionActive: false,
+          },
+          isHardwareWalletAccount: false,
+        });
+
+      jest
+        .mocked(smartTransactionsModule.submitSmartTransactionHook)
+        .mockResolvedValue({ transactionHash: '0xstxHash' });
+
+      type PHArgs = Parameters<typeof publishHook>[0];
+      const result = await publishHook({
+        flatState: {} as PHArgs['flatState'],
+        getTransactionMetricsRequest: () =>
+          ({
+            upsertTransactionUIMetricsFragment: jest
+              .fn()
+              .mockImplementation(() => {
+                throw new Error('metrics error');
+              }),
+          }) as unknown as ReturnType<PHArgs['getTransactionMetricsRequest']>,
+        initMessenger: {
+          call: jest.fn(),
+        } as unknown as TransactionControllerInitMessenger,
+        keyringController: {
+          getKeyringForAccount: jest
+            .fn()
+            .mockResolvedValue({ type: 'Ledger Hardware' }),
+        },
+        signedTx: '0xsigned',
+        smartTransactionsController:
+          {} as PHArgs['smartTransactionsController'],
+        transactionController: {} as PHArgs['transactionController'],
+        transactionMeta: mockTransactionMeta,
+      });
+
+      expect(result).toStrictEqual({ transactionHash: '0xstxHash' });
+    });
   });
 
   describe('publishBatch hook', () => {
@@ -743,5 +835,53 @@ describe('Transaction Controller Init', () => {
 
       expect(upsertFragmentMock).not.toHaveBeenCalled();
     });
+
+    it('returns the result even if upsertTransactionUIMetricsFragment throws', async () => {
+      jest
+        .mocked(smartTransactionsModule.getSmartTransactionCommonParams)
+        .mockReturnValue({
+          isSmartTransaction: true,
+          featureFlags: {
+            extensionReturnTxHashAsap: false,
+            extensionReturnTxHashAsapBatch: false,
+            extensionSkipSmartTransactionStatusPage: false,
+            mobileActive: false,
+            extensionActive: false,
+          },
+          isHardwareWalletAccount: false,
+        });
+
+      const expectedResult = { results: [] };
+      jest
+        .mocked(smartTransactionsModule.submitBatchSmartTransactionHook)
+        .mockResolvedValue(expectedResult);
+
+      const requestMock = buildInitRequestMock();
+      requestMock.getTransactionMetricsRequest.mockReturnValue({
+        upsertTransactionUIMetricsFragment: jest.fn().mockImplementation(() => {
+          throw new Error('metrics error');
+        }),
+      } as unknown as ReturnType<
+        typeof requestMock.getTransactionMetricsRequest
+      >);
+
+      TransactionControllerInit(requestMock);
+
+      const { hooks } = transactionControllerClassMock.mock.calls[0][0];
+      const controllerInstance =
+        transactionControllerClassMock.mock.instances[0];
+      // @ts-expect-error Partial mock state
+      controllerInstance.state = {
+        transactions: [mockTransactionMeta],
+      };
+
+      const result = await hooks?.publishBatch?.({
+        transactions: [
+          { id: 'batch-tx-last' } as unknown as PublishBatchHookTransaction,
+        ],
+      } as unknown as PublishBatchHookRequest);
+
+      expect(result).toStrictEqual(expectedResult);
+    });
   });
 });

app/scripts/messenger-client-init/confirmations/transaction-controller-init.ts

@@ -235,12 +235,19 @@ export const TransactionControllerInit: ControllerInitFunction<
             getTransactionMetricsRequest();
           for (const batchTx of _request.transactions) {
             if (batchTx.id) {
-              upsertTransactionUIMetricsFragment(batchTx.id, {
-                properties: {
-                  [TRANSACTION_SUBMISSION_METHOD_METRIC_NAME]:
-                    TRANSACTION_SUBMISSION_METHOD.SENTINEL_STX,
-                },
-              });
+              try {
+                upsertTransactionUIMetricsFragment(batchTx.id, {
+                  properties: {
+                    [TRANSACTION_SUBMISSION_METHOD_METRIC_NAME]:
+                      TRANSACTION_SUBMISSION_METHOD.SENTINEL_STX,
+                  },
+                });
+              } catch (e) {
+                console.error(
+                  'Failed to record sentinel_stx metrics fragment for batch tx',
+                  e,
+                );
+              }
             }
           }
         }
@@ -442,15 +449,19 @@ export async function publishHook({
 
     const result = await hook(transactionMeta, signedTx);
     if (result?.transactionHash) {
-      getTransactionMetricsRequest().upsertTransactionUIMetricsFragment(
-        transactionMeta.id,
-        {
-          properties: {
-            [TRANSACTION_SUBMISSION_METHOD_METRIC_NAME]:
-              TRANSACTION_SUBMISSION_METHOD.SENTINEL_RELAY,
+      try {
+        getTransactionMetricsRequest().upsertTransactionUIMetricsFragment(
+          transactionMeta.id,
+          {
+            properties: {
+              [TRANSACTION_SUBMISSION_METHOD_METRIC_NAME]:
+                TRANSACTION_SUBMISSION_METHOD.SENTINEL_RELAY,
+            },
           },
-        },
-      );
+        );
+      } catch (e) {
+        console.error('Failed to record sentinel_relay metrics fragment', e);
+      }
       return result;
     }
     // else, fall back to regular regular transaction submission
@@ -471,15 +482,19 @@ export async function publishHook({
     });
 
     if (result?.transactionHash) {
-      getTransactionMetricsRequest().upsertTransactionUIMetricsFragment(
-        transactionMeta.id,
-        {
-          properties: {
-            [TRANSACTION_SUBMISSION_METHOD_METRIC_NAME]:
-              TRANSACTION_SUBMISSION_METHOD.SENTINEL_STX,
+      try {
+        getTransactionMetricsRequest().upsertTransactionUIMetricsFragment(
+          transactionMeta.id,
+          {
+            properties: {
+              [TRANSACTION_SUBMISSION_METHOD_METRIC_NAME]:
+                TRANSACTION_SUBMISSION_METHOD.SENTINEL_STX,
+            },
           },
-        },
-      );
+        );
+      } catch (e) {
+        console.error('Failed to record sentinel_stx metrics fragment', e);
+      }
       return result;
     }
     // else, fall back to regular regular transaction submission

test/jest/console-baseline-unit.json

@@ -51,6 +51,10 @@
       "error: StorageService: Failed to remove item:": 1,
       "error: StorageService: Failed to set item:": 1
     },
+    "app/scripts/messenger-client-init/confirmations/transaction-controller-init.test.ts": {
+      "error: Failed to record sentinel_relay metrics": 1,
+      "error: Failed to record sentinel_stx metrics": 2
+    },
     "app/scripts/messenger-client-init/core-backend/backend-websocket-service-init.test.ts": {
       "MetaMask: Backend WebSocket warnings": 1
     },