feat: Re-simulate active transactions every 3000 ms

eslint-warning-thresholds.json

@@ -565,7 +565,6 @@
     "jsdoc/tag-lines": 4
   },
   "packages/transaction-controller/src/TransactionController.test.ts": {
-    "@typescript-eslint/no-unused-vars": 1,
     "import-x/namespace": 1,
     "import-x/order": 4,
     "jsdoc/tag-lines": 1,
@@ -701,13 +700,6 @@
   "packages/transaction-controller/src/utils/nonce.test.ts": {
     "import-x/order": 1
   },
-  "packages/transaction-controller/src/utils/resimulate.test.ts": {
-    "import-x/order": 2
-  },
-  "packages/transaction-controller/src/utils/resimulate.ts": {
-    "import-x/order": 1,
-    "jsdoc/tag-lines": 7
-  },
   "packages/transaction-controller/src/utils/retry.test.ts": {
     "import-x/order": 1
   },

packages/transaction-controller/CHANGELOG.md

@@ -7,6 +7,13 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+### Added
+
+- Adds ability of re-simulating transaction depending on the `isActive` property on `transactionMeta` ([#5189](https://github.com/MetaMask/core/pull/5189))
+  - `isActive` property is expected to set by client.
+  - Re-simulation of transactions will occur every 3 seconds if `isActive` is `true`.
+- Adds `setTransactionActive` function to update the `isActive` property on `transactionMeta`. ([#5189](https://github.com/MetaMask/core/pull/5189))
+
 ## [45.1.0]
 
 ### Added

packages/transaction-controller/jest.config.js

@@ -18,7 +18,7 @@ module.exports = merge(baseConfig, {
   coverageThreshold: {
     global: {
       branches: 91.76,
-      functions: 94.62,
+      functions: 94.57,
       lines: 96.83,
       statements: 96.82,
     },

packages/transaction-controller/src/TransactionController.test.ts

@@ -50,6 +50,7 @@ import { IncomingTransactionHelper } from './helpers/IncomingTransactionHelper';
 import { MethodDataHelper } from './helpers/MethodDataHelper';
 import { MultichainTrackingHelper } from './helpers/MultichainTrackingHelper';
 import { PendingTransactionTracker } from './helpers/PendingTransactionTracker';
+import { shouldResimulate } from './helpers/ResimulateHelper';
 import type {
   AllowedActions,
   AllowedEvents,
@@ -86,7 +87,6 @@ import {
   getTransactionLayer1GasFee,
   updateTransactionLayer1GasFee,
 } from './utils/layer1-gas-fee-flow';
-import { shouldResimulate } from './utils/resimulate';
 import { getSimulationData } from './utils/simulation';
 import {
   updatePostTransactionBalance,
@@ -115,7 +115,10 @@ jest.mock('./utils/gas');
 jest.mock('./utils/gas-fees');
 jest.mock('./utils/gas-flow');
 jest.mock('./utils/layer1-gas-fee-flow');
-jest.mock('./utils/resimulate');
+jest.mock('./helpers/ResimulateHelper', () => ({
+  ...jest.requireActual('./helpers/ResimulateHelper'),
+  shouldResimulate: jest.fn(),
+}));
 jest.mock('./utils/simulation');
 jest.mock('./utils/swaps');
 jest.mock('uuid');
@@ -2354,7 +2357,7 @@ describe('TransactionController', () => {
 
         try {
           await result;
-        } catch (error) {
+        } catch {
           // Ignore user rejected error as it is expected
         }
         await finishedPromise;
@@ -6075,4 +6078,41 @@ describe('TransactionController', () => {
       );
     });
   });
+
+  describe('setTransactionActive', () => {
+    it('throws if transaction does not exist', async () => {
+      const { controller } = setupController();
+      expect(() => controller.setTransactionActive('123', true)).toThrow(
+        'Transaction with id 123 not found',
+      );
+    });
+
+    it('updates the isActive state of a transaction', async () => {
+      const transactionId = '123';
+      const { controller } = setupController({
+        options: {
+          state: {
+            transactions: [
+              {
+                id: transactionId,
+                status: TransactionStatus.unapproved,
+                history: [{}],
+                txParams: {
+                  from: ACCOUNT_MOCK,
+                  to: ACCOUNT_2_MOCK,
+                },
+              } as unknown as TransactionMeta,
+            ],
+          },
+        },
+        updateToInitialState: true,
+      });
+
+      controller.setTransactionActive(transactionId, true);
+
+      const transaction = controller.state.transactions[0];
+
+      expect(transaction?.isActive).toBe(true);
+    });
+  });
 });

packages/transaction-controller/src/TransactionController.ts

@@ -65,6 +65,12 @@ import { IncomingTransactionHelper } from './helpers/IncomingTransactionHelper';
 import { MethodDataHelper } from './helpers/MethodDataHelper';
 import { MultichainTrackingHelper } from './helpers/MultichainTrackingHelper';
 import { PendingTransactionTracker } from './helpers/PendingTransactionTracker';
+import type { ResimulateResponse } from './helpers/ResimulateHelper';
+import {
+  ResimulateHelper,
+  hasSimulationDataChanged,
+  shouldResimulate,
+} from './helpers/ResimulateHelper';
 import { projectLogger as log } from './logger';
 import type {
   DappSuggestedGasFees,
@@ -110,8 +116,6 @@ import {
   getNextNonce,
 } from './utils/nonce';
 import { prepareTransaction, serializeTransaction } from './utils/prepare';
-import type { ResimulateResponse } from './utils/resimulate';
-import { hasSimulationDataChanged, shouldResimulate } from './utils/resimulate';
 import { getTransactionParamsWithIncreasedGasFee } from './utils/retry';
 import { getSimulationData } from './utils/simulation';
 import {
@@ -926,6 +930,18 @@ export class TransactionController extends BaseController<
       this.#checkForPendingTransactionAndStartPolling,
     );
 
+    new ResimulateHelper({
+      simulateTransaction: this.#updateSimulationData.bind(this),
+      onTransactionsUpdate: (listener) => {
+        this.messagingSystem.subscribe(
+          'TransactionController:stateChange',
+          listener,
+          (controllerState) => controllerState.transactions,
+        );
+      },
+      getTransactions: () => this.state.transactions,
+    });
+
     this.onBootCleanup();
     this.#checkForPendingTransactionAndStartPolling();
   }
@@ -1862,6 +1878,33 @@ export class TransactionController extends BaseController<
     return this.getTransaction(txId);
   }
 
+  /**
+   * Update the isActive state of a transaction.
+   *
+   * @param transactionId - The ID of the transaction to update.
+   * @param isActive - The active state.
+   */
+  setTransactionActive(transactionId: string, isActive: boolean) {
+    const transactionMeta = this.getTransaction(transactionId);
+
+    if (!transactionMeta) {
+      throw new Error(`Transaction with id ${transactionId} not found`);
+    }
+
+    this.#updateTransactionInternal(
+      {
+        transactionId,
+        note: 'TransactionController#setTransactionActive - Transaction isActive updated',
+        skipHistory: true,
+        skipValidation: true,
+        skipResimulateCheck: true,
+      },
+      (updatedTransactionMeta) => {
+        updatedTransactionMeta.isActive = isActive;
+      },
+    );
+  }
+
   /**
    * Signs and returns the raw transaction data for provided transaction params list.
    *

packages/transaction-controller/src/utils/resimulate.test.ts → packages/transaction-controller/src/helpers/ResimulateHelper.test.ts

@@ -1,26 +1,27 @@
-/* eslint-disable @typescript-eslint/naming-convention */
 import { NetworkType } from '@metamask/controller-utils';
+import type { NetworkClientId } from '@metamask/network-controller';
 import { BN } from 'bn.js';
 
-import { CHAIN_IDS } from '../constants';
-import type {
-  SecurityAlertResponse,
-  SimulationData,
-  SimulationTokenBalanceChange,
-  TransactionMeta,
-} from '../types';
-import { SimulationTokenStandard, TransactionStatus } from '../types';
 import {
+  type ResimulateHelperOptions,
+  ResimulateHelper,
   BLOCK_TIME_ADDITIONAL_SECONDS,
   BLOCKAID_RESULT_TYPE_MALICIOUS,
   hasSimulationDataChanged,
   RESIMULATE_PARAMS,
   shouldResimulate,
   VALUE_COMPARISON_PERCENT_THRESHOLD,
-} from './resimulate';
-import { getPercentageChange } from './utils';
-
-jest.mock('./utils');
+  RESIMULATE_INTERVAL_MS,
+} from './ResimulateHelper';
+import { CHAIN_IDS } from '../constants';
+import type {
+  TransactionMeta,
+  SecurityAlertResponse,
+  SimulationData,
+  SimulationTokenBalanceChange,
+} from '../types';
+import { TransactionStatus, SimulationTokenStandard } from '../types';
+import { getPercentageChange } from '../utils/utils';
 
 const CURRENT_TIME_MOCK = 1234567890;
 const CURRENT_TIME_SECONDS_MOCK = 1234567;
@@ -74,6 +75,139 @@ const TRANSACTION_META_MOCK: TransactionMeta = {
   },
 };
 
+const mockTransactionMeta = {
+  id: '1',
+  networkClientId: 'network1' as NetworkClientId,
+  isActive: true,
+  status: TransactionStatus.unapproved,
+} as TransactionMeta;
+
+jest.mock('../utils/utils');
+
+describe('ResimulateHelper', () => {
+  let getTransactionsMock: jest.Mock<() => TransactionMeta[]>;
+  let simulateTransactionMock: jest.Mock<
+    (transactionMeta: TransactionMeta) => Promise<void>
+  >;
+  let onTransactionsUpdateMock: jest.Mock<(listener: () => void) => void>;
+
+  /**
+   * Triggers onStateChange callback
+   */
+  function triggerStateChange() {
+    onTransactionsUpdateMock.mock.calls[0][0]();
+  }
+
+  /**
+   * Mocks getTransactions to return given transactions argument
+   *
+   * @param transactions - Transactions to be returned
+   */
+  function mockGetTransactionsOnce(transactions: TransactionMeta[]) {
+    getTransactionsMock.mockReturnValueOnce(
+      transactions as unknown as ResimulateHelperOptions['getTransactions'],
+    );
+  }
+
+  beforeEach(() => {
+    jest.useFakeTimers();
+    getTransactionsMock = jest.fn();
+    onTransactionsUpdateMock = jest.fn();
+    simulateTransactionMock = jest.fn().mockResolvedValue(undefined);
+
+    new ResimulateHelper({
+      getTransactions: getTransactionsMock,
+      onTransactionsUpdate: onTransactionsUpdateMock,
+      simulateTransaction: simulateTransactionMock,
+    } as unknown as ResimulateHelperOptions);
+  });
+
+  afterEach(() => {
+    jest.clearAllTimers();
+  });
+
+  it(`resimulates unapproved active transaction every ${RESIMULATE_INTERVAL_MS} milliseconds`, async () => {
+    mockGetTransactionsOnce([mockTransactionMeta]);
+    triggerStateChange();
+
+    jest.advanceTimersByTime(RESIMULATE_INTERVAL_MS);
+    await Promise.resolve();
+
+    jest.advanceTimersByTime(RESIMULATE_INTERVAL_MS);
+    await Promise.resolve();
+
+    jest.runAllTimers();
+
+    expect(simulateTransactionMock).toHaveBeenCalledWith(mockTransactionMeta);
+    expect(simulateTransactionMock).toHaveBeenCalledTimes(2);
+  });
+
+  it(`does not resimulate twice the same transaction even if state change is triggered twice`, async () => {
+    mockGetTransactionsOnce([mockTransactionMeta]);
+    triggerStateChange();
+
+    // Halfway through the interval
+    jest.advanceTimersByTime(RESIMULATE_INTERVAL_MS / 2);
+
+    // Assume state change is triggered again
+    mockGetTransactionsOnce([mockTransactionMeta]);
+    triggerStateChange();
+
+    // Halfway through the interval
+    jest.advanceTimersByTime(RESIMULATE_INTERVAL_MS / 2);
+
+    expect(simulateTransactionMock).toHaveBeenCalledTimes(1);
+  });
+
+  it('does not resimulate a transaction that is no longer active', () => {
+    mockGetTransactionsOnce([mockTransactionMeta]);
+    triggerStateChange();
+
+    // Halfway through the interval
+    jest.advanceTimersByTime(RESIMULATE_INTERVAL_MS / 2);
+
+    const inactiveTransactionMeta = {
+      ...mockTransactionMeta,
+      isActive: false,
+    } as TransactionMeta;
+
+    mockGetTransactionsOnce([inactiveTransactionMeta]);
+    triggerStateChange();
+
+    jest.advanceTimersByTime(RESIMULATE_INTERVAL_MS / 2);
+
+    expect(simulateTransactionMock).toHaveBeenCalledTimes(0);
+  });
+
+  it('does not resimulate a transaction that is not active', () => {
+    const inactiveTransactionMeta = {
+      ...mockTransactionMeta,
+      isActive: false,
+    } as TransactionMeta;
+
+    mockGetTransactionsOnce([inactiveTransactionMeta]);
+    triggerStateChange();
+
+    jest.advanceTimersByTime(2 * RESIMULATE_INTERVAL_MS);
+
+    expect(simulateTransactionMock).toHaveBeenCalledTimes(0);
+  });
+
+  it('stops resimulating a transaction that is no longer in the transaction list', () => {
+    mockGetTransactionsOnce([mockTransactionMeta]);
+    triggerStateChange();
+
+    jest.advanceTimersByTime(RESIMULATE_INTERVAL_MS);
+
+    mockGetTransactionsOnce([]);
+    triggerStateChange();
+
+    jest.advanceTimersByTime(RESIMULATE_INTERVAL_MS);
+
+    expect(simulateTransactionMock).toHaveBeenCalledTimes(1);
+  });
+});
+
 describe('Resimulate Utils', () => {
   const getPercentageChangeMock = jest.mocked(getPercentageChange);