@aztec/ethereum 3.0.0-nightly.20251003 → 3.0.0-nightly.20251004

package/src/l1_tx_utils/l1_tx_utils.ts

@@ -1,9 +1,9 @@
 import { maxBigint } from '@aztec/foundation/bigint';
-import { times } from '@aztec/foundation/collection';
-import { TimeoutError } from '@aztec/foundation/error';
+import { merge, pick } from '@aztec/foundation/collection';
+import { InterruptError, TimeoutError } from '@aztec/foundation/error';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { type Logger, createLogger } from '@aztec/foundation/log';
-import { makeBackoff, retry } from '@aztec/foundation/retry';
+import { retryUntil } from '@aztec/foundation/retry';
 import { sleep } from '@aztec/foundation/sleep';
 import { DateProvider } from '@aztec/foundation/timer';
 import { RollupAbi } from '@aztec/l1-artifacts/RollupAbi';
@@ -12,7 +12,6 @@ import pickBy from 'lodash.pickby';
 import {
   type Abi,
   type BlockOverrides,
-  type GetTransactionReturnType,
   type Hex,
   type NonceManager,
   type PrepareTransactionRequestRequest,
@@ -31,12 +30,15 @@ import { type L1TxUtilsConfig, l1TxUtilsConfigMappings } from './config.js';
 import { LARGE_GAS_LIMIT } from './constants.js';
 import { ReadOnlyL1TxUtils } from './readonly_l1_tx_utils.js';
 import {
+  DroppedTransactionError,
   type L1BlobInputs,
-  type L1GasConfig,
+  type L1TxConfig,
   type L1TxRequest,
   type L1TxState,
   type SigningCallback,
+  TerminalTxUtilsState,
   TxUtilsState,
+  UnknownMinedTxError,
 } from './types.js';
 
 const MAX_L1_TX_STATES = 32;
@@ -72,12 +74,12 @@ export class L1TxUtils extends ReadOnlyL1TxUtils {
     l1TxState.status = newState;
     const sender = this.getSenderAddress().toString();
     this.logger.debug(
-      `State changed from ${TxUtilsState[oldState]} to ${TxUtilsState[newState]} for nonce ${l1TxState.nonce} account ${sender}`,
+      `Tx state changed from ${TxUtilsState[oldState]} to ${TxUtilsState[newState]} for nonce ${l1TxState.nonce} account ${sender}`,
     );
   }
 
   public updateConfig(newConfig: Partial<L1TxUtilsConfig>) {
-    this.config = { ...this.config, ...newConfig };
+    this.config = merge(this.config, newConfig);
     this.logger.info(
       'Updated L1TxUtils config',
       pickBy(newConfig, (_, key) => key in l1TxUtilsConfigMappings),
@@ -112,12 +114,16 @@ export class L1TxUtils extends ReadOnlyL1TxUtils {
    */
   public async sendTransaction(
     request: L1TxRequest,
-    gasConfigOverrides?: L1GasConfig,
+    gasConfigOverrides?: L1TxConfig,
     blobInputs?: L1BlobInputs,
     stateChange: TxUtilsState = TxUtilsState.SENT,
   ): Promise<{ txHash: Hex; state: L1TxState }> {
+    if (this.interrupted) {
+      throw new InterruptError(`Transaction sending is interrupted`);
+    }
+
     try {
-      const gasConfig = { ...this.config, ...gasConfigOverrides };
+      const gasConfig = merge(this.config, gasConfigOverrides);
       const account = this.getSenderAddress().toString();
 
       let gasLimit: bigint;
@@ -128,34 +134,16 @@ export class L1TxUtils extends ReadOnlyL1TxUtils {
       } else {
         gasLimit = await this.estimateGas(account, request, gasConfig);
       }
-      this.logger?.debug(`Gas limit for request is ${gasLimit}`, { gasLimit, ...request });
+      this.logger.trace(`Computed gas limit ${gasLimit}`, { gasLimit, ...request });
 
       const gasPrice = await this.getGasPrice(gasConfig, !!blobInputs);
 
-      if (gasConfig.txTimeoutAt && this.dateProvider.now() > gasConfig.txTimeoutAt.getTime()) {
-        throw new Error('Transaction timed out before sending');
-      }
-
       const nonce = await this.nonceManager.consume({
         client: this.client,
         address: account,
         chainId: this.client.chain.id,
       });
 
-      const l1TxState: L1TxState = {
-        txHashes: [],
-        cancelTxHashes: [],
-        gasPrice,
-        request,
-        status: TxUtilsState.IDLE,
-        nonce,
-        gasLimit,
-        txConfig: gasConfig,
-        blobInputs,
-      };
-
-      this.updateState(l1TxState, stateChange);
-
       const baseTxData = {
         ...request,
         gas: gasLimit,
@@ -168,29 +156,60 @@ export class L1TxUtils extends ReadOnlyL1TxUtils {
         ? { ...baseTxData, ...blobInputs, maxFeePerBlobGas: gasPrice.maxFeePerBlobGas! }
         : baseTxData;
 
+      const now = new Date(await this.getL1Timestamp());
+      if (gasConfig.txTimeoutAt && now > gasConfig.txTimeoutAt) {
+        throw new TimeoutError(
+          `Transaction timed out before sending (now ${now.toISOString()} > timeoutAt ${gasConfig.txTimeoutAt.toISOString()})`,
+        );
+      }
+
+      if (this.interrupted) {
+        throw new InterruptError(`Transaction sending is interrupted`);
+      }
+
       const signedRequest = await this.prepareSignedTransaction(txData);
       const txHash = await this.client.sendRawTransaction({ serializedTransaction: signedRequest });
 
-      l1TxState.txHashes.push(txHash);
+      const l1TxState: L1TxState = {
+        txHashes: [txHash],
+        cancelTxHashes: [],
+        gasPrice,
+        request,
+        status: TxUtilsState.IDLE,
+        nonce,
+        gasLimit,
+        txConfigOverrides: gasConfigOverrides ?? {},
+        blobInputs,
+        sentAtL1Ts: now,
+        lastSentAtL1Ts: now,
+      };
+
+      this.updateState(l1TxState, stateChange);
+
       this.txs.push(l1TxState);
       if (this.txs.length > MAX_L1_TX_STATES) {
         this.txs.shift();
       }
 
-      const cleanGasConfig = pickBy(gasConfig, (_, key) => key in l1TxUtilsConfigMappings);
-      this.logger?.info(`Sent L1 transaction ${txHash}`, {
+      this.logger.info(`Sent L1 transaction ${txHash}`, {
+        to: request.to,
+        value: request.value,
+        nonce,
+        account,
+        sentAt: now,
         gasLimit,
         maxFeePerGas: formatGwei(gasPrice.maxFeePerGas),
         maxPriorityFeePerGas: formatGwei(gasPrice.maxPriorityFeePerGas),
-        gasConfig: cleanGasConfig,
         ...(gasPrice.maxFeePerBlobGas && { maxFeePerBlobGas: formatGwei(gasPrice.maxFeePerBlobGas) }),
+        isBlobTx: !!blobInputs,
+        txConfig: gasConfigOverrides,
       });
 
       return { txHash, state: l1TxState };
     } catch (err: any) {
       const viemError = formatViemError(err, request.abi);
-      this.logger?.error(`Failed to send L1 transaction`, viemError.message, {
-        metaMessages: viemError.metaMessages,
+      this.logger.error(`Failed to send L1 transaction`, viemError, {
+        request: pick(request, 'to', 'value'),
       });
       throw viemError;
     }
@@ -205,11 +224,12 @@ export class L1TxUtils extends ReadOnlyL1TxUtils {
       try {
         const receipt = await this.client.getTransactionReceipt({ hash });
         if (receipt) {
+          const account = this.getSenderAddress().toString();
           const what = isCancelTx ? 'Cancellation L1 transaction' : 'L1 transaction';
           if (receipt.status === 'reverted') {
-            this.logger?.warn(`${what} ${hash} with nonce ${nonce} reverted`, receipt);
+            this.logger.warn(`${what} ${hash} with nonce ${nonce} reverted`, { receipt, nonce, account });
           } else {
-            this.logger?.verbose(`${what} ${hash} with nonce ${nonce} mined`, receipt);
+            this.logger.info(`${what} ${hash} with nonce ${nonce} mined`, { receipt, nonce, account });
           }
           return receipt;
         }
@@ -224,50 +244,89 @@ export class L1TxUtils extends ReadOnlyL1TxUtils {
     }
   }
 
+  /**
+   * Returns whether a given tx should be considered as timed out and no longer monitored.
+   * Relies on the txTimeout setting for user txs, and on the txCancellationTimeout for cancel txs.
+   * @remarks We check against the latestBlockTimestamp as opposed to the current time to avoid a race condition where
+   * the tx is mined in a block with the same timestamp as txTimeoutAt, but our execution node has not yet processed it,
+   * or the loop here has not yet checked the tx before that timeout.
+   */
+  private isTxTimedOut(state: L1TxState, l1Timestamp: number) {
+    const account = this.getSenderAddress().toString();
+    const { nonce } = state;
+
+    const txConfig = merge(this.config, state.txConfigOverrides);
+    const { txTimeoutAt, txTimeoutMs, maxSpeedUpAttempts } = txConfig;
+    const isCancelTx = state.cancelTxHashes.length > 0;
+
+    this.logger.trace(`Tx timeout check for ${account} with nonce ${nonce}`, {
+      nonce,
+      account,
+      l1Timestamp,
+      lastAttemptSent: state.lastSentAtL1Ts.getTime(),
+      initialTxTime: state.sentAtL1Ts.getTime(),
+      now: this.dateProvider.now(),
+      txTimeoutAt,
+      txTimeoutMs,
+      interrupted: this.interrupted,
+    });
+
+    if (this.interrupted) {
+      this.logger.warn(`Tx monitoring interrupted during nonce ${nonce} for ${account} check`, { nonce, account });
+      return true;
+    }
+
+    if (isCancelTx) {
+      // Note that we check against the lastSentAt time for cancellations, since we time them out
+      // after the last attempt to submit them, not the initial time.
+      const attempts = state.cancelTxHashes.length;
+      return (
+        attempts > maxSpeedUpAttempts &&
+        state.lastSentAtL1Ts.getTime() + txConfig.txCancellationFinalTimeoutMs! <= l1Timestamp
+      );
+    }
+
+    return (
+      (txTimeoutAt !== undefined && l1Timestamp >= txTimeoutAt.getTime()) ||
+      (txTimeoutMs !== undefined && txTimeoutMs > 0 && l1Timestamp - state.sentAtL1Ts.getTime() >= txTimeoutMs)
+    );
+  }
+
   /**
    * Monitors a transaction until completion, handling speed-ups if needed
    */
   protected async monitorTransaction(state: L1TxState): Promise<TransactionReceipt> {
-    const { request, nonce, txHashes, cancelTxHashes, gasLimit, blobInputs, txConfig: gasConfig } = state;
-    const isCancelTx = cancelTxHashes.length > 0;
+    const { request, nonce, gasLimit, blobInputs, txConfigOverrides: gasConfigOverrides } = state;
+    const gasConfig = merge(this.config, gasConfigOverrides);
+    const { maxSpeedUpAttempts, stallTimeMs } = gasConfig;
+    const isCancelTx = state.cancelTxHashes.length > 0;
+    const txHashes = isCancelTx ? state.cancelTxHashes : state.txHashes;
     const isBlobTx = !!blobInputs;
     const account = this.getSenderAddress().toString();
 
-    const makeGetTransactionBackoff = () =>
-      makeBackoff(times(gasConfig.txPropagationMaxQueryAttempts ?? 3, i => i + 1));
-
-    let currentTxHash = isCancelTx ? cancelTxHashes[0] : txHashes[0];
-    let attempts = 0;
-    let lastAttemptSent = this.dateProvider.now();
-
-    const initialTxTime = lastAttemptSent;
-    let txTimedOut = false;
-    let latestBlockTimestamp: bigint | undefined;
-
-    // We check against the latestBlockTimestamp as opposed to the current time to avoid a race condition where
-    // the tx is mined in a block with the same timestamp as txTimeoutAt, but our execution node has not yet processed it,
-    // or the loop here has not yet checked the tx before that timeout.
-    const isTimedOut = () =>
-      (gasConfig.txTimeoutAt &&
-        latestBlockTimestamp !== undefined &&
-        Number(latestBlockTimestamp) * 1000 >= gasConfig.txTimeoutAt.getTime()) ||
-      (gasConfig.txTimeoutMs !== undefined && this.dateProvider.now() - initialTxTime > gasConfig.txTimeoutMs) ||
-      this.interrupted ||
-      false;
-
-    while (!txTimedOut) {
+    const initialTxHash = txHashes[0];
+    let currentTxHash = initialTxHash;
+    let l1Timestamp: number;
+
+    while (true) {
+      l1Timestamp = await this.getL1Timestamp();
+
       try {
-        ({ timestamp: latestBlockTimestamp } = await this.client.getBlock({
-          blockTag: 'latest',
-          includeTransactions: false,
-        }));
+        const timePassed = l1Timestamp - state.lastSentAtL1Ts.getTime();
+        const [currentNonce, pendingNonce] = await Promise.all([
+          this.client.getTransactionCount({ address: account, blockTag: 'latest' }),
+          this.client.getTransactionCount({ address: account, blockTag: 'pending' }),
+        ]);
 
-        const currentNonce = await this.client.getTransactionCount({ address: account });
         // If the current nonce on our account is greater than our transaction's nonce then a tx with the same nonce has been mined.
         if (currentNonce > nonce) {
+          // We try getting the receipt twice, since sometimes anvil fails to return it if the tx has just been mined
           const receipt =
-            (await this.tryGetTxReceipt(cancelTxHashes, nonce, true)) ??
-            (await this.tryGetTxReceipt(txHashes, nonce, false));
+            (await this.tryGetTxReceipt(state.cancelTxHashes, nonce, true)) ??
+            (await this.tryGetTxReceipt(state.txHashes, nonce, false)) ??
+            (await sleep(500)) ??
+            (await this.tryGetTxReceipt(state.cancelTxHashes, nonce, true)) ??
+            (await this.tryGetTxReceipt(state.txHashes, nonce, false));
 
           if (receipt) {
             this.updateState(state, TxUtilsState.MINED);
@@ -278,62 +337,39 @@ export class L1TxUtils extends ReadOnlyL1TxUtils {
           // If we get here then we have checked all of our tx versions and not found anything.
           // We should consider the nonce as MINED
           this.updateState(state, TxUtilsState.MINED);
-          throw new Error(`Nonce ${nonce} is MINED but not by one of our expected transactions`);
+          throw new UnknownMinedTxError(nonce, account);
         }
 
-        this.logger?.trace(`Tx timeout check for ${currentTxHash}: ${isTimedOut()}`, {
-          latestBlockTimestamp: Number(latestBlockTimestamp) * 1000,
-          lastAttemptSent,
-          initialTxTime,
-          now: this.dateProvider.now(),
-          txTimeoutAt: gasConfig.txTimeoutAt?.getTime(),
-          txTimeoutMs: gasConfig.txTimeoutMs,
-          txStallTime: gasConfig.stallTimeMs,
-        });
-
-        // Retry a few times, in case the tx is not yet propagated.
-        const tx = await retry<GetTransactionReturnType>(
-          () => this.client.getTransaction({ hash: currentTxHash }),
-          `Getting L1 transaction ${currentTxHash}`,
-          makeGetTransactionBackoff(),
-          this.logger,
-          true,
-        );
-        const timePassed = this.dateProvider.now() - lastAttemptSent;
-
-        if (tx && timePassed < gasConfig.stallTimeMs!) {
-          this.logger?.debug(`L1 transaction ${currentTxHash} pending. Time passed: ${timePassed}ms.`);
-
-          // Check timeout before continuing
-          txTimedOut = isTimedOut();
-          if (txTimedOut) {
-            break;
-          }
+        // If this is a cancel tx and its nonce is no longer on the mempool, we consider it dropped and stop monitoring
+        // If it is a regular tx, we let the loop speed it up after the stall time
+        if (isCancelTx && pendingNonce <= nonce && timePassed >= gasConfig.txUnseenConsideredDroppedMs) {
+          this.logger.warn(
+            `Cancellation tx with nonce ${nonce} for account ${account} has been dropped from the visible mempool`,
+            { nonce, account, pendingNonce, timePassed },
+          );
+          this.updateState(state, TxUtilsState.NOT_MINED);
+          this.nonceManager.reset({ address: account, chainId: this.client.chain.id });
+          throw new DroppedTransactionError(nonce, account);
+        }
 
-          await sleep(gasConfig.checkIntervalMs!);
-          continue;
+        // Break if the tx has timed out (ie expired)
+        if (this.isTxTimedOut(state, l1Timestamp)) {
+          break;
         }
 
-        if (timePassed > gasConfig.stallTimeMs! && attempts < gasConfig.maxAttempts!) {
-          attempts++;
-          const newGasPrice = await this.getGasPrice(
-            gasConfig,
-            isBlobTx,
-            attempts,
-            tx.maxFeePerGas && tx.maxPriorityFeePerGas
-              ? {
-                  maxFeePerGas: tx.maxFeePerGas,
-                  maxPriorityFeePerGas: tx.maxPriorityFeePerGas,
-                  maxFeePerBlobGas: tx.maxFeePerBlobGas,
-                }
-              : undefined,
-          );
+        // Speed up the transaction if it appears to be stuck (exceeded stall time and still have retry attempts)
+        const attempts = txHashes.length;
+        if (timePassed >= stallTimeMs && attempts <= maxSpeedUpAttempts) {
+          const newGasPrice = await this.getGasPrice(gasConfig, isBlobTx, attempts, state.gasPrice);
           state.gasPrice = newGasPrice;
 
-          this.logger?.debug(
-            `L1 transaction ${currentTxHash} appears stuck. Attempting speed-up ${attempts}/${gasConfig.maxAttempts} ` +
-              `with new priority fee ${formatGwei(newGasPrice.maxPriorityFeePerGas)} gwei`,
+          this.logger.debug(
+            `Tx ${currentTxHash} with nonce ${nonce} from ${account} appears stuck. ` +
+              `Attempting speed-up ${attempts}/${maxSpeedUpAttempts} ` +
+              `with new priority fee ${formatGwei(newGasPrice.maxPriorityFeePerGas)} gwei.`,
             {
+              account,
+              nonce,
               maxFeePerGas: formatGwei(newGasPrice.maxFeePerGas),
               maxPriorityFeePerGas: formatGwei(newGasPrice.maxPriorityFeePerGas),
               ...(newGasPrice.maxFeePerBlobGas && { maxFeePerBlobGas: formatGwei(newGasPrice.maxFeePerBlobGas) }),
@@ -359,58 +395,109 @@ export class L1TxUtils extends ReadOnlyL1TxUtils {
             this.updateState(state, TxUtilsState.SPEED_UP);
           }
 
-          const cleanGasConfig = pickBy(gasConfig, (_, key) => key in l1TxUtilsConfigMappings);
-          this.logger?.verbose(`Sent L1 speed-up tx ${newHash}, replacing ${currentTxHash}`, {
-            gasLimit,
-            maxFeePerGas: formatGwei(newGasPrice.maxFeePerGas),
-            maxPriorityFeePerGas: formatGwei(newGasPrice.maxPriorityFeePerGas),
-            gasConfig: cleanGasConfig,
-            ...(newGasPrice.maxFeePerBlobGas && { maxFeePerBlobGas: formatGwei(newGasPrice.maxFeePerBlobGas) }),
-          });
+          this.logger.verbose(
+            `Sent L1 speed-up tx ${newHash} replacing ${currentTxHash} for nonce ${nonce} from ${account}`,
+            {
+              nonce,
+              account,
+              gasLimit,
+              maxFeePerGas: formatGwei(newGasPrice.maxFeePerGas),
+              maxPriorityFeePerGas: formatGwei(newGasPrice.maxPriorityFeePerGas),
+              txConfig: state.txConfigOverrides,
+              ...(newGasPrice.maxFeePerBlobGas && { maxFeePerBlobGas: formatGwei(newGasPrice.maxFeePerBlobGas) }),
+            },
+          );
 
           currentTxHash = newHash;
-
-          (isCancelTx ? cancelTxHashes : txHashes).push(currentTxHash);
-          lastAttemptSent = this.dateProvider.now();
+          txHashes.push(currentTxHash);
+          state.lastSentAtL1Ts = new Date(l1Timestamp);
+          await sleep(gasConfig.checkIntervalMs!);
+          continue;
         }
+
+        this.logger.debug(
+          `Tx ${currentTxHash} from ${account} with nonce ${nonce} still pending after ${timePassed}ms`,
+          {
+            account,
+            nonce,
+            pendingNonce,
+            attempts,
+            timePassed,
+            isBlobTx,
+            isCancelTx,
+            ...pick(state.gasPrice, 'maxFeePerGas', 'maxPriorityFeePerGas', 'maxFeePerBlobGas'),
+            ...pick(
+              gasConfig,
+              'txUnseenConsideredDroppedMs',
+              'txCancellationFinalTimeoutMs',
+              'maxSpeedUpAttempts',
+              'stallTimeMs',
+              'txTimeoutAt',
+              'txTimeoutMs',
+            ),
+          },
+        );
+
         await sleep(gasConfig.checkIntervalMs!);
       } catch (err: any) {
-        const viemError = formatViemError(err);
-        this.logger?.warn(`Error monitoring L1 transaction ${currentTxHash}:`, viemError.message);
-        if (viemError.message?.includes('reverted')) {
-          throw viemError;
+        if (err instanceof DroppedTransactionError || err instanceof UnknownMinedTxError) {
+          throw err;
         }
+
+        const viemError = formatViemError(err);
+        this.logger.error(`Error while monitoring L1 tx ${currentTxHash}`, viemError, { nonce, account });
         await sleep(gasConfig.checkIntervalMs!);
       }
-      // Check if tx has timed out.
-      txTimedOut = isTimedOut();
     }
 
-    // The transaction has timed out. If it's a cancellation then we are giving up on it.
-    // Otherwise we may attempt to cancel it if configured to do so.
-    if (isCancelTx) {
+    // Oh no, the transaction has timed out!
+    if (isCancelTx || !gasConfig.cancelTxOnTimeout) {
+      // If this was already a cancellation tx, or we are configured to not cancel txs, we just mark it as NOT_MINED
+      // and reset the nonce manager, so the next tx that comes along can reuse the nonce if/when this tx gets dropped.
+      // This is the nastiest scenario for us, since the new tx could acquire the next nonce, but then this tx is dropped,
+      // and the new tx would never get mined. Eventually, the new tx would also drop.
       this.updateState(state, TxUtilsState.NOT_MINED);
-    } else if (gasConfig.cancelTxOnTimeout) {
-      // Fire cancellation without awaiting to avoid blocking the main thread
-      this.attemptTxCancellation(state, attempts).catch(err => {
-        const viemError = formatViemError(err);
-        this.logger?.error(`Failed to send cancellation for timed out tx ${currentTxHash}:`, viemError.message, {
-          metaMessages: viemError.metaMessages,
+      this.nonceManager.reset({ address: account, chainId: this.client.chain.id });
+    } else {
+      // Otherwise we fire the cancellation without awaiting to avoid blocking the caller,
+      // and monitor it in the background so we can speed it up as needed.
+      void this.attemptTxCancellation(state).catch(err => {
+        this.updateState(state, TxUtilsState.NOT_MINED);
+        this.logger.error(`Failed to send cancellation for timed out tx ${initialTxHash} with nonce ${nonce}`, err, {
+          account,
+          nonce,
+          initialTxHash,
         });
       });
     }
 
-    this.logger?.warn(`L1 transaction ${currentTxHash} timed out`, {
-      txHash: currentTxHash,
-      txTimeoutAt: gasConfig.txTimeoutAt,
+    const what = isCancelTx ? 'Cancellation L1' : 'L1';
+    this.logger.warn(`${what} transaction ${initialTxHash} with nonce ${nonce} from ${account} timed out`, {
+      initialTxHash,
+      currentTxHash,
+      nonce,
+      account,
+      txTimeoutAt: gasConfig.txTimeoutAt?.getTime(),
       txTimeoutMs: gasConfig.txTimeoutMs,
-      txInitialTime: initialTxTime,
+      txInitialTime: state.sentAtL1Ts.getTime(),
+      l1Timestamp,
       now: this.dateProvider.now(),
-      attempts,
+      attempts: txHashes.length - 1,
       isInterrupted: this.interrupted,
     });
 
-    throw new TimeoutError(`L1 transaction ${currentTxHash} timed out`);
+    throw new TimeoutError(`L1 transaction ${initialTxHash} timed out`);
+  }
+
+  /** Returns when all monitor loops have stopped. */
+  public async waitMonitoringStopped(timeoutSeconds = 10) {
+    const account = this.getSenderAddress().toString();
+    await retryUntil(
+      () => this.txs.every(tx => TerminalTxUtilsState.includes(tx.status)),
+      `monitoring stopped for ${account}`,
+      timeoutSeconds,
+      0.1,
+    ).catch(() => this.logger.warn(`Timeout waiting for monitoring loops to stop for ${account}`));
   }
 
   /**
@@ -421,7 +508,7 @@ export class L1TxUtils extends ReadOnlyL1TxUtils {
    */
   public async sendAndMonitorTransaction(
     request: L1TxRequest,
-    gasConfig?: L1GasConfig,
+    gasConfig?: L1TxConfig,
     blobInputs?: L1BlobInputs,
   ): Promise<{ receipt: TransactionReceipt; state: L1TxState }> {
     const { state } = await this.sendTransaction(request, gasConfig, blobInputs);
@@ -437,7 +524,7 @@ export class L1TxUtils extends ReadOnlyL1TxUtils {
     _gasConfig?: L1TxUtilsConfig & { fallbackGasEstimate?: bigint; ignoreBlockGasLimit?: boolean },
   ): Promise<{ gasUsed: bigint; result: `0x${string}` }> {
     const blockOverrides = { ..._blockOverrides };
-    const gasConfig = { ...this.config, ..._gasConfig };
+    const gasConfig = merge(this.config, _gasConfig);
     const gasPrice = await this.getGasPrice(gasConfig, false);
 
     const call: any = {
@@ -459,11 +546,36 @@ export class L1TxUtils extends ReadOnlyL1TxUtils {
 
   /**
    * Attempts to cancel a transaction by sending a 0-value tx to self with same nonce but higher gas prices
+   * Only sends the cancellation if the original tx is still pending, not if it was dropped
    * @returns The hash of the cancellation transaction
    */
-  protected async attemptTxCancellation(state: L1TxState, attempts: number) {
+  protected async attemptTxCancellation(state: L1TxState) {
     const isBlobTx = state.blobInputs !== undefined;
     const { nonce, gasPrice: previousGasPrice } = state;
+    const account = this.getSenderAddress().toString();
+
+    // Do not send cancellation if interrupted
+    if (this.interrupted) {
+      this.logger.warn(
+        `Not sending cancellation for L1 tx from account ${account} with nonce ${nonce} as interrupted`,
+        { nonce, account },
+      );
+      this.updateState(state, TxUtilsState.NOT_MINED);
+      this.nonceManager.reset({ address: account, chainId: this.client.chain.id });
+      return;
+    }
+
+    // Check if the original tx is still pending
+    const currentNonce = await this.client.getTransactionCount({ address: account, blockTag: 'pending' });
+    if (currentNonce < nonce) {
+      this.logger.verbose(
+        `Not sending cancellation for L1 tx from account ${account} with nonce ${nonce} as it is dropped`,
+        { nonce, account, currentNonce },
+      );
+      this.updateState(state, TxUtilsState.NOT_MINED);
+      this.nonceManager.reset({ address: account, chainId: this.client.chain.id });
+      return;
+    }
 
     // Get gas price with higher priority fee for cancellation
     const cancelGasPrice = await this.getGasPrice(
@@ -473,13 +585,13 @@ export class L1TxUtils extends ReadOnlyL1TxUtils {
         priorityFeeRetryBumpPercentage: 150, // 150% bump should be enough to replace any tx
       },
       isBlobTx,
-      attempts + 1,
+      state.txHashes.length,
       previousGasPrice,
     );
 
     const { maxFeePerGas, maxPriorityFeePerGas, maxFeePerBlobGas } = cancelGasPrice;
-    this.logger?.info(
-      `Attempting to cancel L1 ${isBlobTx ? 'blob' : 'vanilla'} transaction ${state.txHashes[0]} with nonce ${nonce}`,
+    this.logger.verbose(
+      `Attempting to cancel L1 ${isBlobTx ? 'blob' : 'vanilla'} transaction from account ${account} with nonce ${nonce} after time out`,
       {
         maxFeePerGas: formatGwei(maxFeePerGas),
         maxPriorityFeePerGas: formatGwei(maxPriorityFeePerGas),
@@ -508,18 +620,30 @@ export class L1TxUtils extends ReadOnlyL1TxUtils {
     state.gasPrice = cancelGasPrice;
     state.gasLimit = 21_000n;
     state.cancelTxHashes.push(cancelTxHash);
+    state.lastSentAtL1Ts = new Date(await this.getL1Timestamp());
 
     this.updateState(state, TxUtilsState.CANCELLED);
 
-    this.logger?.info(`Sent cancellation tx ${cancelTxHash} for timed out tx with nonce ${nonce}`, {
+    this.logger.warn(`Sent cancellation tx ${cancelTxHash} for timed out tx from ${account} with nonce ${nonce}`, {
       nonce,
-      txData,
+      txData: baseTxData,
       isBlobTx,
       txHashes: state.txHashes,
     });
 
-    const { transactionHash } = await this.monitorTransaction(state);
-    return transactionHash;
+    // Do not await the cancel tx to be mined
+    void this.monitorTransaction(state).catch(err => {
+      this.logger.error(`Failed to mine cancellation tx ${cancelTxHash} for nonce ${nonce} account ${account}`, err, {
+        nonce,
+        account,
+        cancelTxHash,
+      });
+    });
+  }
+
+  private async getL1Timestamp() {
+    const { timestamp } = await this.client.getBlock({ blockTag: 'latest', includeTransactions: false });
+    return Number(timestamp) * 1000;
   }
 
   /** Makes empty blob inputs for the cancellation tx. To be overridden in L1TxUtilsWithBlobs. */