Update implementation

Author: matthewwalsh0

packages/transaction-controller/src/helpers/PendingTransactionTracker.ts

@@ -15,7 +15,10 @@ import { createModuleLogger, projectLogger } from '../logger';
 import type { TransactionControllerMessenger } from '../TransactionController';
 import type { TransactionMeta, TransactionReceipt } from '../types';
 import { TransactionStatus, TransactionType } from '../types';
-import { getTimeoutAttempts } from '../utils/feature-flags';
+import {
+  getAcceleratedPollingParams,
+  getTimeoutAttempts,
+} from '../utils/feature-flags';
 
 /**
  * We wait this many blocks before emitting a 'transaction-dropped' event
@@ -88,6 +91,8 @@ export class PendingTransactionTracker {
 
   readonly #isResubmitEnabled: () => boolean;
 
+  readonly #lastSeenTimestampByHash: Map<string, number>;
+
   // TODO: Replace `any` with type
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   readonly #listener: any;
@@ -103,8 +108,6 @@ export class PendingTransactionTracker {
 
   #running: boolean;
 
-  readonly #timeoutCountByHash: Map<string, number>;
-
   readonly #transactionPoller: TransactionPoller;
 
   #transactionToForcePoll: TransactionMeta | undefined;
@@ -150,11 +153,11 @@ export class PendingTransactionTracker {
     this.#getNetworkClientId = getNetworkClientId;
     this.#getTransactions = getTransactions;
     this.#isResubmitEnabled = isResubmitEnabled ?? ((): boolean => true);
+    this.#lastSeenTimestampByHash = new Map();
     this.#listener = this.#onLatestBlock.bind(this);
     this.#messenger = messenger;
     this.#publishTransaction = publishTransaction;
     this.#running = false;
-    this.#timeoutCountByHash = new Map();
     this.#transactionToForcePoll = undefined;
 
     this.#transactionPoller = new TransactionPoller({
@@ -529,6 +532,7 @@ export class PendingTransactionTracker {
       chainId,
       hash,
       id: transactionId,
+      submittedTime,
       txParams: { nonce },
     } = txMeta;
 
@@ -564,36 +568,54 @@ export class PendingTransactionTracker {
       // Check if transaction exists on the network
       const transaction = await this.#getTransactionByHash(hash);
 
-      // If transaction exists, reset the counter
+      // If transaction exists, record the timestamp
       if (transaction !== null) {
+        const currentTimestamp = Date.now();
+
+        this.#log(
+          'Transaction found on network, recording timestamp',
+          transactionId,
+        );
+
+        this.#lastSeenTimestampByHash.set(hash, currentTimestamp);
+        return false;
+      }
+
+      const lastSeenTimestamp =
+        this.#lastSeenTimestampByHash.get(hash) ?? submittedTime;
+
+      if (!lastSeenTimestamp) {
         this.#log(
-          'Transaction found on network, resetting timeout counter',
+          'Transaction not yet seen on network and has no submitted time, skipping timeout check',
           transactionId,
         );
 
-        this.#timeoutCountByHash.delete(hash);
         return false;
       }
 
-      // Transaction doesn't exist, increment counter
-      let attempts = this.#timeoutCountByHash.get(hash);
+      const { blockTime } = getAcceleratedPollingParams(
+        chainId,
+        this.#messenger,
+      );
 
-      attempts ??= 0;
-      attempts += 1;
-      this.#timeoutCountByHash.set(hash, attempts);
+      const currentTimestamp = Date.now();
+      const durationSinceLastSeen = currentTimestamp - lastSeenTimestamp;
+      const timeoutDuration = blockTime * threshold;
 
-      this.#log('Incrementing timeout counter', {
+      this.#log('Checking timeout duration', {
         transactionId,
-        attempts,
+        durationSinceLastSeen,
+        timeoutDuration,
         threshold,
+        blockTime,
       });
 
-      if (attempts < threshold) {
+      if (durationSinceLastSeen < timeoutDuration) {
         return false;
       }
 
-      this.#log('Hit timeout threshold', transactionId);
-      this.#timeoutCountByHash.delete(hash);
+      this.#log('Hit timeout duration threshold', transactionId);
+      this.#lastSeenTimestampByHash.delete(hash);
 
       this.#failTransaction(
         txMeta,

packages/transaction-controller/src/utils/feature-flags.ts

@@ -9,6 +9,7 @@ import type { TransactionControllerMessenger } from '../TransactionController';
 const DEFAULT_BATCH_SIZE_LIMIT = 10;
 const DEFAULT_ACCELERATED_POLLING_COUNT_MAX = 10;
 const DEFAULT_ACCELERATED_POLLING_INTERVAL_MS = 3 * 1000;
+const DEFAULT_BLOCK_TIME = 12 * 1000;
 const DEFAULT_GAS_ESTIMATE_FALLBACK_BLOCK_PERCENT = 35;
 const DEFAULT_GAS_ESTIMATE_BUFFER = 1;
 const DEFAULT_INCOMING_TRANSACTIONS_POLLING_INTERVAL_MS = 1000 * 60 * 4; // 4 Minutes
@@ -116,6 +117,11 @@ export type TransactionControllerFeatureFlags = {
       /** Accelerated polling parameters on a per-chain basis. */
       perChainConfig?: {
         [chainId: Hex]: {
+          /**
+           * Block time in milliseconds.
+           */
+          blockTime?: number;
+
           /**
            * Maximum number of polling requests that can be made in a row, before
            * the normal polling resumes.
@@ -264,7 +270,7 @@ export function getBatchSizeLimit(
 export function getAcceleratedPollingParams(
   chainId: Hex,
   messenger: TransactionControllerMessenger,
-): { countMax: number; intervalMs: number } {
+): { blockTime: number; countMax: number; intervalMs: number } {
   const featureFlags = getFeatureFlags(messenger);
 
   const acceleratedPollingParams =
@@ -280,7 +286,11 @@ export function getAcceleratedPollingParams(
     acceleratedPollingParams?.defaultIntervalMs ??
     DEFAULT_ACCELERATED_POLLING_INTERVAL_MS;
 
-  return { countMax, intervalMs };
+  const blockTime =
+    acceleratedPollingParams?.perChainConfig?.[chainId]?.blockTime ??
+    DEFAULT_BLOCK_TIME;
+
+  return { blockTime, countMax, intervalMs };
 }
 
 /**