feat: Shield: log transaction and signature (#6633)

## Explanation

Context: ShieldController

Once a transaction is submitted or a signature request is fulfilled, the
transaction hash or signature, respectively, are logged on the backend.

<!--
Thanks for your contribution! Take a moment to answer these questions so
that reviewers have the information they need to properly understand
your changes:

* What is the current state of things and why does it need to change?
* What is the solution your changes offer and how does it work?
* Are there any changes whose purpose might not obvious to those
unfamiliar with the domain?
* If your primary goal was to update one package but you found you had
to update another one along the way, why did you do so?
* If you had to upgrade a dependency, why did you do so?
-->

## References

<!--
Are there any issues that this pull request is tied to?
Are there other links that reviewers should consult to understand these
changes better?
Are there client or consumer pull requests to adopt any breaking
changes?

For example:

* Fixes #12345
* Related to #67890
-->

## Checklist

- [x] I've updated the test suite for new or updated code as appropriate
- [x] I've updated documentation (JSDoc, Markdown, etc.) for new or
updated code as appropriate
- [x] I've communicated my changes to consumers by [updating changelogs
for packages I've
changed](https://github.com/MetaMask/core/tree/main/docs/contributing.md#updating-changelogs),
highlighting breaking changes as necessary
- [ ] I've prepared draft pull requests for clients and consumer
packages to resolve any breaking changes

Author: matthiasgeihs

packages/shield-controller/CHANGELOG.md

@@ -11,6 +11,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 - Add two new controller state metadata properties: `includeInStateLogs` and `usedInUi` ([#6504](https://github.com/MetaMask/core/pull/6504))
 - Add signature coverage checking ([#6501](https://github.com/MetaMask/core/pull/6501))
+- Add transaction and signature logging ([#6633](https://github.com/MetaMask/core/pull/6633))
 
 ### Changed
 

packages/shield-controller/src/ShieldController.test.ts

@@ -1,9 +1,17 @@
 import { deriveStateFromMetadata } from '@metamask/base-controller';
-import type { SignatureControllerState } from '@metamask/signature-controller';
-import type { TransactionControllerState } from '@metamask/transaction-controller';
+import type { SignatureRequest } from '@metamask/signature-controller';
+import {
+  SignatureRequestStatus,
+  type SignatureControllerState,
+} from '@metamask/signature-controller';
+import type { TransactionMeta } from '@metamask/transaction-controller';
+import {
+  TransactionStatus,
+  type TransactionControllerState,
+} from '@metamask/transaction-controller';
 
 import { ShieldController } from './ShieldController';
-import { createMockBackend } from '../tests/mocks/backend';
+import { createMockBackend, MOCK_COVERAGE_ID } from '../tests/mocks/backend';
 import { createMockMessenger } from '../tests/mocks/messenger';
 import {
   generateMockSignatureRequest,
@@ -218,6 +226,174 @@ describe('ShieldController', () => {
     );
   });
 
+  describe('logSignature', () => {
+    /**
+     * Run a test that logs a signature.
+     *
+     * @param components - An object containing the messenger and base messenger.
+     * @param options - An object containing optional parameters.
+     * @param options.updateSignatureRequest - A function that updates the signature request.
+     */
+    async function runTest(
+      components: ReturnType<typeof setup>,
+      options?: {
+        updateSignatureRequest?: (signatureRequest: SignatureRequest) => void;
+      },
+    ) {
+      const { messenger, baseMessenger } = components;
+
+      // Create a promise that resolves when the state changes
+      const stateUpdated = new Promise((resolve) =>
+        messenger.subscribe('ShieldController:stateChange', resolve),
+      );
+
+      // Publish a signature request
+      const signatureRequest = generateMockSignatureRequest();
+      baseMessenger.publish(
+        'SignatureController:stateChange',
+        {
+          signatureRequests: { [signatureRequest.id]: signatureRequest },
+        } as SignatureControllerState,
+        undefined as never,
+      );
+
+      // Wait for state to be updated
+      await stateUpdated;
+
+      // Update signature request
+      const updatedSignatureRequest = { ...signatureRequest };
+      updatedSignatureRequest.status = SignatureRequestStatus.Signed;
+      updatedSignatureRequest.rawSig = '0x00';
+      options?.updateSignatureRequest?.(updatedSignatureRequest);
+      baseMessenger.publish(
+        'SignatureController:stateChange',
+        {
+          signatureRequests: { [signatureRequest.id]: updatedSignatureRequest },
+        } as SignatureControllerState,
+        undefined as never,
+      );
+    }
+
+    it('logs a signature', async () => {
+      const components = setup();
+
+      await runTest(components);
+
+      // Check that backend was called
+      expect(components.backend.logSignature).toHaveBeenCalledWith({
+        coverageId: MOCK_COVERAGE_ID,
+        signature: '0x00',
+        status: 'shown',
+      });
+    });
+
+    it('does not log when coverageId is missing', async () => {
+      const components = setup();
+
+      components.backend.checkSignatureCoverage.mockResolvedValue({
+        coverageId: undefined,
+        status: 'unknown',
+      });
+
+      await runTest(components);
+
+      // Check that backend was not called
+      expect(components.backend.logSignature).not.toHaveBeenCalled();
+    });
+
+    it('does not log when signature is missing', async () => {
+      const components = setup();
+
+      await runTest(components, {
+        updateSignatureRequest: (signatureRequest) => {
+          signatureRequest.rawSig = undefined;
+        },
+      });
+
+      // Check that backend was not called
+      expect(components.backend.logSignature).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('logTransaction', () => {
+    /**
+     * Runs a test that logs a transaction.
+     *
+     * @param components - An object containing the messenger and base messenger.
+     * @param options - Options for the test.
+     * @param options.updateTransaction - A function that updates the transaction.
+     */
+    async function runTest(
+      components: ReturnType<typeof setup>,
+      options?: { updateTransaction: (txMeta: TransactionMeta) => void },
+    ) {
+      const { messenger, baseMessenger } = components;
+      // Create a promise that resolves when the state changes
+      const stateUpdated = new Promise((resolve) =>
+        messenger.subscribe('ShieldController:stateChange', resolve),
+      );
+
+      // Publish a transaction
+      const txMeta = generateMockTxMeta();
+      baseMessenger.publish(
+        'TransactionController:stateChange',
+        { transactions: [txMeta] } as TransactionControllerState,
+        undefined as never,
+      );
+
+      // Wait for state to be updated
+      await stateUpdated;
+
+      // Update transaction
+      const updatedTxMeta = { ...txMeta };
+      updatedTxMeta.status = TransactionStatus.submitted;
+      updatedTxMeta.hash = '0x00';
+      options?.updateTransaction(updatedTxMeta);
+      baseMessenger.publish(
+        'TransactionController:stateChange',
+        { transactions: [updatedTxMeta] } as TransactionControllerState,
+        undefined as never,
+      );
+    }
+
+    it('logs a transaction', async () => {
+      const components = setup();
+      await runTest(components);
+
+      // Check that backend was called
+      expect(components.backend.logTransaction).toHaveBeenCalledWith({
+        coverageId: MOCK_COVERAGE_ID,
+        status: 'shown',
+        transactionHash: '0x00',
+      });
+    });
+
+    it('does not log when coverageId is missing', async () => {
+      const components = setup();
+
+      components.backend.checkCoverage.mockResolvedValue({
+        coverageId: undefined,
+        status: 'unknown',
+      });
+
+      await runTest(components);
+
+      // Check that backend was not called
+      expect(components.backend.logTransaction).not.toHaveBeenCalled();
+    });
+
+    it('does not log when hash is missing', async () => {
+      const components = setup();
+
+      await runTest(components, {
+        updateTransaction: (txMeta) => delete txMeta.hash,
+      });
+
+      // Check that backend was not called
+      expect(components.backend.logTransaction).not.toHaveBeenCalled();
+    });
+  });
+
   describe('metadata', () => {
     it('includes expected state in debug snapshots', () => {
       const { controller } = setup();

packages/shield-controller/src/ShieldController.ts

@@ -4,13 +4,15 @@ import type {
   RestrictedMessenger,
 } from '@metamask/base-controller';
 import {
+  SignatureRequestStatus,
   SignatureRequestType,
   type SignatureRequest,
   type SignatureStateChange,
 } from '@metamask/signature-controller';
-import type {
-  TransactionControllerStateChangeEvent,
-  TransactionMeta,
+import {
+  TransactionStatus,
+  type TransactionControllerStateChangeEvent,
+  type TransactionMeta,
 } from '@metamask/transaction-controller';
 
 import { controllerName } from './constants';
@@ -230,6 +232,17 @@ export class ShieldController extends BaseController<
           (error) => log('Error checking coverage:', error),
         );
       }
+
+      // Log signature once the signature request has been fulfilled.
+      if (
+        signatureRequest.status === SignatureRequestStatus.Signed &&
+        signatureRequest.status !== previousSignatureRequest?.status
+      ) {
+        this.#logSignature(signatureRequest).catch(
+          // istanbul ignore next
+          (error) => log('Error logging signature:', error),
+        );
+      }
     }
   }
 
@@ -256,6 +269,17 @@ export class ShieldController extends BaseController<
           (error) => log('Error checking coverage:', error),
         );
       }
+
+      // Log transaction once it has been submitted.
+      if (
+        transaction.status === TransactionStatus.submitted &&
+        transaction.status !== previousTransaction?.status
+      ) {
+        this.#logTransaction(transaction).catch(
+          // istanbul ignore next
+          (error) => log('Error logging transaction:', error),
+        );
+      }
     }
   }
 
@@ -346,4 +370,49 @@ export class ShieldController extends BaseController<
       }
     });
   }
+
+  async #logSignature(signatureRequest: SignatureRequest) {
+    const coverageId = this.#getLatestCoverageId(signatureRequest.id);
+    if (!coverageId) {
+      throw new Error('Coverage ID not found');
+    }
+
+    const sig = signatureRequest.rawSig;
+    if (!sig) {
+      throw new Error('Signature not found');
+    }
+
+    await this.#backend.logSignature({
+      coverageId,
+      signature: sig,
+      // Status is 'shown' because the coverageId can only be retrieved after
+      // the result is in the state. If the result is in the state, we assume
+      // that it has been shown.
+      status: 'shown',
+    });
+  }
+
+  async #logTransaction(txMeta: TransactionMeta) {
+    const coverageId = this.#getLatestCoverageId(txMeta.id);
+    if (!coverageId) {
+      throw new Error('Coverage ID not found');
+    }
+
+    const txHash = txMeta.hash;
+    if (!txHash) {
+      throw new Error('Transaction hash not found');
+    }
+    await this.#backend.logTransaction({
+      coverageId,
+      transactionHash: txHash,
+      // Status is 'shown' because the coverageId can only be retrieved after
+      // the result is in the state. If the result is in the state, we assume
+      // that it has been shown.
+      status: 'shown',
+    });
+  }
+
+  #getLatestCoverageId(itemId: string) {
+    return this.state.coverageResults[itemId]?.results[0]?.coverageId;
+  }
 }