feat(rewards): add targeted Sentry capture for rewards auth errors (MetaMask#29545)

## Summary

Adds `captureException` to six targeted catch blocks across the rewards
controller and hooks. Scoped intentionally to avoid noise — only errors
that are either user-facing, represent rare high-severity auth failures,
or are unexpected outer-catch escapes from flows with visible user
impact.

### Instrumented locations

| Location | Context tag | When it fires |
|---|---|---|
| `useCandidateSubscriptionId` catch |
`candidateSubscriptionId.fetch_failed` | Every time the auth-failed
modal is shown to the user |
| `RewardsController.performSilentAuth` non-401 branch |
`performSilentAuth.unexpected_error` | Unexpected server errors (e.g.
500s) during silent auth — rare |
| `RewardsController.#withAuthRetry` reauthError catch |
`withAuthRetry.reauth_failed` | 403 recovery itself throws, forcing
cache invalidation — very rare |
| `RewardsController.#optIn` outer catch | `optIn.unexpected_error` |
Unexpected failures after inner InvalidTimestamp/AlreadyRegistered
handling |
| `RewardsController.linkAccountToSubscriptionCandidate` catch |
`linkAccountToSubscriptionCandidate.failed` | Unexpected failures after
inner retry/recovery handling |
| `RewardsController.optOut` catch | `optOut.failed` | API 500s or
network errors during opt-out |

All events tagged `{ feature: 'rewards', context: '<location>' }`. The
three captures with an `InternalAccount` in scope also emit `extra: {
accountType }` (chain namespace, e.g. `eip155:eoa`) for filtering by
account kind without exposing PII.

## Changelog

CHANGELOG entry: null

🤖 Generated with [Claude Code](https://claude.com/claude-code)

<!-- CURSOR_SUMMARY -->
---

> [!NOTE]
> **Low Risk**
> Primarily adds observability side effects in error paths without
changing success-path behavior; low risk aside from potential for minor
telemetry noise or additional overhead when failures occur.
> 
> **Overview**
> Adds targeted Sentry error reporting to rewards flows by calling
`captureException` in select catch blocks across
`useCandidateSubscriptionId` and `RewardsController` (silent auth
unexpected failures, 403 reauth retry failures, opt-in/linking failures,
and opt-out failures), consistently tagged with `{ feature: 'rewards',
context: ... }` and including `accountType` as extra where available.
> 
> Updates and extends unit tests to mock Sentry and assert the new
`captureException` calls (including new coverage for non-401 silent-auth
login errors and other unexpected failure cases).
> 
> <sup>Reviewed by [Cursor Bugbot](https://cursor.com/bugbot) for commit
ccf3146. Bugbot is set up for automated
code reviews on this repo. Configure
[here](https://www.cursor.com/dashboard/bugbot).</sup>
<!-- /CURSOR_SUMMARY -->

---------

Co-authored-by: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: VGR-GIT

app/components/UI/Rewards/hooks/useCandidateSubscriptionId.test.ts

@@ -1,5 +1,6 @@
 import { renderHook, act } from '@testing-library/react-hooks';
 import { useDispatch, useSelector } from 'react-redux';
+import { captureException } from '@sentry/react-native';
 import { useCandidateSubscriptionId } from './useCandidateSubscriptionId';
 import Engine from '../../../../core/Engine';
 import { setCandidateSubscriptionId } from '../../../../actions/rewards';
@@ -11,6 +12,10 @@ jest.mock('react-redux', () => ({
   useSelector: jest.fn(),
 }));
 
+jest.mock('@sentry/react-native', () => ({
+  captureException: jest.fn(),
+}));
+
 jest.mock('../../../../core/Engine', () => ({
   controllerMessenger: {
     call: jest.fn(),
@@ -42,6 +47,9 @@ describe('useCandidateSubscriptionId', () => {
   const mockEngineCall = Engine.controllerMessenger.call as jest.MockedFunction<
     typeof Engine.controllerMessenger.call
   >;
+  const mockCaptureException = captureException as jest.MockedFunction<
+    typeof captureException
+  >;
 
   beforeEach(() => {
     jest.clearAllMocks();
@@ -105,6 +113,12 @@ describe('useCandidateSubscriptionId', () => {
     expect(mockEngineCall).toHaveBeenCalledWith(
       'RewardsController:getCandidateSubscriptionId',
     );
+    expect(mockCaptureException).toHaveBeenCalledWith(mockError, {
+      tags: {
+        feature: 'rewards',
+        context: 'candidateSubscriptionId.fetch_failed',
+      },
+    });
     expect(mockDispatch).toHaveBeenCalledWith(
       setCandidateSubscriptionId('error'),
     );
@@ -157,6 +171,12 @@ describe('useCandidateSubscriptionId', () => {
     expect(mockEngineCall).toHaveBeenCalledWith(
       'RewardsController:getCandidateSubscriptionId',
     );
+    expect(mockCaptureException).toHaveBeenCalledWith(mockError, {
+      tags: {
+        feature: 'rewards',
+        context: 'candidateSubscriptionId.fetch_failed',
+      },
+    });
     expect(mockDispatch).toHaveBeenCalledWith(
       setCandidateSubscriptionId('error'),
     );

app/components/UI/Rewards/hooks/useCandidateSubscriptionId.ts

@@ -1,5 +1,6 @@
 import { useCallback, useEffect } from 'react';
 import { useDispatch, useSelector } from 'react-redux';
+import { captureException } from '@sentry/react-native';
 import { setCandidateSubscriptionId } from '../../../../actions/rewards';
 import { selectCandidateSubscriptionId } from '../../../../reducers/rewards/selectors';
 import Engine from '../../../../core/Engine';
@@ -20,6 +21,12 @@ export const useCandidateSubscriptionId = () => {
       );
       dispatch(setCandidateSubscriptionId(candidateId));
     } catch (error) {
+      captureException(error as Error, {
+        tags: {
+          feature: 'rewards',
+          context: 'candidateSubscriptionId.fetch_failed',
+        },
+      });
       dispatch(setCandidateSubscriptionId('error'));
     }
   }, [dispatch]);

app/core/Engine/controllers/rewards-controller/RewardsController.test.ts

@@ -114,6 +114,7 @@ import {
   SeasonNotFoundError,
   RewardsDataService,
 } from './services/rewards-data-service';
+import { captureException } from '@sentry/react-native';
 
 // Type the mocked modules
 // Note: mockStore is kept for potential future use but currently unused after feature flag removal
@@ -136,6 +137,9 @@ const mockToHex = toHex as jest.MockedFunction<typeof toHex>;
 const mockLogger = Logger as jest.Mocked<typeof Logger>;
 const mockStoreSubscriptionToken =
   storeSubscriptionToken as jest.MockedFunction<typeof storeSubscriptionToken>;
+const mockCaptureException = captureException as jest.MockedFunction<
+  typeof captureException
+>;
 const mockRemoveSubscriptionToken =
   removeSubscriptionToken as jest.MockedFunction<
     typeof removeSubscriptionToken
@@ -4560,6 +4564,48 @@ describe('RewardsController', () => {
         expect.anything(),
       );
     });
+
+    it('reports non-401 login errors to Sentry', async () => {
+      // Arrange — a 500 server error is unexpected and should be reported
+      const unexpectedError = new Error('Internal server error');
+      mockMessenger.call.mockClear();
+      mockStoreSubscriptionToken.mockResolvedValue({ success: true });
+      mockMessenger.call.mockImplementation(
+        (method: string, ..._args: unknown[]): any => {
+          if (method === 'AccountsController:listMultichainAccounts') {
+            return [mockInternalAccount];
+          }
+          if (method === 'RewardsDataService:getOptInStatus') {
+            return Promise.resolve({ ois: [true], sids: ['sub123'] });
+          }
+          if (method === 'KeyringController:signPersonalMessage') {
+            return Promise.resolve('0xsignature');
+          }
+          if (method === 'RewardsDataService:login') {
+            return Promise.reject(unexpectedError);
+          }
+          return Promise.resolve(undefined);
+        },
+      );
+
+      const testController = new RewardsController({
+        messenger: mockMessenger,
+        state: getRewardsControllerDefaultState(),
+        isDisabled: () => false,
+      });
+
+      // Act — call performSilentAuth directly with an opted-in account
+      await testController.performSilentAuth(mockInternalAccount, false, false);
+
+      // Assert — captureException called with the unexpected error
+      expect(mockCaptureException).toHaveBeenCalledWith(unexpectedError, {
+        tags: {
+          feature: 'rewards',
+          context: 'performSilentAuth.unexpected_error',
+        },
+        extra: { accountType: 'eip155:eoa' },
+      });
+    });
   });
 
   describe('getSeasonStatus', () => {
@@ -5230,6 +5276,14 @@ describe('RewardsController', () => {
       expect(mockLogger.log).toHaveBeenCalledWith(
         'RewardsController: Attempting reauth with active account after 403',
       );
+      expect(mockCaptureException).toHaveBeenCalledWith(
+        expect.objectContaining({
+          message: expect.stringContaining('Reauth failed'),
+        }),
+        {
+          tags: { feature: 'rewards', context: 'withAuthRetry.reauth_failed' },
+        },
+      );
     });
 
     it('reauthenticates with active account and retries after 403 error', async () => {
@@ -10238,6 +10292,13 @@ describe('RewardsController', () => {
       await expect(controller.optIn(mockAccounts)).rejects.toThrow(
         'Failed to opt in any account from the account group',
       );
+      expect(mockCaptureException).toHaveBeenCalledWith(
+        expect.objectContaining({ message: 'Optin service error' }),
+        {
+          tags: { feature: 'rewards', context: 'optIn.unexpected_error' },
+          extra: { accountType: 'eip155:eoa' },
+        },
+      );
     });
 
     it('handles signature generation errors', async () => {
@@ -11267,6 +11328,35 @@ describe('RewardsController', () => {
       expect(newState.subscriptions[subscriptionId2]).toBeDefined();
       expect(newState.subscriptions[subscriptionId2].id).toBe(subscriptionId2);
     });
+
+    it('reports unexpected opt-out failures to Sentry', async () => {
+      // Arrange — a non-403 server error is unexpected and should be captured
+      const unexpectedError = new Error('Internal server error');
+      mockMessenger.call.mockRejectedValue(unexpectedError);
+
+      const testController = new TestableRewardsController({
+        messenger: mockMessenger,
+        state: {
+          ...getRewardsControllerDefaultState(),
+          subscriptions: {
+            sub123: {
+              id: 'sub123',
+              referralCode: 'REF123',
+              accounts: [],
+            },
+          },
+        },
+      });
+
+      // Act
+      const result = await testController.optOut('sub123');
+
+      // Assert
+      expect(result).toBe(false);
+      expect(mockCaptureException).toHaveBeenCalledWith(unexpectedError, {
+        tags: { feature: 'rewards', context: 'optOut.failed' },
+      });
+    });
   });
 
   describe('optIn and optOut edge cases', () => {
@@ -13133,6 +13223,13 @@ describe('RewardsController', () => {
 
       // Assert
       expect(result).toBe(false);
+      expect(mockCaptureException).toHaveBeenCalledWith(mockError, {
+        tags: {
+          feature: 'rewards',
+          context: 'linkAccountToSubscriptionCandidate.failed',
+        },
+        extra: { accountType: 'eip155:eoa' },
+      });
       expect(mockLogger.log).toHaveBeenCalledWith(
         'RewardsController: Failed to link account to subscription',
         CAIP_ACCOUNT_1,

app/core/Engine/controllers/rewards-controller/RewardsController.ts

@@ -56,6 +56,7 @@ import {
   getSubscriptionToken,
 } from './utils/multi-subscription-token-vault';
 import Logger from '../../../../util/Logger';
+import { captureException } from '@sentry/react-native';
 import type { InternalAccount } from '@metamask/keyring-internal-api';
 import { isAddress as isSolanaAddress } from '@solana/addresses';
 import { isHardwareAccount } from '../../../../util/address';
@@ -950,6 +951,9 @@ export class RewardsController extends BaseController<
       try {
         await this.#reauthPromises.get(subscriptionId);
       } catch (reauthError) {
+        captureException(reauthError as Error, {
+          tags: { feature: 'rewards', context: 'withAuthRetry.reauth_failed' },
+        });
         this.invalidateSubscriptionCache(subscriptionId);
         await this.invalidateSubscriptionAndAccounts(subscriptionId);
         throw reauthError;
@@ -1314,6 +1318,13 @@ export class RewardsController extends BaseController<
         // Unknown error
         subscription = null;
         authUnexpectedError = true;
+        captureException(error as Error, {
+          tags: {
+            feature: 'rewards',
+            context: 'performSilentAuth.unexpected_error',
+          },
+          extra: { accountType: internalAccount.type },
+        });
       }
     } finally {
       // Update state
@@ -2541,6 +2552,10 @@ export class RewardsController extends BaseController<
         sessionId: optinResponse.sessionId,
       };
     } catch (error) {
+      captureException(error as Error, {
+        tags: { feature: 'rewards', context: 'optIn.unexpected_error' },
+        extra: { accountType: account.type },
+      });
       Logger.log(
         'RewardsController: Opt-in failed for account',
         account.address,
@@ -3059,6 +3074,13 @@ export class RewardsController extends BaseController<
 
       return true;
     } catch (error) {
+      captureException(error as Error, {
+        tags: {
+          feature: 'rewards',
+          context: 'linkAccountToSubscriptionCandidate.failed',
+        },
+        extra: { accountType: account.type },
+      });
       Logger.log(
         'RewardsController: Failed to link account to subscription',
         caipAccount,
@@ -3178,6 +3200,9 @@ export class RewardsController extends BaseController<
       );
       return false;
     } catch (error) {
+      captureException(error as Error, {
+        tags: { feature: 'rewards', context: 'optOut.failed' },
+      });
       Logger.log('RewardsController: Failed to opt out', error);
       return false;
     }