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

package/dest/l1_tx_utils/l1_tx_utils.js

@@ -1,8 +1,8 @@
 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 { 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';
@@ -13,7 +13,7 @@ import { formatViemError } from '../utils.js';
 import { l1TxUtilsConfigMappings } from './config.js';
 import { LARGE_GAS_LIMIT } from './constants.js';
 import { ReadOnlyL1TxUtils } from './readonly_l1_tx_utils.js';
-import { TxUtilsState } from './types.js';
+import { DroppedTransactionError, TerminalTxUtilsState, TxUtilsState, UnknownMinedTxError } from './types.js';
 const MAX_L1_TX_STATES = 32;
 export class L1TxUtils extends ReadOnlyL1TxUtils {
     client;
@@ -39,13 +39,10 @@ export class L1TxUtils extends ReadOnlyL1TxUtils {
         const oldState = l1TxState.status;
         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}`);
+        this.logger.debug(`Tx state changed from ${TxUtilsState[oldState]} to ${TxUtilsState[newState]} for nonce ${l1TxState.nonce} account ${sender}`);
     }
     updateConfig(newConfig) {
-        this.config = {
-            ...this.config,
-            ...newConfig
-        };
+        this.config = merge(this.config, newConfig);
         this.logger.info('Updated L1TxUtils config', pickBy(newConfig, (_, key)=>key in l1TxUtilsConfigMappings));
     }
     getSenderAddress() {
@@ -70,11 +67,11 @@ export class L1TxUtils extends ReadOnlyL1TxUtils {
    * @param gasConfig - Optional gas configuration
    * @returns The transaction hash and parameters used
    */ async sendTransaction(request, gasConfigOverrides, blobInputs, stateChange = TxUtilsState.SENT) {
+        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;
             if (this.debugMaxGasLimit) {
@@ -84,31 +81,16 @@ export class L1TxUtils extends ReadOnlyL1TxUtils {
             } else {
                 gasLimit = await this.estimateGas(account, request, gasConfig);
             }
-            this.logger?.debug(`Gas limit for request is ${gasLimit}`, {
+            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 = {
-                txHashes: [],
-                cancelTxHashes: [],
-                gasPrice,
-                request,
-                status: TxUtilsState.IDLE,
-                nonce,
-                gasLimit,
-                txConfig: gasConfig,
-                blobInputs
-            };
-            this.updateState(l1TxState, stateChange);
             const baseTxData = {
                 ...request,
                 gas: gasLimit,
@@ -121,24 +103,51 @@ export class L1TxUtils extends ReadOnlyL1TxUtils {
                 ...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 = {
+                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,
@@ -146,8 +155,8 @@ export class L1TxUtils extends ReadOnlyL1TxUtils {
             };
         } catch (err) {
             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;
         }
@@ -159,11 +168,20 @@ export class L1TxUtils extends ReadOnlyL1TxUtils {
                     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;
                 }
@@ -178,35 +196,74 @@ 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.
+   */ isTxTimedOut(state, l1Timestamp) {
+        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
    */ async monitorTransaction(state) {
-        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;
-        // 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;
+        while(true){
+            l1Timestamp = await this.getL1Timestamp();
             try {
-                ({ timestamp: latestBlockTimestamp } = await this.client.getBlock({
-                    blockTag: 'latest',
-                    includeTransactions: false
-                }));
-                const currentNonce = await this.client.getTransactionCount({
-                    address: account
-                });
+                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'
+                    })
+                ]);
                 // 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) {
-                    const receipt = await this.tryGetTxReceipt(cancelTxHashes, nonce, true) ?? await this.tryGetTxReceipt(txHashes, nonce, false);
+                    // 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(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);
                         state.receipt = receipt;
@@ -215,41 +272,36 @@ 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(()=>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;
-                    }
-                    await sleep(gasConfig.checkIntervalMs);
-                    continue;
+                // 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);
                 }
-                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);
+                // Break if the tx has timed out (ie expired)
+                if (this.isTxTimedOut(state, l1Timestamp)) {
+                    break;
+                }
+                // 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 && {
@@ -275,55 +327,89 @@ export class L1TxUtils extends ReadOnlyL1TxUtils {
                     if (!isCancelTx) {
                         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}`, {
+                    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),
-                        gasConfig: cleanGasConfig,
+                        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) {
-                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. */ 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}`));
     }
     /**
    * Sends a transaction and monitors it until completion
@@ -342,10 +428,7 @@ export class L1TxUtils extends ReadOnlyL1TxUtils {
         const blockOverrides = {
             ..._blockOverrides
         };
-        const gasConfig = {
-            ...this.config,
-            ..._gasConfig
-        };
+        const gasConfig = merge(this.config, _gasConfig);
         const gasPrice = await this.getGasPrice(gasConfig, false);
         const call = {
             to: request.to,
@@ -363,18 +446,51 @@ 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
-   */ async attemptTxCancellation(state, attempts) {
+   */ async attemptTxCancellation(state) {
         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({
             ...this.config,
             // Use high bump for cancellation to ensure it replaces the original tx
             priorityFeeRetryBumpPercentage: 150
-        }, isBlobTx, attempts + 1, previousGasPrice);
+        }, isBlobTx, 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),
             ...maxFeePerBlobGas && {
@@ -404,15 +520,29 @@ 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
+            });
+        });
+    }
+    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. */ makeEmptyBlobInputs(_maxFeePerBlobGas) {
         throw new Error('Cannot make empty blob inputs for cancellation');

package/dest/l1_tx_utils/readonly_l1_tx_utils.d.ts

@@ -9,7 +9,7 @@ export declare class ReadOnlyL1TxUtils {
     protected logger: Logger;
     readonly dateProvider: DateProvider;
     protected debugMaxGasLimit: boolean;
-    config: L1TxUtilsConfig;
+    config: Required<L1TxUtilsConfig>;
     protected interrupted: boolean;
     constructor(client: ViemClient, logger: Logger | undefined, dateProvider: DateProvider, config?: Partial<L1TxUtilsConfig>, debugMaxGasLimit?: boolean);
     interrupt(): void;
@@ -47,7 +47,7 @@ export declare class ReadOnlyL1TxUtils {
     /**
      * Gets the current gas price with bounds checking
      */
-    getGasPrice(_gasConfig?: L1TxUtilsConfig, isBlobTx?: boolean, attempt?: number, previousGasPrice?: typeof attempt extends 0 ? never : GasPrice): Promise<GasPrice>;
+    getGasPrice(gasConfigOverrides?: L1TxUtilsConfig, isBlobTx?: boolean, attempt?: number, previousGasPrice?: typeof attempt extends 0 ? never : GasPrice): Promise<GasPrice>;
     /**
      * Estimates gas and adds buffer
      */

package/dest/l1_tx_utils/readonly_l1_tx_utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"readonly_l1_tx_utils.d.ts","sourceRoot":"","sources":["../../src/l1_tx_utils/readonly_l1_tx_utils.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"readonly_l1_tx_utils.d.ts","sourceRoot":"","sources":["../../src/l1_tx_utils/readonly_l1_tx_utils.ts"],"names":[],"mappings":"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"}