@aztec/ethereum 0.0.1-commit.f2ce05ee → 0.0.1-commit.f5a9928

package/src/l1_tx_utils/forwarder_l1_tx_utils.ts

@@ -1,25 +1,27 @@
+import type { BlobKzgInstance } from '@aztec/blob-lib/types';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import type { Logger } from '@aztec/foundation/log';
 import type { DateProvider } from '@aztec/foundation/timer';
 
 import { type Hex, encodeFunctionData } from 'viem';
 
-import type { EthSigner } from '../eth-signer/eth-signer.js';
 import { FORWARDER_ABI } from '../forwarder_proxy.js';
-import type { ExtendedViemWalletClient, ViemClient } from '../types.js';
+import type { ViemClient } from '../types.js';
 import type { L1TxUtilsConfig } from './config.js';
+import type { L1SignerSource } from './factory.js';
+import { resolveSignerSource } from './factory.js';
 import type { IL1TxMetrics, IL1TxStore } from './interfaces.js';
-import { L1TxUtilsWithBlobs } from './l1_tx_utils_with_blobs.js';
-import { createViemSigner } from './signer.js';
+import { L1TxUtils } from './l1_tx_utils.js';
+import { Delayer } from './tx_delayer.js';
 import type { L1BlobInputs, L1TxConfig, L1TxRequest, SigningCallback } from './types.js';
 
 /**
- * Extends L1TxUtilsWithBlobs to wrap all transactions through a forwarder contract.
+ * Extends L1TxUtils to wrap all transactions through a forwarder contract.
  * This is mainly used for testing the archiver's ability to decode transactions that go through proxies.
  */
-export class ForwarderL1TxUtils extends L1TxUtilsWithBlobs {
+export class ForwarderL1TxUtils extends L1TxUtils {
   constructor(
-    client: ViemClient | ExtendedViemWalletClient,
+    client: ViemClient,
     senderAddress: EthAddress,
     signingCallback: SigningCallback,
     logger: Logger | undefined,
@@ -28,9 +30,23 @@ export class ForwarderL1TxUtils extends L1TxUtilsWithBlobs {
     debugMaxGasLimit: boolean,
     store: IL1TxStore | undefined,
     metrics: IL1TxMetrics | undefined,
+    kzg: BlobKzgInstance | undefined,
+    delayer: Delayer | undefined,
     private readonly forwarderAddress: EthAddress,
   ) {
-    super(client, senderAddress, signingCallback, logger, dateProvider, config, debugMaxGasLimit, store, metrics);
+    super(
+      client,
+      senderAddress,
+      signingCallback,
+      logger,
+      dateProvider,
+      config,
+      debugMaxGasLimit,
+      store,
+      metrics,
+      kzg,
+      delayer,
+    );
   }
 
   /**
@@ -61,59 +77,32 @@ export class ForwarderL1TxUtils extends L1TxUtilsWithBlobs {
   }
 }
 
-export function createForwarderL1TxUtilsFromViemWallet(
-  client: ExtendedViemWalletClient,
+export function createForwarderL1TxUtils(
+  source: L1SignerSource,
   forwarderAddress: EthAddress,
-  deps: {
+  deps?: {
     logger?: Logger;
     dateProvider?: DateProvider;
     store?: IL1TxStore;
     metrics?: IL1TxMetrics;
-  } = {},
-  config: Partial<L1TxUtilsConfig> = {},
-  debugMaxGasLimit: boolean = false,
-) {
+    kzg?: BlobKzgInstance;
+    delayer?: Delayer;
+  },
+  config?: Partial<L1TxUtilsConfig> & { debugMaxGasLimit?: boolean },
+): ForwarderL1TxUtils {
+  const { client, address, signingCallback } = resolveSignerSource(source);
   return new ForwarderL1TxUtils(
     client,
-    EthAddress.fromString(client.account.address),
-    createViemSigner(client),
-    deps.logger,
-    deps.dateProvider,
-    config,
-    debugMaxGasLimit,
-    deps.store,
-    deps.metrics,
-    forwarderAddress,
-  );
-}
-
-export function createForwarderL1TxUtilsFromEthSigner(
-  client: ViemClient,
-  signer: EthSigner,
-  forwarderAddress: EthAddress,
-  deps: {
-    logger?: Logger;
-    dateProvider?: DateProvider;
-    store?: IL1TxStore;
-    metrics?: IL1TxMetrics;
-  } = {},
-  config: Partial<L1TxUtilsConfig> = {},
-  debugMaxGasLimit: boolean = false,
-) {
-  const callback: SigningCallback = async (transaction, _signingAddress) => {
-    return (await signer.signTransaction(transaction)).toViemTransactionSignature();
-  };
-
-  return new ForwarderL1TxUtils(
-    client,
-    signer.address,
-    callback,
-    deps.logger,
-    deps.dateProvider,
-    config,
-    debugMaxGasLimit,
-    deps.store,
-    deps.metrics,
+    address,
+    signingCallback,
+    deps?.logger,
+    deps?.dateProvider,
+    config ?? {},
+    config?.debugMaxGasLimit ?? false,
+    deps?.store,
+    deps?.metrics,
+    deps?.kzg,
+    deps?.delayer,
     forwarderAddress,
   );
 }

package/src/l1_tx_utils/index-blobs.ts

@@ -1,2 +1,2 @@
-export * from './forwarder_l1_tx_utils.js';
-export * from './l1_tx_utils_with_blobs.js';
+export { createForwarderL1TxUtils, ForwarderL1TxUtils } from './forwarder_l1_tx_utils.js';
+export { createL1TxUtils, type L1SignerSource, resolveSignerSource } from './factory.js';

package/src/l1_tx_utils/index.ts

@@ -8,6 +8,7 @@ export * from './l1_tx_utils.js';
 export * from './readonly_l1_tx_utils.js';
 export * from './signer.js';
 export * from './types.js';
+export * from './tx_delayer.js';
 export * from './utils.js';
 
 // Note: We intentionally do not export l1_tx_utils_with_blobs.js

package/src/l1_tx_utils/l1_tx_utils.ts

@@ -1,9 +1,11 @@
+import type { BlobKzgInstance } from '@aztec/blob-lib/types';
 import { maxBigint } from '@aztec/foundation/bigint';
 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 { retryUntil } from '@aztec/foundation/retry';
+import { type Logger, type LoggerBindings, createLogger } from '@aztec/foundation/log';
+import { Semaphore } from '@aztec/foundation/queue';
+import { makeBackoff, retry, 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,16 +15,13 @@ import {
   type Abi,
   type BlockOverrides,
   type Hex,
-  type NonceManager,
   type PrepareTransactionRequestRequest,
   type StateOverride,
   type TransactionReceipt,
   type TransactionSerializable,
-  createNonceManager,
   formatGwei,
   serializeTransaction,
 } from 'viem';
-import { jsonRpc } from 'viem/nonce';
 
 import type { ViemClient } from '../types.js';
 import { formatViemError } from '../utils.js';
@@ -30,6 +29,7 @@ import { type L1TxUtilsConfig, l1TxUtilsConfigMappings } from './config.js';
 import { MAX_L1_TX_LIMIT } from './constants.js';
 import type { IL1TxMetrics, IL1TxStore } from './interfaces.js';
 import { ReadOnlyL1TxUtils } from './readonly_l1_tx_utils.js';
+import { Delayer, createDelayer, wrapClientWithDelayer } from './tx_delayer.js';
 import {
   DroppedTransactionError,
   type L1BlobInputs,
@@ -44,9 +44,21 @@ import {
 
 const MAX_L1_TX_STATES = 32;
 
+// Backoff (in seconds) for retrying the read-only RPC calls that prepare a tx cancellation. A
+// cancellation is fired in the background after a tx times out and is important (it frees the stuck
+// nonce), so a transient RPC failure while reading the pending nonce or gas price must not abandon it.
+const CANCELLATION_PREP_RETRY_BACKOFF_S = [1, 2, 4, 8];
+
 export class L1TxUtils extends ReadOnlyL1TxUtils {
-  protected nonceManager: NonceManager;
   protected txs: L1TxState[] = [];
+  /** Last nonce successfully sent to the chain. Used as a lower bound when a fallback RPC node returns a stale count. */
+  private lastSentNonce: number | undefined;
+  /** Mutex to prevent concurrent sendTransaction calls from racing on the same nonce. */
+  private readonly sendMutex = new Semaphore(1);
+  /** Tx delayer for testing. Only set when enableDelayer config is true. */
+  public delayer?: Delayer;
+  /** KZG instance for blob operations. */
+  protected kzg?: BlobKzgInstance;
 
   constructor(
     public override client: ViemClient,
@@ -58,9 +70,25 @@ export class L1TxUtils extends ReadOnlyL1TxUtils {
     debugMaxGasLimit: boolean = false,
     protected store?: IL1TxStore,
     protected metrics?: IL1TxMetrics,
+    kzg?: BlobKzgInstance,
+    delayer?: Delayer,
   ) {
     super(client, logger, dateProvider, config, debugMaxGasLimit);
-    this.nonceManager = createNonceManager({ source: jsonRpc() });
+    this.kzg = kzg;
+
+    // Set up delayer: use provided one or create new
+    if (config?.enableDelayer && config?.ethereumSlotDuration) {
+      this.delayer =
+        delayer ?? this.createDelayer({ ethereumSlotDuration: config.ethereumSlotDuration }, logger.getBindings());
+      this.client = wrapClientWithDelayer(this.client, this.delayer);
+      if (config.txDelayerMaxInclusionTimeIntoSlot !== undefined) {
+        this.delayer.setMaxInclusionTimeIntoSlot(config.txDelayerMaxInclusionTimeIntoSlot);
+      }
+    } else if (delayer) {
+      // Delayer provided but enableDelayer not set — just store it without wrapping
+      logger.warn('Delayer provided but enableDelayer config is not set; delayer will not be used');
+      this.delayer = delayer;
+    }
   }
 
   public get state() {
@@ -87,6 +115,11 @@ export class L1TxUtils extends ReadOnlyL1TxUtils {
       this.metrics?.recordMinedTx(l1TxState, new Date(l1Timestamp));
     } else if (newState === TxUtilsState.NOT_MINED) {
       this.metrics?.recordDroppedTx(l1TxState);
+      // The tx was dropped: the chain nonce reverted to l1TxState.nonce, so our lower bound is
+      // no longer valid. Clear it so the next send fetches the real nonce from the chain.
+      if (this.lastSentNonce === l1TxState.nonce) {
+        this.lastSentNonce = undefined;
+      }
     }
 
     // Update state in the store
@@ -103,6 +136,14 @@ export class L1TxUtils extends ReadOnlyL1TxUtils {
     );
   }
 
+  /**
+   * Clears the cached `lastSentNonce` so the next `sendTransaction` call fetches the real
+   * nonce from the chain. Call this after an L1 reorg to prevent stale nonce references.
+   */
+  public resetNonce(): void {
+    this.lastSentNonce = undefined;
+  }
+
   public getSenderAddress() {
     return this.address;
   }
@@ -185,6 +226,19 @@ export class L1TxUtils extends ReadOnlyL1TxUtils {
     return await this.signTransaction(txRequest as TransactionSerializable);
   }
 
+  private async checkInterruptedOrTimedOut(gasConfig: Pick<L1TxConfig, 'txTimeoutAt'>): Promise<Date> {
+    if (this.interrupted) {
+      throw new InterruptError(`Transaction sending is interrupted`);
+    }
+    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()})`,
+      );
+    }
+    return now;
+  }
+
   /**
    * Sends a transaction with gas estimation and pricing
    * @param request - The transaction request (to, data, value)
@@ -197,14 +251,15 @@ export class L1TxUtils extends ReadOnlyL1TxUtils {
     blobInputs?: L1BlobInputs,
     stateChange: TxUtilsState = TxUtilsState.SENT,
   ): Promise<{ txHash: Hex; state: L1TxState }> {
-    if (this.interrupted) {
-      throw new InterruptError(`Transaction sending is interrupted`);
-    }
-
     try {
       const gasConfig = merge(this.config, gasConfigOverrides);
       const account = this.getSenderAddress().toString();
 
+      // Fail fast before doing any work (gas estimation, balance check) if we've been interrupted
+      // or if the caller's deadline has already passed. The same check is repeated after gas
+      // estimation in case it took long enough to push us past the deadline.
+      await this.checkInterruptedOrTimedOut(gasConfig);
+
       let gasLimit: bigint;
       if (this.debugMaxGasLimit) {
         gasLimit = MAX_L1_TX_LIMIT;
@@ -217,34 +272,34 @@ export class L1TxUtils extends ReadOnlyL1TxUtils {
 
       const gasPrice = await this.getGasPrice(gasConfig, !!blobInputs);
 
-      if (this.interrupted) {
-        throw new InterruptError(`Transaction sending is interrupted`);
-      }
-
-      const nonce = await this.nonceManager.consume({
-        client: this.client,
-        address: account,
-        chainId: this.client.chain.id,
-      });
+      const now = await this.checkInterruptedOrTimedOut(gasConfig);
 
-      const baseState = { request, gasLimit, blobInputs, gasPrice, nonce };
-      const txData = this.makeTxData(baseState, { isCancelTx: false });
+      let txHash: Hex;
+      let nonce: number;
+      let baseState: Pick<L1TxState, 'request' | 'gasLimit' | 'blobInputs' | 'gasPrice' | 'nonce'>;
 
-      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()})`,
-        );
+      await this.sendMutex.acquire();
+      try {
+        const chainNonce = await this.client.getTransactionCount({ address: account, blockTag: 'pending' });
+        // If a fallback RPC node returns a stale count (lower than what we last sent), use our
+        // local lower bound to avoid sending a duplicate of an already-pending transaction.
+        nonce =
+          this.lastSentNonce !== undefined && chainNonce <= this.lastSentNonce ? this.lastSentNonce + 1 : chainNonce;
+
+        baseState = { request, gasLimit, blobInputs, gasPrice, nonce };
+        const txData = this.makeTxData(baseState, { isCancelTx: false });
+
+        const signedRequest = await this.prepareSignedTransaction(txData);
+        txHash = await this.client.sendRawTransaction({ serializedTransaction: signedRequest });
+        this.lastSentNonce = nonce;
+      } finally {
+        this.sendMutex.release();
       }
 
-      // Send the new tx
-      const signedRequest = await this.prepareSignedTransaction(txData);
-      const txHash = await this.client.sendRawTransaction({ serializedTransaction: signedRequest });
-
       // Create the new state for monitoring
       const l1TxState: L1TxState = {
         ...baseState,
-        id: (await this.store?.consumeNextStateId(account)) ?? Math.max(...this.txs.map(tx => tx.id), 0),
+        id: (await this.store?.consumeNextStateId(account)) ?? Math.max(...this.txs.map(tx => tx.id), -1) + 1,
         txHashes: [txHash],
         cancelTxHashes: [],
         status: TxUtilsState.IDLE,
@@ -381,10 +436,23 @@ export class L1TxUtils extends ReadOnlyL1TxUtils {
 
     const initialTxHash = txHashes[0];
     let currentTxHash = txHashes.at(-1)!;
-    let l1Timestamp: number;
+    let l1Timestamp = 0;
 
     while (true) {
-      l1Timestamp = await this.getL1Timestamp();
+      try {
+        l1Timestamp = await this.getL1Timestamp();
+      } catch (err) {
+        // A transient RPC failure here must not abort monitoring with a rejection: callers that
+        // fire this loop in the background would surface it as an unhandled rejection (e.g. when a
+        // test tears down its L1 node while a monitor iteration is in flight). Exit quietly if we
+        // are shutting down, otherwise retry on the next interval.
+        if (this.interrupted) {
+          break;
+        }
+        this.logger.error(`Error fetching L1 timestamp while monitoring tx ${currentTxHash}`, err, { nonce, account });
+        await sleep(gasConfig.checkIntervalMs!);
+        continue;
+      }
 
       try {
         const timePassed = l1Timestamp - state.lastSentAtL1Ts.getTime();
@@ -423,7 +491,6 @@ export class L1TxUtils extends ReadOnlyL1TxUtils {
             { nonce, account, pendingNonce, timePassed },
           );
           await this.updateState(state, TxUtilsState.NOT_MINED);
-          this.nonceManager.reset({ address: account, chainId: this.client.chain.id });
           throw new DroppedTransactionError(nonce, account);
         }
 
@@ -515,12 +582,7 @@ export class L1TxUtils extends ReadOnlyL1TxUtils {
 
     // 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.
       await this.updateState(state, TxUtilsState.NOT_MINED);
-      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.
@@ -623,14 +685,14 @@ export class L1TxUtils extends ReadOnlyL1TxUtils {
   ): Promise<{ gasUsed: bigint; result: `0x${string}` }> {
     const blockOverrides = { ..._blockOverrides };
     const gasConfig = merge(this.config, _gasConfig);
-    const gasPrice = await this.getGasPrice(gasConfig, false);
 
+    // Fee fields are deliberately omitted. Supplying them makes the node apply the EIP-1559 upfront funds
+    // check (sender balance >= gas * maxFeePerGas) against the worst-case gas cap below, which rejects the
+    // whole simulation request before any execution. Omitted fee fields default to a zero gas price.
     const call: any = {
       to: request.to!,
       data: request.data,
       from: request.from ?? this.getSenderAddress().toString(),
-      maxFeePerGas: gasPrice.maxFeePerGas,
-      maxPriorityFeePerGas: gasPrice.maxPriorityFeePerGas,
       gas: request.gas ?? MAX_L1_TX_LIMIT,
     };
 
@@ -639,7 +701,7 @@ export class L1TxUtils extends ReadOnlyL1TxUtils {
       blockOverrides.gasLimit = MAX_L1_TX_LIMIT;
     }
 
-    return this._simulate(call, blockOverrides, stateOverrides, gasConfig, abi);
+    return await this._simulate(call, blockOverrides, stateOverrides, gasConfig, abi);
   }
 
   /**
@@ -659,34 +721,48 @@ export class L1TxUtils extends ReadOnlyL1TxUtils {
         { nonce, account },
       );
       await 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) {
+    // Resolve the pending nonce and cancellation gas price up front. These are read-only RPC calls, so
+    // they are safe to retry; a transient RPC failure here must not permanently abandon the cancellation
+    // (which would leave the nonce stuck and the tx state stranded short of CANCELLED). We retry with a
+    // real backoff before giving up, unlike getGasPrice's tight internal retry which can be exhausted by
+    // a brief node hiccup. The retried block performs no state-changing send, so retrying cannot
+    // double-send the cancellation tx.
+    const { currentNonce, cancelGasPrice } = await retry(
+      async () => {
+        const currentNonce = await this.client.getTransactionCount({ address: account, blockTag: 'pending' });
+        if (currentNonce >= nonce) {
+          // 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, // 150% bump should be enough to replace any tx
+            },
+            isBlobTx,
+            state.txHashes.length,
+            previousGasPrice,
+          );
+          return { currentNonce, cancelGasPrice };
+        }
+        return { currentNonce, cancelGasPrice: undefined };
+      },
+      `Preparing cancellation for L1 tx from account ${account} with nonce ${nonce}`,
+      makeBackoff(CANCELLATION_PREP_RETRY_BACKOFF_S),
+      this.logger,
+    );
+
+    if (cancelGasPrice === undefined) {
       this.logger.verbose(
         `Not sending cancellation for L1 tx from account ${account} with nonce ${nonce} as it is dropped`,
         { nonce, account, currentNonce },
       );
       await 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, // 150% bump should be enough to replace any tx
-      },
-      isBlobTx,
-      state.txHashes.length,
-      previousGasPrice,
-    );
-
     const { maxFeePerGas, maxPriorityFeePerGas, maxFeePerBlobGas } = cancelGasPrice;
     this.logger.verbose(
       `Attempting to cancel L1 ${isBlobTx ? 'blob' : 'vanilla'} transaction from account ${account} with nonce ${nonce} after time out`,
@@ -731,8 +807,17 @@ export class L1TxUtils extends ReadOnlyL1TxUtils {
     return Number(timestamp) * 1000;
   }
 
-  /** 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');
+  /** Makes empty blob inputs for the cancellation tx. */
+  protected makeEmptyBlobInputs(maxFeePerBlobGas: bigint): Required<L1BlobInputs> {
+    if (!this.kzg) {
+      throw new Error('Cannot make empty blob inputs for cancellation without kzg');
+    }
+    const blobData = new Uint8Array(131072).fill(0);
+    return { blobs: [blobData], kzg: this.kzg, maxFeePerBlobGas };
+  }
+
+  /** Creates a new delayer instance. */
+  protected createDelayer(opts: { ethereumSlotDuration: bigint | number }, bindings: LoggerBindings): Delayer {
+    return createDelayer(this.dateProvider, opts, bindings);
   }
 }

package/src/l1_tx_utils/readonly_l1_tx_utils.ts

@@ -3,6 +3,7 @@ import type { EthAddress } from '@aztec/foundation/eth-address';
 import { type Logger, createLogger } from '@aztec/foundation/log';
 import { makeBackoff, retry } from '@aztec/foundation/retry';
 import { DateProvider } from '@aztec/foundation/timer';
+import { getErrorCause } from '@aztec/foundation/types';
 import { RollupAbi } from '@aztec/l1-artifacts/RollupAbi';
 
 import pickBy from 'lodash.pickby';
@@ -16,6 +17,7 @@ import {
   type Hex,
   MethodNotFoundRpcError,
   MethodNotSupportedRpcError,
+  RpcRequestError,
   type StateOverride,
   decodeErrorResult,
   formatGwei,
@@ -23,6 +25,7 @@ import {
   hexToBytes,
 } from 'viem';
 
+import { getL1RpcErrorCode } from '../client.js';
 import type { ViemClient } from '../types.js';
 import { type L1TxUtilsConfig, defaultL1TxUtilsConfig, l1TxUtilsConfigMappings } from './config.js';
 import {
@@ -39,6 +42,23 @@ import { getCalldataGasUsage, tryGetCustomErrorNameContractFunction } from './ut
 // Change this to the current strategy we want to use
 const CurrentStrategy: PriorityFeeStrategy = P75AllTxsPriorityFeeStrategy;
 
+/** Error code returned by eth_simulateV1 for `insufficient funds for gas * price + value`. */
+const INSUFFICIENT_FUNDS_RPC_ERROR_CODE = -38014;
+
+/**
+ * Returns true when an RPC transport error reports the node's upfront funds check
+ * (sender balance >= gasLimit * maxFeePerGas) rejecting the request. Matches on the message as well as on the
+ * error code, since RPC gateways differ in how they wrap node errors. Apply this only to transport errors: an
+ * execution revert string can mention insufficient funds without being this kind of rejection.
+ */
+function isInsufficientFundsRpcError(err: unknown): boolean {
+  if (getL1RpcErrorCode(err) === INSUFFICIENT_FUNDS_RPC_ERROR_CODE) {
+    return true;
+  }
+  const messages = [err, getErrorCause(err, RpcRequestError)].map(e => (e instanceof Error ? e.message : '')).join(' ');
+  return /insufficient funds/i.test(messages);
+}
+
 export class ReadOnlyL1TxUtils {
   public config: Required<L1TxUtilsConfig>;
   protected interrupted = false;
@@ -130,9 +150,10 @@ export class ReadOnlyL1TxUtils {
     const numBlocks = Math.ceil(gasConfig.stallTimeMs! / BLOCK_TIME_MS);
     for (let i = 0; i < numBlocks; i++) {
       // each block can go up 12.5% from previous baseFee
-      maxFeePerGas = (maxFeePerGas * (1_000n + 125n)) / 1_000n;
+      // ceil, (a+b-1)/b, to avoid truncation at small values (e.g. 1 wei blob base fee)
+      maxFeePerGas = (maxFeePerGas * (1_000n + 125n) + 999n) / 1_000n;
       // same for blob gas fee
-      maxFeePerBlobGas = (maxFeePerBlobGas * (1_000n + 125n)) / 1_000n;
+      maxFeePerBlobGas = (maxFeePerBlobGas * (1_000n + 125n) + 999n) / 1_000n;
     }
 
     if (attempt > 0) {
@@ -242,13 +263,16 @@ export class ReadOnlyL1TxUtils {
     const gasConfig = { ...this.config, ..._gasConfig };
     let initialEstimate = 0n;
     if (_blobInputs) {
-      // @note requests with blobs also require maxFeePerBlobGas to be set
+      // @note requests with blobs also require maxFeePerBlobGas to be set.
+      // Use 2x buffer for maxFeePerBlobGas to avoid stale fees and to pass EIP-4844 validation (even if it is a gas estimation call).
+      // 1. maxFeePerBlobGas >= blobBaseFee
+      // 2. account balance >= gas * maxFeePerGas + maxFeePerBlobGas * blobCount + value
       const gasPrice = await this.getGasPrice(gasConfig, true, 0);
       initialEstimate = await this.client.estimateGas({
         account,
         ...request,
         ..._blobInputs,
-        maxFeePerBlobGas: gasPrice.maxFeePerBlobGas!,
+        maxFeePerBlobGas: gasPrice.maxFeePerBlobGas! * 2n,
         gas: MAX_L1_TX_LIMIT,
         blockTag: 'latest',
       });
@@ -368,8 +392,8 @@ export class ReadOnlyL1TxUtils {
     gasConfig: L1TxUtilsConfig & { fallbackGasEstimate?: bigint },
     abi: Abi,
   ) {
-    try {
-      const result = await this.client.simulateBlocks({
+    const simulateBlocks = () =>
+      this.client.simulateBlocks({
         validation: false,
         blocks: [
           {
@@ -380,18 +404,13 @@ export class ReadOnlyL1TxUtils {
         ],
       });
 
-      if (result[0].calls[0].status === 'failure') {
-        this.logger?.error('L1 transaction simulation failed', result[0].calls[0].error);
-        const decodedError = decodeErrorResult({ abi, data: result[0].calls[0].data });
-
-        throw new Error(
-          `L1 transaction simulation failed with error ${decodedError.errorName}(${decodedError.args?.join(',')})`,
-        );
-      }
-      this.logger?.debug(`L1 transaction simulation succeeded`, { ...result[0].calls[0] });
-      return { gasUsed: result[0].gasUsed, result: result[0].calls[0].data as `0x${string}` };
+    // Only the request itself is wrapped, so that transport-level rejections are never confused with an
+    // execution revert (whose decoded revert string could well mention insufficient funds too).
+    let result: Awaited<ReturnType<typeof simulateBlocks>>;
+    try {
+      result = await simulateBlocks();
     } catch (err) {
-      if (err instanceof MethodNotFoundRpcError || err instanceof MethodNotSupportedRpcError) {
+      if (getErrorCause(err, MethodNotFoundRpcError) || getErrorCause(err, MethodNotSupportedRpcError)) {
         if (gasConfig.fallbackGasEstimate) {
           this.logger?.warn(
             `Node does not support eth_simulateV1 API. Using fallback gas estimate: ${gasConfig.fallbackGasEstimate}`,
@@ -400,8 +419,29 @@ export class ReadOnlyL1TxUtils {
         }
         this.logger?.error('Node does not support eth_simulateV1 API');
       }
+      if (isInsufficientFundsRpcError(err)) {
+        const rpcError = getErrorCause(err, RpcRequestError);
+        const providerMessage = rpcError?.details ?? (err instanceof Error ? err.message : String(err));
+        const gas = call?.gas !== undefined ? `, gas ${call.gas}` : '';
+        throw new Error(
+          `L1 node rejected the eth_simulateV1 request with an insufficient funds error before executing it ` +
+            `(sender ${call?.from ?? 'unknown'}${gas}): ${providerMessage}`,
+          { cause: err },
+        );
+      }
       throw err;
     }
+
+    if (result[0].calls[0].status === 'failure') {
+      this.logger?.error('L1 transaction simulation failed', result[0].calls[0].error);
+      const decodedError = decodeErrorResult({ abi, data: result[0].calls[0].data });
+
+      throw new Error(
+        `L1 transaction simulation failed with error ${decodedError.errorName}(${decodedError.args?.join(',')})`,
+      );
+    }
+    this.logger?.debug(`L1 transaction simulation succeeded`, { ...result[0].calls[0] });
+    return { gasUsed: result[0].gasUsed, result: result[0].calls[0].data as `0x${string}` };
   }
 
   public bumpGasLimit(gasLimit: bigint, _gasConfig?: L1TxUtilsConfig): bigint {