@aztec/ethereum 3.0.0-nightly.20250929 → 3.0.0-nightly.20251001

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aztec/ethereum",
-  "version": "3.0.0-nightly.20250929",
+  "version": "3.0.0-nightly.20251001",
   "type": "module",
   "exports": {
     ".": "./dest/index.js",
@@ -31,10 +31,10 @@
     "../package.common.json"
   ],
   "dependencies": {
-    "@aztec/blob-lib": "3.0.0-nightly.20250929",
-    "@aztec/constants": "3.0.0-nightly.20250929",
-    "@aztec/foundation": "3.0.0-nightly.20250929",
-    "@aztec/l1-artifacts": "3.0.0-nightly.20250929",
+    "@aztec/blob-lib": "3.0.0-nightly.20251001",
+    "@aztec/constants": "3.0.0-nightly.20251001",
+    "@aztec/foundation": "3.0.0-nightly.20251001",
+    "@aztec/l1-artifacts": "3.0.0-nightly.20251001",
     "@viem/anvil": "^0.0.10",
     "dotenv": "^16.0.3",
     "lodash.chunk": "^4.2.0",

package/src/client.ts

@@ -19,7 +19,7 @@ import { createEthereumChain } from './chain.js';
 import type { ExtendedViemWalletClient, ViemPublicClient } from './types.js';
 
 type Config = {
-  /** The RPC Url of the ethereum host. */
+  /** List of URLs of Ethereum RPC nodes that services will connect to (comma separated). */
   l1RpcUrls: string[];
   /** The chain ID of the ethereum host. */
   l1ChainId: number;

package/src/config.ts

@@ -232,8 +232,8 @@ const TestnetEntryQueueConfig = {
 };
 
 const StagingIgnitionEntryQueueConfig = {
-  bootstrapValidatorSetSize: 24n,
-  bootstrapFlushSize: 24n,
+  bootstrapValidatorSetSize: 48n,
+  bootstrapFlushSize: 48n,
   normalFlushSizeMin: 1n,
   normalFlushSizeQuotient: 2048n,
   maxQueueFlushSize: 24n,

package/src/contracts/governance_proposer.ts

@@ -11,7 +11,7 @@ import {
   getContract,
 } from 'viem';
 
-import type { GasPrice, L1TxRequest, L1TxUtils } from '../l1_tx_utils/index.js';
+import type { L1TxRequest, L1TxUtils } from '../l1_tx_utils/index.js';
 import type { ViemClient } from '../types.js';
 import { type IEmpireBase, encodeSignal, encodeSignalWithSignature, signSignalWithSig } from './empire_base.js';
 import { extractProposalIdFromLogs } from './governance.js';
@@ -102,10 +102,9 @@ export class GovernanceProposerContract implements IEmpireBase {
     l1TxUtils: L1TxUtils,
   ): Promise<{
     receipt: TransactionReceipt;
-    gasPrice: GasPrice;
     proposalId: bigint;
   }> {
-    const { receipt, gasPrice } = await l1TxUtils.sendAndMonitorTransaction({
+    const { receipt } = await l1TxUtils.sendAndMonitorTransaction({
       to: this.address.toString(),
       data: encodeFunctionData({
         abi: this.proposer.abi,
@@ -114,6 +113,6 @@ export class GovernanceProposerContract implements IEmpireBase {
       }),
     });
     const proposalId = extractProposalIdFromLogs(receipt.logs);
-    return { receipt, gasPrice, proposalId };
+    return { receipt, proposalId };
   }
 }

package/src/contracts/multicall.ts

@@ -36,7 +36,7 @@ export class Multicall3 {
     const encodedForwarderData = encodeFunctionData(forwarderFunctionData);
 
     try {
-      const { receipt, gasPrice } = await l1TxUtils.sendAndMonitorTransaction(
+      const { receipt, state } = await l1TxUtils.sendAndMonitorTransaction(
         {
           to: MULTI_CALL_3_ADDRESS,
           data: encodedForwarderData,
@@ -47,7 +47,7 @@ export class Multicall3 {
 
       if (receipt.status === 'success') {
         const stats = await l1TxUtils.getTransactionStats(receipt.transactionHash);
-        return { receipt, gasPrice, stats };
+        return { receipt, stats };
       } else {
         logger.error('Forwarder transaction failed', undefined, { receipt });
 
@@ -59,7 +59,7 @@ export class Multicall3 {
         let errorMsg: string | undefined;
 
         if (blobConfig) {
-          const maxFeePerBlobGas = blobConfig.maxFeePerBlobGas ?? gasPrice.maxFeePerBlobGas;
+          const maxFeePerBlobGas = blobConfig.maxFeePerBlobGas ?? state.gasPrice.maxFeePerBlobGas;
           if (maxFeePerBlobGas === undefined) {
             errorMsg = 'maxFeePerBlobGas is required to get the error message';
           } else {
@@ -90,7 +90,7 @@ export class Multicall3 {
           errorMsg = await l1TxUtils.tryGetErrorFromRevertedTx(encodedForwarderData, args, undefined, []);
         }
 
-        return { receipt, gasPrice, errorMsg };
+        return { receipt, errorMsg };
       }
     } catch (err) {
       if (err instanceof TimeoutError) {

package/src/deploy_l1_contracts.ts

@@ -1449,11 +1449,14 @@ export class L1Deployer {
     tx: L1TxRequest,
     options?: L1GasConfig,
   ): Promise<{ txHash: Hex; gasLimit: bigint; gasPrice: GasPrice }> {
-    return this.l1TxUtils.sendTransaction(tx, options);
+    return this.l1TxUtils.sendTransaction(tx, options).then(({ txHash, state }) => ({
+      txHash,
+      gasLimit: state.gasLimit,
+      gasPrice: state.gasPrice,
+    }));
   }
 }
 
-// docs:start:deployL1Contract
 /**
  * Helper function to deploy ETH contracts.
  * @param walletClient - A viem WalletClient.
@@ -1650,5 +1653,3 @@ export function getExpectedAddress(
     calldata,
   };
 }
-
-// docs:end:deployL1Contract

package/src/l1_reader.ts

@@ -4,7 +4,7 @@ import { type L1ContractAddresses, l1ContractAddressesMapping } from './l1_contr
 
 /** Configuration of the L1GlobalReader. */
 export interface L1ReaderConfig {
-  /** The RPC Url of the ethereum host. */
+  /** List of URLs of Ethereum RPC nodes that services will connect to (comma separated). */
   l1RpcUrls: string[];
   /** The chain ID of the ethereum host. */
   l1ChainId: number;
@@ -26,7 +26,7 @@ export const l1ReaderConfigMappings: ConfigMappingsType<L1ReaderConfig> = {
   },
   l1RpcUrls: {
     env: 'ETHEREUM_HOSTS',
-    description: 'The RPC Url of the ethereum host.',
+    description: 'List of URLs of Ethereum RPC nodes that services will connect to (comma separated).',
     parseEnv: (val: string) => val.split(',').map(url => url.trim()),
     defaultValue: [],
   },

package/src/l1_tx_utils/factory.ts

@@ -13,7 +13,7 @@ import type { SigningCallback } from './types.js';
 
 export function createL1TxUtilsFromViemWallet(
   client: ExtendedViemWalletClient,
-  logger: Logger = createLogger('L1TxUtils'),
+  logger: Logger = createLogger('l1-tx-utils'),
   dateProvider: DateProvider = new DateProvider(),
   config?: Partial<L1TxUtilsConfig>,
   debugMaxGasLimit: boolean = false,
@@ -32,7 +32,7 @@ export function createL1TxUtilsFromViemWallet(
 export function createL1TxUtilsFromEthSigner(
   client: ViemClient,
   signer: EthSigner,
-  logger: Logger = createLogger('L1TxUtils'),
+  logger: Logger = createLogger('l1-tx-utils'),
   dateProvider: DateProvider = new DateProvider(),
   config?: Partial<L1TxUtilsConfig>,
   debugMaxGasLimit: boolean = false,

package/src/l1_tx_utils/l1_tx_utils.ts

@@ -1,3 +1,4 @@
+import { maxBigint } from '@aztec/foundation/bigint';
 import { times } from '@aztec/foundation/collection';
 import { TimeoutError } from '@aztec/foundation/error';
 import { EthAddress } from '@aztec/foundation/eth-address';
@@ -30,18 +31,19 @@ import { type L1TxUtilsConfig, l1TxUtilsConfigMappings } from './config.js';
 import { LARGE_GAS_LIMIT } from './constants.js';
 import { ReadOnlyL1TxUtils } from './readonly_l1_tx_utils.js';
 import {
-  type GasPrice,
   type L1BlobInputs,
   type L1GasConfig,
   type L1TxRequest,
+  type L1TxState,
   type SigningCallback,
   TxUtilsState,
 } from './types.js';
 
+const MAX_L1_TX_STATES = 32;
+
 export class L1TxUtils extends ReadOnlyL1TxUtils {
-  private txUtilsState: TxUtilsState = TxUtilsState.IDLE;
-  private lastMinedBlockNumber: bigint | undefined = undefined;
-  private nonceManager: NonceManager;
+  protected nonceManager: NonceManager;
+  protected txs: L1TxState[] = [];
 
   constructor(
     public override client: ViemClient,
@@ -57,21 +59,28 @@ export class L1TxUtils extends ReadOnlyL1TxUtils {
   }
 
   public get state() {
-    return this.txUtilsState;
+    return this.txs.at(-1)?.status ?? TxUtilsState.IDLE;
   }
 
   public get lastMinedAtBlockNumber() {
-    return this.lastMinedBlockNumber;
+    const minedBlockNumbers = this.txs.map(tx => tx.receipt?.blockNumber).filter(bn => bn !== undefined);
+    return minedBlockNumbers.length === 0 ? undefined : maxBigint(...minedBlockNumbers);
   }
 
-  private set lastMinedAtBlockNumber(blockNumber: bigint | undefined) {
-    this.lastMinedBlockNumber = blockNumber;
+  protected updateState(l1TxState: L1TxState, newState: TxUtilsState) {
+    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}`,
+    );
   }
 
-  private set state(state: TxUtilsState) {
-    this.txUtilsState = state;
-    this.logger?.debug(
-      `L1TxUtils state changed to ${TxUtilsState[state]} for sender: ${this.getSenderAddress().toString()}`,
+  public updateConfig(newConfig: Partial<L1TxUtilsConfig>) {
+    this.config = { ...this.config, ...newConfig };
+    this.logger.info(
+      'Updated L1TxUtils config',
+      pickBy(newConfig, (_, key) => key in l1TxUtilsConfigMappings),
     );
   }
 
@@ -103,12 +112,12 @@ export class L1TxUtils extends ReadOnlyL1TxUtils {
    */
   public async sendTransaction(
     request: L1TxRequest,
-    _gasConfig?: L1GasConfig,
+    gasConfigOverrides?: L1GasConfig,
     blobInputs?: L1BlobInputs,
     stateChange: TxUtilsState = TxUtilsState.SENT,
-  ): Promise<{ txHash: Hex; gasLimit: bigint; gasPrice: GasPrice }> {
+  ): Promise<{ txHash: Hex; state: L1TxState }> {
     try {
-      const gasConfig = { ...this.config, ..._gasConfig };
+      const gasConfig = { ...this.config, ...gasConfigOverrides };
       const account = this.getSenderAddress().toString();
 
       let gasLimit: bigint;
@@ -133,32 +142,41 @@ export class L1TxUtils extends ReadOnlyL1TxUtils {
         chainId: this.client.chain.id,
       });
 
-      let txHash: Hex;
-      if (blobInputs) {
-        const txData = {
-          ...request,
-          ...blobInputs,
-          gas: gasLimit,
-          maxFeePerGas: gasPrice.maxFeePerGas,
-          maxPriorityFeePerGas: gasPrice.maxPriorityFeePerGas,
-          maxFeePerBlobGas: gasPrice.maxFeePerBlobGas!,
-          nonce,
-        };
-
-        const signedRequest = await this.prepareSignedTransaction(txData);
-        txHash = await this.client.sendRawTransaction({ serializedTransaction: signedRequest });
-      } else {
-        const txData = {
-          ...request,
-          gas: gasLimit,
-          maxFeePerGas: gasPrice.maxFeePerGas,
-          maxPriorityFeePerGas: gasPrice.maxPriorityFeePerGas,
-          nonce,
-        };
-        const signedRequest = await this.prepareSignedTransaction(txData);
-        txHash = await this.client.sendRawTransaction({ serializedTransaction: signedRequest });
+      const l1TxState: L1TxState = {
+        txHashes: [],
+        cancelTxHashes: [],
+        gasPrice,
+        request,
+        status: TxUtilsState.IDLE,
+        nonce,
+        gasLimit,
+        txConfig: gasConfig,
+        blobInputs,
+      };
+
+      this.updateState(l1TxState, stateChange);
+
+      const baseTxData = {
+        ...request,
+        gas: gasLimit,
+        maxFeePerGas: gasPrice.maxFeePerGas,
+        maxPriorityFeePerGas: gasPrice.maxPriorityFeePerGas,
+        nonce,
+      };
+
+      const txData = blobInputs
+        ? { ...baseTxData, ...blobInputs, maxFeePerBlobGas: gasPrice.maxFeePerBlobGas! }
+        : baseTxData;
+
+      const signedRequest = await this.prepareSignedTransaction(txData);
+      const txHash = await this.client.sendRawTransaction({ serializedTransaction: signedRequest });
+
+      l1TxState.txHashes.push(txHash);
+      this.txs.push(l1TxState);
+      if (this.txs.length > MAX_L1_TX_STATES) {
+        this.txs.shift();
       }
-      this.state = stateChange;
+
       const cleanGasConfig = pickBy(gasConfig, (_, key) => key in l1TxUtilsConfigMappings);
       this.logger?.info(`Sent L1 transaction ${txHash}`, {
         gasLimit,
@@ -168,7 +186,7 @@ export class L1TxUtils extends ReadOnlyL1TxUtils {
         ...(gasPrice.maxFeePerBlobGas && { maxFeePerBlobGas: formatGwei(gasPrice.maxFeePerBlobGas) }),
       });
 
-      return { txHash, gasLimit, gasPrice };
+      return { txHash, state: l1TxState };
     } catch (err: any) {
       const viemError = formatViemError(err, request.abi);
       this.logger?.error(`Failed to send L1 transaction`, viemError.message, {
@@ -178,60 +196,51 @@ export class L1TxUtils extends ReadOnlyL1TxUtils {
     }
   }
 
+  private async tryGetTxReceipt(
+    txHashes: Hex[],
+    nonce: number,
+    isCancelTx: boolean,
+  ): Promise<TransactionReceipt | undefined> {
+    for (const hash of txHashes) {
+      try {
+        const receipt = await this.client.getTransactionReceipt({ hash });
+        if (receipt) {
+          const what = isCancelTx ? 'Cancellation L1 transaction' : 'L1 transaction';
+          if (receipt.status === 'reverted') {
+            this.logger?.warn(`${what} ${hash} with nonce ${nonce} reverted`, receipt);
+          } else {
+            this.logger?.verbose(`${what} ${hash} with nonce ${nonce} mined`, receipt);
+          }
+          return receipt;
+        }
+      } catch (err) {
+        if (err instanceof Error && err.name === 'TransactionReceiptNotFoundError') {
+          continue;
+        } else {
+          this.logger.error(`Error getting receipt for tx ${hash}`, err);
+          continue;
+        }
+      }
+    }
+  }
+
   /**
    * Monitors a transaction until completion, handling speed-ups if needed
-   * @param request - Original transaction request (needed for speed-ups)
-   * @param initialTxHash - Hash of the initial transaction
-   * @param allVersions - Hashes of all transactions submitted under the same nonce (any of them could mine)
-   * @param params - Parameters used in the initial transaction
-   * @param gasConfig - Optional gas configuration
    */
-  public async monitorTransaction(
-    request: L1TxRequest,
-    initialTxHash: Hex,
-    allVersions: Set<Hex>,
-    params: { gasLimit: bigint },
-    _gasConfig?: Partial<L1TxUtilsConfig> & { txTimeoutAt?: Date },
-    _blobInputs?: L1BlobInputs,
-    isCancelTx: boolean = false,
-  ): Promise<TransactionReceipt> {
-    const isBlobTx = !!_blobInputs;
-    const gasConfig = { ...this.config, ..._gasConfig };
+  protected async monitorTransaction(state: L1TxState): Promise<TransactionReceipt> {
+    const { request, nonce, txHashes, cancelTxHashes, gasLimit, blobInputs, txConfig: gasConfig } = state;
+    const isCancelTx = cancelTxHashes.length > 0;
+    const isBlobTx = !!blobInputs;
     const account = this.getSenderAddress().toString();
 
-    const blobInputs = _blobInputs || {};
     const makeGetTransactionBackoff = () =>
       makeBackoff(times(gasConfig.txPropagationMaxQueryAttempts ?? 3, i => i + 1));
 
-    // Retry a few times, in case the tx is not yet propagated.
-    const tx = await retry<GetTransactionReturnType>(
-      () => this.client.getTransaction({ hash: initialTxHash }),
-      `Getting L1 transaction ${initialTxHash}`,
-      makeGetTransactionBackoff(),
-      this.logger,
-      true,
-    );
-
-    if (!tx) {
-      throw new Error(`Failed to get L1 transaction ${initialTxHash} to monitor`);
-    }
-
-    if (tx?.nonce === undefined || tx?.nonce === null) {
-      throw new Error(`Failed to get L1 transaction ${initialTxHash} nonce`);
-    }
-    const nonce = tx.nonce;
-
-    allVersions.add(initialTxHash);
-    let currentTxHash = initialTxHash;
+    let currentTxHash = isCancelTx ? cancelTxHashes[0] : txHashes[0];
     let attempts = 0;
     let lastAttemptSent = this.dateProvider.now();
-    let lastGasPrice: GasPrice = {
-      maxFeePerGas: tx.maxFeePerGas!,
-      maxPriorityFeePerGas: tx.maxPriorityFeePerGas!,
-      maxFeePerBlobGas: tx.maxFeePerBlobGas!,
-    };
-    const initialTxTime = lastAttemptSent;
 
+    const initialTxTime = lastAttemptSent;
     let txTimedOut = false;
     let latestBlockTimestamp: bigint | undefined;
 
@@ -256,28 +265,19 @@ export class L1TxUtils extends ReadOnlyL1TxUtils {
         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) {
-          for (const hash of allVersions) {
-            try {
-              const receipt = await this.client.getTransactionReceipt({ hash });
-              if (receipt) {
-                if (receipt.status === 'reverted') {
-                  this.logger?.error(`L1 transaction ${hash} reverted`, receipt);
-                } else {
-                  this.logger?.debug(`L1 transaction ${hash} mined`);
-                }
-                this.state = TxUtilsState.MINED;
-                this.lastMinedAtBlockNumber = receipt.blockNumber;
-                return receipt;
-              }
-            } catch (err) {
-              if (err instanceof Error && err.message.includes('reverted')) {
-                throw formatViemError(err);
-              }
-            }
+          const receipt =
+            (await this.tryGetTxReceipt(cancelTxHashes, nonce, true)) ??
+            (await this.tryGetTxReceipt(txHashes, nonce, false));
+
+          if (receipt) {
+            this.updateState(state, TxUtilsState.MINED);
+            state.receipt = receipt;
+            return receipt;
           }
+
           // 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.state = TxUtilsState.MINED;
+          this.updateState(state, TxUtilsState.MINED);
           throw new Error(`Nonce ${nonce} is MINED but not by one of our expected transactions`);
         }
 
@@ -328,7 +328,7 @@ export class L1TxUtils extends ReadOnlyL1TxUtils {
                 }
               : undefined,
           );
-          lastGasPrice = newGasPrice;
+          state.gasPrice = newGasPrice;
 
           this.logger?.debug(
             `L1 transaction ${currentTxHash} appears stuck. Attempting speed-up ${attempts}/${gasConfig.maxAttempts} ` +
@@ -340,26 +340,28 @@ export class L1TxUtils extends ReadOnlyL1TxUtils {
             },
           );
 
-          const txData: PrepareTransactionRequestRequest = {
+          const baseTxData = {
             ...request,
-            ...blobInputs,
-            nonce,
-            gas: params.gasLimit,
+            gas: gasLimit,
             maxFeePerGas: newGasPrice.maxFeePerGas,
             maxPriorityFeePerGas: newGasPrice.maxPriorityFeePerGas,
+            nonce,
           };
-          if (isBlobTx && newGasPrice.maxFeePerBlobGas) {
-            (txData as any).maxFeePerBlobGas = newGasPrice.maxFeePerBlobGas;
-          }
+
+          const txData = blobInputs
+            ? { ...baseTxData, ...blobInputs, maxFeePerBlobGas: newGasPrice.maxFeePerBlobGas! }
+            : baseTxData;
+
           const signedRequest = await this.prepareSignedTransaction(txData);
           const newHash = await this.client.sendRawTransaction({ serializedTransaction: signedRequest });
+
           if (!isCancelTx) {
-            this.state = TxUtilsState.SPEED_UP;
+            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: params.gasLimit,
+            gasLimit,
             maxFeePerGas: formatGwei(newGasPrice.maxFeePerGas),
             maxPriorityFeePerGas: formatGwei(newGasPrice.maxPriorityFeePerGas),
             gasConfig: cleanGasConfig,
@@ -368,7 +370,7 @@ export class L1TxUtils extends ReadOnlyL1TxUtils {
 
           currentTxHash = newHash;
 
-          allVersions.add(currentTxHash);
+          (isCancelTx ? cancelTxHashes : txHashes).push(currentTxHash);
           lastAttemptSent = this.dateProvider.now();
         }
         await sleep(gasConfig.checkIntervalMs!);
@@ -387,10 +389,10 @@ export class L1TxUtils extends ReadOnlyL1TxUtils {
     // 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) {
-      this.state = TxUtilsState.NOT_MINED;
+      this.updateState(state, TxUtilsState.NOT_MINED);
     } else if (gasConfig.cancelTxOnTimeout) {
       // Fire cancellation without awaiting to avoid blocking the main thread
-      this.attemptTxCancellation(currentTxHash, nonce, allVersions, isBlobTx, lastGasPrice, attempts).catch(err => {
+      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,
@@ -398,7 +400,7 @@ export class L1TxUtils extends ReadOnlyL1TxUtils {
       });
     }
 
-    this.logger?.error(`L1 transaction ${currentTxHash} timed out`, undefined, {
+    this.logger?.warn(`L1 transaction ${currentTxHash} timed out`, {
       txHash: currentTxHash,
       txTimeoutAt: gasConfig.txTimeoutAt,
       txTimeoutMs: gasConfig.txTimeoutMs,
@@ -406,7 +408,6 @@ export class L1TxUtils extends ReadOnlyL1TxUtils {
       now: this.dateProvider.now(),
       attempts,
       isInterrupted: this.interrupted,
-      ...tx,
     });
 
     throw new TimeoutError(`L1 transaction ${currentTxHash} timed out`);
@@ -422,10 +423,10 @@ export class L1TxUtils extends ReadOnlyL1TxUtils {
     request: L1TxRequest,
     gasConfig?: L1GasConfig,
     blobInputs?: L1BlobInputs,
-  ): Promise<{ receipt: TransactionReceipt; gasPrice: GasPrice }> {
-    const { txHash, gasLimit, gasPrice } = await this.sendTransaction(request, gasConfig, blobInputs);
-    const receipt = await this.monitorTransaction(request, txHash, new Set(), { gasLimit }, gasConfig, blobInputs);
-    return { receipt, gasPrice };
+  ): Promise<{ receipt: TransactionReceipt; state: L1TxState }> {
+    const { state } = await this.sendTransaction(request, gasConfig, blobInputs);
+    const receipt = await this.monitorTransaction(state);
+    return { receipt, state };
   }
 
   public override async simulate(
@@ -458,23 +459,11 @@ 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
-   * @param nonce - The nonce of the transaction to cancel
-   * @param allVersions - Hashes of all transactions submitted under the same nonce (any of them could mine)
-   * @param previousGasPrice - The gas price of the previous transaction
-   * @param attempts - The number of attempts to cancel the transaction
    * @returns The hash of the cancellation transaction
    */
-  protected async attemptTxCancellation(
-    currentTxHash: Hex,
-    nonce: number,
-    allVersions: Set<Hex>,
-    isBlobTx = false,
-    previousGasPrice?: GasPrice,
-    attempts = 0,
-  ) {
-    if (isBlobTx) {
-      throw new Error('Cannot cancel blob transactions, please use L1TxUtilsWithBlobsClass');
-    }
+  protected async attemptTxCancellation(state: L1TxState, attempts: number) {
+    const isBlobTx = state.blobInputs !== undefined;
+    const { nonce, gasPrice: previousGasPrice } = state;
 
     // Get gas price with higher priority fee for cancellation
     const cancelGasPrice = await this.getGasPrice(
@@ -488,40 +477,53 @@ export class L1TxUtils extends ReadOnlyL1TxUtils {
       previousGasPrice,
     );
 
-    this.logger?.info(`Attempting to cancel L1 transaction ${currentTxHash} with nonce ${nonce}`, {
-      maxFeePerGas: formatGwei(cancelGasPrice.maxFeePerGas),
-      maxPriorityFeePerGas: formatGwei(cancelGasPrice.maxPriorityFeePerGas),
-    });
+    const { maxFeePerGas, maxPriorityFeePerGas, maxFeePerBlobGas } = cancelGasPrice;
+    this.logger?.info(
+      `Attempting to cancel L1 ${isBlobTx ? 'blob' : 'vanilla'} transaction ${state.txHashes[0]} with nonce ${nonce}`,
+      {
+        maxFeePerGas: formatGwei(maxFeePerGas),
+        maxPriorityFeePerGas: formatGwei(maxPriorityFeePerGas),
+        ...(maxFeePerBlobGas && { maxFeePerBlobGas: formatGwei(maxFeePerBlobGas) }),
+      },
+    );
+
     const request = {
       to: this.getSenderAddress().toString(),
       value: 0n,
     };
 
     // Send 0-value tx to self with higher gas price
-    const txData = {
+    const baseTxData = {
       ...request,
       nonce,
-      gas: 21_000n, // Standard ETH transfer gas
-      maxFeePerGas: cancelGasPrice.maxFeePerGas,
-      maxPriorityFeePerGas: cancelGasPrice.maxPriorityFeePerGas,
+      gas: 21_000n,
+      maxFeePerGas,
+      maxPriorityFeePerGas,
     };
+
+    const txData = isBlobTx ? { ...baseTxData, ...this.makeEmptyBlobInputs(maxFeePerBlobGas!) } : baseTxData;
     const signedRequest = await this.prepareSignedTransaction(txData);
     const cancelTxHash = await this.client.sendRawTransaction({ serializedTransaction: signedRequest });
 
-    this.state = TxUtilsState.CANCELLED;
+    state.gasPrice = cancelGasPrice;
+    state.gasLimit = 21_000n;
+    state.cancelTxHashes.push(cancelTxHash);
 
-    this.logger?.info(`Sent cancellation tx ${cancelTxHash} for timed out tx ${currentTxHash}`, { nonce });
+    this.updateState(state, TxUtilsState.CANCELLED);
 
-    const receipt = await this.monitorTransaction(
-      request,
-      cancelTxHash,
-      allVersions,
-      { gasLimit: 21_000n },
-      undefined,
-      undefined,
-      true,
-    );
+    this.logger?.info(`Sent cancellation tx ${cancelTxHash} for timed out tx with nonce ${nonce}`, {
+      nonce,
+      txData,
+      isBlobTx,
+      txHashes: state.txHashes,
+    });
+
+    const { transactionHash } = await this.monitorTransaction(state);
+    return transactionHash;
+  }
 
-    return receipt.transactionHash;
+  /** Makes empty blob inputs for the cancellation tx. To be overridden in L1TxUtilsWithBlobs. */
+  protected makeEmptyBlobInputs(_maxFeePerBlobGas: bigint): Required<L1BlobInputs> {
+    throw new Error('Cannot make empty blob inputs for cancellation');
   }
 }