feat: track snap account metrics (#14686)

## **Description**

This PR adds metric tracking for basic snap account actions. This brings
the metric tracking more inline with the events we already track on the
extension.

The main events that we are tracking are the following...
1. Snap account creation
- [Equivalent extension
event](https://github.com/MetaMask/metamask-extension/blob/5d953bf41b950eeb8358a735729c22d1e45386f6/app/scripts/lib/snap-keyring/snap-keyring.ts#L362)
- [Extension event
definition](https://github.com/MetaMask/metamask-extension/blob/478b45f3ffa7619378e43f9367e62edff6b5b810/shared/constants/metametrics.ts#L645)
2. Snap account removal
- [Equivalent extension event
](https://github.com/MetaMask/metamask-extension/blob/5d953bf41b950eeb8358a735729c22d1e45386f6/app/scripts/lib/snap-keyring/snap-keyring.ts#L547)
- [Extension event
definition](https://github.com/MetaMask/metamask-extension/blob/478b45f3ffa7619378e43f9367e62edff6b5b810/shared/constants/metametrics.ts#L826)
3. Failed attempts at snap account removal
- [Equivalent extension
event](https://github.com/MetaMask/metamask-extension/blob/5d953bf41b950eeb8358a735729c22d1e45386f6/app/scripts/lib/snap-keyring/snap-keyring.ts#L532)
- [Extension event
definition](https://github.com/MetaMask/metamask-extension/blob/478b45f3ffa7619378e43f9367e62edff6b5b810/shared/constants/metametrics.ts#L827)

On mobile we do not have snap account confirmations so we skipped all of
those events.

## **Related issues**

Fixes: MetaMask/accounts-planning#695

## **Manual testing steps**

1. ensure you are building metamask flask by editing the
`METAMASK_BUILD_TYPE` to `flask` in the `.js.env`
2. `yarn setup && yarn start:ios`
3. import/create an account
4. click on the selected account at the top of the screen
5. click `add new account or hardware wallet`
6. click on `solana`
7. the solana account should be created
8. repeat the above steps and then click on `Bitcoin` instead
9. the Bitcoin account should be created. 

## **Screenshots/Recordings**


### **Before**

<!-- [screenshots/recordings] -->

### **After**

I added a log to the trackSnapAccountEvent to verify that it is called
when we create a new solana account


https://github.com/user-attachments/assets/328b95c3-0b8b-4a62-b712-4303bf1fde27


## **Pre-merge author checklist**

- [ ] I’ve followed [MetaMask Contributor
Docs](https://github.com/MetaMask/contributor-docs) and [MetaMask Mobile
Coding
Standards](https://github.com/MetaMask/metamask-mobile/blob/main/.github/guidelines/CODING_GUIDELINES.md).
- [ ] I've completed the PR template to the best of my ability
- [ ] I’ve included tests if applicable
- [ ] I’ve documented my code using [JSDoc](https://jsdoc.app/) format
if applicable
- [ ] I’ve applied the right labels on the PR (see [labeling
guidelines](https://github.com/MetaMask/metamask-mobile/blob/main/.github/guidelines/LABELING_GUIDELINES.md)).
Not required for external contributors.

## **Pre-merge reviewer checklist**

- [ ] I've manually tested the PR (e.g. pull and build branch, run the
app, test code being changed).
- [ ] I confirm that this PR addresses all acceptance criteria described
in the ticket it closes and includes the necessary testing evidence such
as recordings and or screenshots.

Author: owencraston

app/core/Analytics/MetaMetrics.events.ts

@@ -381,6 +381,9 @@ enum EVENT_NAME {
 
   // Remove an account
   ACCOUNT_REMOVED = 'Account removed',
+  ACCOUNT_REMOVE_FAILED = 'Account remove failed',
+  // Account added
+  ACCOUNT_ADDED = 'Account Added',
 
   //Notifications
   ALL_NOTIFICATIONS = 'All Notifications',
@@ -493,11 +496,11 @@ const events = {
     EVENT_NAME.CONNECT_REQUEST_OTPFAILURE,
   ),
   CONNECT_REQUEST_CANCELLED: generateOpt(EVENT_NAME.CONNECT_REQUEST_CANCELLED),
-  
+
   // Phishing events
   PHISHING_PAGE_DISPLAYED: generateOpt(EVENT_NAME.PHISHING_PAGE_DISPLAYED),
   PROCEED_ANYWAY_CLICKED: generateOpt(EVENT_NAME.PROCEED_ANYWAY_CLICKED),
-  
+
   WALLET_OPENED: generateOpt(EVENT_NAME.WALLET_OPENED),
   TOKEN_ADDED: generateOpt(EVENT_NAME.TOKEN_ADDED),
   COLLECTIBLE_ADDED: generateOpt(EVENT_NAME.COLLECTIBLE_ADDED),
@@ -863,6 +866,8 @@ const events = {
 
   // Remove an account
   ACCOUNT_REMOVED: generateOpt(EVENT_NAME.ACCOUNT_REMOVED),
+  ACCOUNT_REMOVE_FAILED: generateOpt(EVENT_NAME.ACCOUNT_REMOVE_FAILED),
+  ACCOUNT_ADDED: generateOpt(EVENT_NAME.ACCOUNT_ADDED),
 
   // Smart transactions
   SMART_TRANSACTION_OPT_IN: generateOpt(EVENT_NAME.SMART_TRANSACTION_OPT_IN),

app/core/Analytics/helpers/SnapKeyring/trackSnapAccountEvent.test.ts

@@ -0,0 +1,60 @@
+import { IMetaMetricsEvent, MetaMetrics } from '../..';
+import { trackSnapAccountEvent } from './trackSnapAccountEvent';
+import { MetricsEventBuilder } from '../../MetricsEventBuilder';
+import { IMetaMetrics } from '../../MetaMetrics.types';
+
+const mockTrackEvent = jest.fn();
+const mockAddProperties = jest.fn().mockReturnThis();
+const mockBuild = jest.fn().mockReturnValue({ mockBuiltEvent: true });
+const mockCreateEventBuilder = jest.fn().mockReturnValue({
+  addProperties: mockAddProperties,
+  build: mockBuild,
+});
+
+jest
+  .spyOn(MetricsEventBuilder, 'createEventBuilder')
+  .mockImplementation(mockCreateEventBuilder);
+
+jest.spyOn(MetaMetrics, 'getInstance').mockReturnValue({
+  trackEvent: mockTrackEvent,
+  isEnabled: jest.fn(),
+  enable: jest.fn(),
+  addTraitsToUser: jest.fn(),
+  group: jest.fn(),
+  reset: jest.fn(),
+  flush: jest.fn(),
+  createDataDeletionTask: jest.fn(),
+  checkDataDeleteStatus: jest.fn(),
+  getDeleteRegulationCreationDate: jest.fn(),
+  getDeleteRegulationId: jest.fn(),
+  isDataRecorded: jest.fn(),
+  configure: jest.fn(),
+  getMetaMetricsId: jest.fn(),
+} as IMetaMetrics);
+
+describe('trackSnapAccountEvent', () => {
+  const mockMetricEvent: IMetaMetricsEvent = {
+    category: 'testCategory',
+    properties: { name: 'testEvent' },
+  };
+  const mockSnapId = 'npm:@metamask/test-snap';
+  const mockSnapName = 'Test Snap';
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('should create and track an event with the correct properties', () => {
+    trackSnapAccountEvent(mockMetricEvent, mockSnapId, mockSnapName);
+    expect(mockCreateEventBuilder).toHaveBeenCalledWith(mockMetricEvent);
+    expect(mockAddProperties).toHaveBeenCalledWith({
+      account_type: 'Snap',
+      snap_id: mockSnapId,
+      snap_name: mockSnapName,
+    });
+
+    expect(mockBuild).toHaveBeenCalled();
+    // Verify MetaMetrics trackEvent was called with the built event
+    expect(mockTrackEvent).toHaveBeenCalledWith({ mockBuiltEvent: true });
+  });
+});

app/core/Analytics/helpers/SnapKeyring/trackSnapAccountEvent.ts

@@ -0,0 +1,33 @@
+import { IMetaMetricsEvent, MetaMetrics } from '../..';
+import Logger from '../../../../util/Logger';
+import { MetricsEventBuilder } from '../../MetricsEventBuilder';
+
+/**
+ * Track a Snap account-related event.
+ *
+ * @param metricEvent - The name of the event to track.
+ * @param snapId - The ID of the Snap.
+ * @param snapName - The name of the Snap.
+ */
+export function trackSnapAccountEvent(
+  metricEvent: IMetaMetricsEvent,
+  snapId: string,
+  snapName: string,
+): void {
+  try {
+    const event = MetricsEventBuilder.createEventBuilder(metricEvent)
+      .addProperties({
+        account_type: 'Snap',
+        snap_id: snapId,
+        snap_name: snapName,
+      })
+      .build();
+
+    MetaMetrics.getInstance().trackEvent(event);
+  } catch (error) {
+    Logger.error(
+      error as Error,
+      `Error tracking snap account event: ${JSON.stringify(metricEvent)}`,
+    );
+  }
+}

app/core/SnapKeyring/SnapKeyring.test.ts

@@ -16,6 +16,7 @@ import { SNAP_MANAGE_ACCOUNTS_CONFIRMATION_TYPES } from '../RPCMethods/RPCMethod
 import { showAccountNameSuggestionDialog } from './utils/showDialog';
 import Logger from '../../util/Logger';
 import { isSnapPreinstalled } from './utils/snaps';
+import { trackSnapAccountEvent } from '../Analytics/helpers/SnapKeyring/trackSnapAccountEvent';
 
 const mockAddRequest = jest.fn();
 const mockStartFlow = jest.fn();
@@ -144,6 +145,12 @@ const createSnapKeyringBuilder = () =>
 // Mock the isSnapPreinstalled function
 jest.mock('./utils/snaps', () => ({
   isSnapPreinstalled: jest.fn(),
+  getSnapName: jest.fn().mockReturnValue('Mock Snap Name'),
+}));
+
+// Mock the trackSnapAccountEvent function
+jest.mock('../Analytics/helpers/SnapKeyring/trackSnapAccountEvent', () => ({
+  trackSnapAccountEvent: jest.fn(),
 }));
 
 describe('Snap Keyring Methods', () => {
@@ -212,6 +219,12 @@ describe('Snap Keyring Methods', () => {
       expect(mockGetAccounts).toHaveBeenCalledTimes(1);
       expect(mockSetAccountName).not.toHaveBeenCalled();
       expect(mockEndFlow).toHaveBeenCalledWith([{ id: mockFlowId }]);
+
+      // Wait for any pending promises (including the account finalization which tracks the event)
+      await waitForAllPromises();
+
+      // Verify trackSnapAccountEvent was called for successful account creation
+      expect(trackSnapAccountEvent).toHaveBeenCalled();
     });
 
     it('handles account creation with user defined name', async () => {
@@ -250,6 +263,12 @@ describe('Snap Keyring Methods', () => {
       ]);
       expect(mockEndFlow).toHaveBeenCalledTimes(2);
       expect(mockEndFlow).toHaveBeenCalledWith([{ id: mockFlowId }]);
+
+      // Wait for any pending promises (including the account finalization which tracks the event)
+      await waitForAllPromises();
+
+      // Verify trackSnapAccountEvent was called
+      expect(trackSnapAccountEvent).toHaveBeenCalled();
     });
 
     it('throws an error when user denies account creation', async () => {
@@ -342,6 +361,7 @@ describe('Snap Keyring Methods', () => {
       expect(mockEndFlow).toHaveBeenCalledTimes(2);
       expect(mockEndFlow).toHaveBeenNthCalledWith(1, [{ id: mockFlowId }]);
       expect(mockEndFlow).toHaveBeenNthCalledWith(2, [{ id: mockFlowId }]);
+      expect(trackSnapAccountEvent).not.toHaveBeenCalled();
     });
     it('skips account name suggestion dialog for preinstalled snaps when displayAccountNameSuggestion is false', async () => {
       // Mock isSnapPreinstalled to return true for this test
@@ -467,4 +487,95 @@ describe('Snap Keyring Methods', () => {
       ]);
     });
   });
+  describe('removeAccount', () => {
+    beforeEach(() => {
+      mockAddRequest.mockReturnValue(true).mockReturnValue({ success: true });
+      (isSnapPreinstalled as jest.Mock).mockReset();
+    });
+    afterEach(() => {
+      jest.resetAllMocks();
+    });
+
+    it('calls removeAccountHelper and persistKeyringHelper when account is deleted', async () => {
+      const builder = createSnapKeyringBuilder();
+      const snapKeyring = builder();
+
+      // First add an account to the keyring so that it can be removed
+      // NOTE: This callback will not be triggered if there are no accounts in the keyring
+      await snapKeyring.handleKeyringSnapMessage(mockSnapId, {
+        method: KeyringEvent.AccountCreated,
+        params: {
+          account: mockAccount,
+          displayConfirmation: false,
+        },
+      });
+
+      // Reset mocks after account creation
+      mockRemoveAccountHelper.mockReset();
+      mockPersisKeyringHelper.mockReset();
+
+      // Now delete the account
+      await snapKeyring.handleKeyringSnapMessage(mockSnapId, {
+        method: KeyringEvent.AccountDeleted,
+        params: {
+          id: mockAccount.id,
+        },
+      });
+
+      expect(mockRemoveAccountHelper).toHaveBeenCalledTimes(1);
+      expect(mockRemoveAccountHelper).toHaveBeenCalledWith(
+        mockAccount.address.toLowerCase(),
+      );
+      expect(mockPersisKeyringHelper).toHaveBeenCalledTimes(2);
+
+      // Verify trackSnapAccountEvent was called
+      expect(trackSnapAccountEvent).toHaveBeenCalled();
+    });
+
+    it('handles errors when removing an account', async () => {
+      const loggerSpy = jest.spyOn(Logger, 'error').mockImplementation();
+
+      // Set up mock to throw an error
+      const errorMessage = 'Failed to remove account';
+      mockRemoveAccountHelper.mockRejectedValue(new Error(errorMessage));
+
+      const builder = createSnapKeyringBuilder();
+      const snapKeyring = builder();
+
+      // First add an account to the keyring so that it can be removed
+      await snapKeyring.handleKeyringSnapMessage(mockSnapId, {
+        method: KeyringEvent.AccountCreated,
+        params: {
+          account: mockAccount,
+          displayConfirmation: false,
+        },
+      });
+
+      // Reset mocks after account creation
+      mockRemoveAccountHelper.mockReset();
+      mockPersisKeyringHelper.mockReset();
+      mockRemoveAccountHelper.mockRejectedValue(new Error(errorMessage));
+
+      // Expect the error to be thrown
+      await expect(
+        snapKeyring.handleKeyringSnapMessage(mockSnapId, {
+          method: KeyringEvent.AccountDeleted,
+          params: {
+            id: mockAccount.id,
+          },
+        }),
+      ).rejects.toThrow(errorMessage);
+
+      // Verify error was logged
+      expect(loggerSpy).toHaveBeenCalledWith(
+        expect.objectContaining({ message: errorMessage }),
+        expect.stringContaining(
+          `Error removing snap account: ${mockAccount.address.toLowerCase()}`,
+        ),
+      );
+
+      // Verify trackSnapAccountEvent was called for error case
+      expect(trackSnapAccountEvent).toHaveBeenCalled();
+    });
+  });
 });

app/core/SnapKeyring/SnapKeyring.ts

@@ -10,10 +10,12 @@ import { SnapKeyringBuilderMessenger } from './types';
 import { SnapId } from '@metamask/snaps-sdk';
 import { assertIsValidSnapId } from '@metamask/snaps-utils';
 import { getUniqueAccountName } from './utils/getUniqueAccountName';
-import { isSnapPreinstalled } from './utils/snaps';
+import { getSnapName, isSnapPreinstalled } from './utils/snaps';
 import { endTrace, trace, TraceName, TraceOperation } from '../../util/trace';
 import { getTraceTags } from '../../util/sentry/tags';
 import { store } from '../../store';
+import { MetaMetricsEvents } from '../../core/Analytics/MetaMetrics.events';
+import { trackSnapAccountEvent } from '../Analytics/helpers/SnapKeyring/trackSnapAccountEvent';
 
 /**
  * Builder type for the Snap keyring.
@@ -140,6 +142,8 @@ class SnapKeyringImpl implements SnapKeyringCallbacks {
   }
 
   private async addAccountFinalize({
+    address: _address,
+    snapId,
     accountName,
     onceSaved,
   }: {
@@ -176,6 +180,15 @@ class SnapKeyringImpl implements SnapKeyringCallbacks {
             accountName,
           );
         }
+
+        // Track successful account addition
+        const snapName = getSnapName(snapId as SnapId, this.#messenger);
+        trackSnapAccountEvent(
+          MetaMetricsEvents.ACCOUNT_ADDED,
+          snapId,
+          snapName,
+        );
+
         endTrace({
           name: TraceName.AddSnapAccount,
         });
@@ -231,17 +244,39 @@ class SnapKeyringImpl implements SnapKeyringCallbacks {
     handleUserInput: (accepted: boolean) => Promise<void>,
   ) {
     assertIsValidSnapId(snapId);
+
     // TODO: Implement proper snap account confirmations. Currently, we are approving everything for testing purposes.
     Logger.log(
       `SnapKeyring: removeAccount called with \n
           - address: ${address} \n
           - handleUserInput: ${handleUserInput} \n
           - snapId: ${snapId} \n`,
     );
+
     // Approve everything for now because we have not implemented snap account confirmations yet
     await handleUserInput(true);
-    await this.#removeAccountHelper(address);
-    await this.#persistKeyringHelper();
+
+    try {
+      await this.#removeAccountHelper(address);
+      await this.#persistKeyringHelper();
+
+      // Track successful account removal
+      const snapName = getSnapName(snapId as SnapId, this.#messenger);
+      trackSnapAccountEvent(
+        MetaMetricsEvents.ACCOUNT_REMOVED,
+        snapId,
+        snapName,
+      );
+    } catch (error) {
+      Logger.error(error as Error, `Error removing snap account: ${address}`);
+      const snapName = getSnapName(snapId as SnapId, this.#messenger);
+      trackSnapAccountEvent(
+        MetaMetricsEvents.ACCOUNT_REMOVED,
+        snapId,
+        snapName,
+      );
+      throw error;
+    }
   }
 
   async redirectUser(snapId: string, url: string, message: string) {