@aztec/ethereum 0.0.1-commit.42ee6df9b → 0.0.1-commit.431c48d

package/src/l1_contract_addresses.ts

@@ -1,15 +1,15 @@
-import type { ConfigMappingsType } from '@aztec/foundation/config';
+import type { ConfigMapping, ConfigMappingsType } from '@aztec/foundation/config';
 import { EthAddress } from '@aztec/foundation/eth-address';
-import { schemas, zodFor } from '@aztec/foundation/schemas';
+import { schemas } from '@aztec/foundation/schemas';
 
 import { z } from 'zod';
 
 /**
- * The names of the current L1 contract addresses.
+ * Required L1 contract address keys.
  * NOTE: When changing this list, make sure to update CLI & CI scripts accordingly.
  * For reference: https://github.com/AztecProtocol/aztec-packages/pull/5553
  */
-export const L1ContractsNames = [
+const REQUIRED_L1_CONTRACT_ADDRESS_KEYS = [
   'rollupAddress',
   'registryAddress',
   'inboxAddress',
@@ -23,102 +23,128 @@ export const L1ContractsNames = [
   'stakingAssetAddress',
 ] as const;
 
+/** Optional L1 contract address keys — present only in some deployments. */
+export const OPTIONAL_L1_CONTRACT_ADDRESS_KEYS = [
+  'feeAssetHandlerAddress',
+  'stakingAssetHandlerAddress',
+  'zkPassportVerifierAddress',
+  'gseAddress',
+  'dateGatedRelayerAddress',
+] as const;
+
+type RequiredContractKey = (typeof REQUIRED_L1_CONTRACT_ADDRESS_KEYS)[number];
+type OptionalContractKey = (typeof OPTIONAL_L1_CONTRACT_ADDRESS_KEYS)[number];
+
 /** Provides the directory of current L1 contract addresses */
 export type L1ContractAddresses = {
-  [K in (typeof L1ContractsNames)[number]]: EthAddress;
+  [K in RequiredContractKey]: EthAddress;
 } & {
-  slashFactoryAddress?: EthAddress | undefined;
-  feeAssetHandlerAddress?: EthAddress | undefined;
-  stakingAssetHandlerAddress?: EthAddress | undefined;
-  zkPassportVerifierAddress?: EthAddress | undefined;
-  gseAddress?: EthAddress | undefined;
-  dateGatedRelayerAddress?: EthAddress | undefined;
+  [K in OptionalContractKey]?: EthAddress;
 };
 
-export const L1ContractAddressesSchema = zodFor<L1ContractAddresses>()(
-  z.object({
-    rollupAddress: schemas.EthAddress,
-    registryAddress: schemas.EthAddress,
-    inboxAddress: schemas.EthAddress,
-    outboxAddress: schemas.EthAddress,
-    feeJuiceAddress: schemas.EthAddress,
-    stakingAssetAddress: schemas.EthAddress,
-    feeJuicePortalAddress: schemas.EthAddress,
-    coinIssuerAddress: schemas.EthAddress,
-    rewardDistributorAddress: schemas.EthAddress,
-    governanceProposerAddress: schemas.EthAddress,
-    governanceAddress: schemas.EthAddress,
-    slashFactoryAddress: schemas.EthAddress.optional(),
-    feeAssetHandlerAddress: schemas.EthAddress.optional(),
-    stakingAssetHandlerAddress: schemas.EthAddress.optional(),
-    zkPassportVerifierAddress: schemas.EthAddress.optional(),
-    gseAddress: schemas.EthAddress.optional(),
-    dateGatedRelayerAddress: schemas.EthAddress.optional(),
-  }),
-);
+/**
+ * Names of required L1 contract addresses.
+ * NOTE: When changing the set of contracts, update CLI & CI scripts accordingly.
+ * For reference: https://github.com/AztecProtocol/aztec-packages/pull/5553
+ */
+export const L1ContractsNames = REQUIRED_L1_CONTRACT_ADDRESS_KEYS;
 
 const parseEnv = (val: string) => EthAddress.fromString(val);
+const addrEnv = (description: string, env?: ConfigMapping<EthAddress>['env']): ConfigMapping<EthAddress> => ({
+  description,
+  parseEnv,
+  ...(env && { env }),
+});
 
-export const l1ContractAddressesMapping: ConfigMappingsType<
-  Omit<L1ContractAddresses, 'gseAddress' | 'zkPassportVerifierAddress' | 'dateGatedRelayerAddress'>
-> = {
-  registryAddress: {
-    env: 'REGISTRY_CONTRACT_ADDRESS',
-    description: 'The deployed L1 registry contract address.',
-    parseEnv,
-  },
-  slashFactoryAddress: {
-    env: 'SLASH_FACTORY_CONTRACT_ADDRESS',
-    description: 'The deployed L1 slashFactory contract address',
-    parseEnv,
-  },
-  feeAssetHandlerAddress: {
-    env: 'FEE_ASSET_HANDLER_CONTRACT_ADDRESS',
-    description: 'The deployed L1 feeAssetHandler contract address',
-    parseEnv,
-  },
-  rollupAddress: {
-    description: 'The deployed L1 rollup contract address.',
-    parseEnv,
-  },
-  inboxAddress: {
-    description: 'The deployed L1 inbox contract address.',
-    parseEnv,
-  },
-  outboxAddress: {
-    description: 'The deployed L1 outbox contract address.',
-    parseEnv,
-  },
-  feeJuiceAddress: {
-    description: 'The deployed L1 Fee Juice contract address.',
-    parseEnv,
-  },
-  stakingAssetAddress: {
-    description: 'The deployed L1 staking asset contract address.',
-    parseEnv,
-  },
-  feeJuicePortalAddress: {
-    description: 'The deployed L1 Fee Juice portal contract address.',
-    parseEnv,
-  },
-  coinIssuerAddress: {
-    description: 'The deployed L1 coinIssuer contract address',
-    parseEnv,
-  },
-  rewardDistributorAddress: {
-    description: 'The deployed L1 rewardDistributor contract address',
-    parseEnv,
-  },
-  governanceProposerAddress: {
-    description: 'The deployed L1 governanceProposer contract address',
-    parseEnv,
-  },
-  governanceAddress: {
-    description: 'The deployed L1 governance contract address',
-    parseEnv,
-  },
-  stakingAssetHandlerAddress: {
-    description: 'The deployed L1 stakingAssetHandler contract address',
-    parseEnv,
-  },
+/**
+ * Config mapping for all L1 contract addresses.
+ * This is the single source of truth for which contract addresses exist and how to parse them.
+ */
+export const l1ContractAddressesMapping: ConfigMappingsType<L1ContractAddresses> = {
+  rollupAddress: addrEnv('The deployed L1 rollup contract address.'),
+  registryAddress: addrEnv('The deployed L1 registry contract address.', 'REGISTRY_CONTRACT_ADDRESS'),
+  inboxAddress: addrEnv('The deployed L1 inbox contract address.'),
+  outboxAddress: addrEnv('The deployed L1 outbox contract address.'),
+  feeJuiceAddress: addrEnv('The deployed L1 Fee Juice contract address.'),
+  feeJuicePortalAddress: addrEnv('The deployed L1 Fee Juice portal contract address.'),
+  coinIssuerAddress: addrEnv('The deployed L1 coinIssuer contract address'),
+  rewardDistributorAddress: addrEnv('The deployed L1 rewardDistributor contract address'),
+  governanceProposerAddress: addrEnv('The deployed L1 governanceProposer contract address'),
+  governanceAddress: addrEnv('The deployed L1 governance contract address'),
+  stakingAssetAddress: addrEnv('The deployed L1 staking asset contract address.'),
+  feeAssetHandlerAddress: addrEnv(
+    'The deployed L1 feeAssetHandler contract address',
+    'FEE_ASSET_HANDLER_CONTRACT_ADDRESS',
+  ),
+  stakingAssetHandlerAddress: addrEnv('The deployed L1 stakingAssetHandler contract address'),
+  zkPassportVerifierAddress: addrEnv('The deployed L1 ZK passport verifier contract address'),
+  gseAddress: addrEnv('The deployed L1 GSE contract address'),
+  dateGatedRelayerAddress: addrEnv('The deployed L1 date-gated relayer contract address'),
 };
+
+/** Keys present in {@link l1ContractAddressesMapping}. */
+export type L1ContractAddressMappingKey = keyof typeof l1ContractAddressesMapping;
+
+type RequiredAddressShape = { [K in RequiredContractKey]: typeof schemas.EthAddress };
+type OptionalAddressShape = { [K in OptionalContractKey]: ReturnType<typeof schemas.EthAddress.optional> };
+
+export const L1ContractAddressesSchema = z.object({
+  ...(Object.fromEntries(REQUIRED_L1_CONTRACT_ADDRESS_KEYS.map(k => [k, schemas.EthAddress])) as RequiredAddressShape),
+  ...(Object.fromEntries(
+    OPTIONAL_L1_CONTRACT_ADDRESS_KEYS.map(k => [k, schemas.EthAddress.optional()]),
+  ) as OptionalAddressShape),
+});
+
+/**
+ * Selects entries from {@link l1ContractAddressesMapping} so composed configs can reuse the same
+ * env vars, descriptions, and parsers without duplicating definitions.
+ *
+ * @example
+ * ```ts
+ * const mappings = {
+ *   ...pickL1ContractAddressMappings('rollupAddress'),
+ *   nodeId: { ... },
+ * };
+ * ```
+ */
+export function pickL1ContractAddressMappings<const K extends readonly L1ContractAddressMappingKey[]>(
+  ...keys: K
+): Pick<typeof l1ContractAddressesMapping, K[number]> {
+  return Object.fromEntries(keys.map(key => [key, l1ContractAddressesMapping[key]] as const)) as Pick<
+    typeof l1ContractAddressesMapping,
+    K[number]
+  >;
+}
+
+/**
+ * Like {@link pickL1ContractAddressMappings}, but returns a fragment of {@link L1ContractAddressesSchema}'s shape for
+ * spreading into `z.object({ ...pickL1ContractAddressesSchemaShape('rollupAddress'), localField: z... })`.
+ */
+export function pickL1ContractAddressesSchema<const K extends readonly L1ContractAddressMappingKey[]>(
+  ...keys: K
+): Pick<typeof L1ContractAddressesSchema.shape, K[number]> {
+  return Object.fromEntries(keys.map(key => [key, L1ContractAddressesSchema.shape[key]])) as Pick<
+    typeof L1ContractAddressesSchema.shape,
+    K[number]
+  >;
+}
+
+/** Builds an {@link L1ContractAddresses} object from config that stores those fields at the top level. */
+export function pickL1ContractAddresses<T extends L1ContractAddresses>(config: T): L1ContractAddresses {
+  const result: Partial<L1ContractAddresses> = {};
+  for (const key of REQUIRED_L1_CONTRACT_ADDRESS_KEYS) {
+    result[key] = config[key];
+  }
+  for (const key of OPTIONAL_L1_CONTRACT_ADDRESS_KEYS) {
+    const v = config[key];
+    if (v !== undefined) {
+      result[key] = v;
+    }
+  }
+  return result as L1ContractAddresses;
+}
+
+export function randomL1ContractAddresses(includeOptional: boolean = false): L1ContractAddresses {
+  const keys = includeOptional ? [...L1ContractsNames, ...OPTIONAL_L1_CONTRACT_ADDRESS_KEYS] : L1ContractsNames;
+  return Object.fromEntries(keys.map(name => [name, EthAddress.random()])) as L1ContractAddresses;
+}

package/src/l1_reader.ts

@@ -8,29 +8,23 @@ import {
 import { type L1ContractAddresses, l1ContractAddressesMapping } from './l1_contract_addresses.js';
 
 /** Configuration of the L1GlobalReader. */
-export interface L1ReaderConfig {
+export type L1ReaderConfig = {
   /** List of URLs of Ethereum RPC nodes that services will connect to (comma separated). */
   l1RpcUrls: string[];
   /** The RPC Url of the ethereum debug host for trace and debug methods. */
   l1DebugRpcUrls: string[];
   /** The chain ID of the ethereum host. */
   l1ChainId: number;
-  /** The deployed l1 contract addresses */
-  l1Contracts: L1ContractAddresses;
   /** The polling interval viem uses in ms */
   viemPollingIntervalMS: number;
   /** Timeout for HTTP requests to the L1 RPC node in ms. */
   l1HttpTimeoutMS?: number;
-}
+} & L1ContractAddresses;
 
 export const l1ReaderConfigMappings: ConfigMappingsType<L1ReaderConfig> = {
-  l1Contracts: {
-    description: 'The deployed L1 contract addresses',
-    nested: l1ContractAddressesMapping,
-  },
   l1ChainId: {
     env: 'L1_CHAIN_ID',
-    parseEnv: (val: string) => +val,
+    ...optionalNumberConfigHelper(),
     description: 'The chain ID of the ethereum host.',
   },
   l1RpcUrls: {
@@ -55,6 +49,7 @@ export const l1ReaderConfigMappings: ConfigMappingsType<L1ReaderConfig> = {
     description: 'Timeout for HTTP requests to the L1 RPC node in ms.',
     ...optionalNumberConfigHelper(),
   },
+  ...l1ContractAddressesMapping,
 };
 
 export function getL1ReaderConfigFromEnv(): L1ReaderConfig {

package/src/l1_tx_utils/config.ts

@@ -73,7 +73,7 @@ export const l1TxUtilsConfigMappings: ConfigMappingsType<L1TxUtilsConfig> = {
   gasLimitBufferPercentage: {
     description: 'How much to increase calculated gas limit by (percentage)',
     env: 'L1_GAS_LIMIT_BUFFER_PERCENTAGE',
-    ...numberConfigHelper(20),
+    ...floatConfigHelper(20),
   },
   maxGwei: {
     description: 'Maximum gas price in gwei to be used for transactions.',
@@ -90,12 +90,12 @@ export const l1TxUtilsConfigMappings: ConfigMappingsType<L1TxUtilsConfig> = {
   priorityFeeBumpPercentage: {
     description: 'How much to increase priority fee by each attempt (percentage)',
     env: 'L1_PRIORITY_FEE_BUMP_PERCENTAGE',
-    ...numberConfigHelper(20),
+    ...floatConfigHelper(20),
   },
   priorityFeeRetryBumpPercentage: {
     description: 'How much to increase priority fee by each retry attempt (percentage)',
     env: 'L1_PRIORITY_FEE_RETRY_BUMP_PERCENTAGE',
-    ...numberConfigHelper(50),
+    ...floatConfigHelper(50),
   },
   minimumPriorityFeePerGas: {
     description:

package/src/l1_tx_utils/l1_tx_utils.ts

@@ -5,7 +5,7 @@ import { InterruptError, TimeoutError } from '@aztec/foundation/error';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { type Logger, type LoggerBindings, createLogger } from '@aztec/foundation/log';
 import { Semaphore } from '@aztec/foundation/queue';
-import { retryUntil } from '@aztec/foundation/retry';
+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';
@@ -44,6 +44,11 @@ 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 txs: L1TxState[] = [];
   /** Last nonce successfully sent to the chain. Used as a lower bound when a fallback RPC node returns a stale count. */
@@ -131,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;
   }
@@ -213,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)
@@ -225,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;
@@ -245,16 +272,7 @@ export class L1TxUtils extends ReadOnlyL1TxUtils {
 
       const gasPrice = await this.getGasPrice(gasConfig, !!blobInputs);
 
-      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()})`,
-        );
-      }
+      const now = await this.checkInterruptedOrTimedOut(gasConfig);
 
       let txHash: Hex;
       let nonce: number;
@@ -418,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();
@@ -654,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,
     };
 
@@ -670,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);
   }
 
   /**
@@ -693,9 +724,37 @@ export class L1TxUtils extends ReadOnlyL1TxUtils {
       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 },
@@ -704,18 +763,6 @@ export class L1TxUtils extends ReadOnlyL1TxUtils {
       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`,

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;
@@ -372,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: [
           {
@@ -384,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}`,
@@ -404,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 {

package/src/l1_tx_utils/tx_delayer.ts

@@ -81,7 +81,11 @@ export class Delayer {
 
   public maxInclusionTimeIntoSlot: number | undefined = undefined;
   public ethereumSlotDuration: bigint;
-  public nextWait: { l1Timestamp: bigint } | { l1BlockNumber: bigint } | { indefinitely: true } | undefined = undefined;
+  public nextWait:
+    | { l1Timestamp: bigint; timeoutSeconds?: number }
+    | { l1BlockNumber: bigint; timeoutSeconds?: number }
+    | { indefinitely: true }
+    | undefined = undefined;
   public sentTxHashes: Hex[] = [];
   public cancelledTxs: Hex[] = [];
 
@@ -110,13 +114,13 @@ export class Delayer {
   }
 
   /** Delays the next tx to be sent so it lands on the given L1 block number. */
-  pauseNextTxUntilBlock(l1BlockNumber: number | bigint) {
-    this.nextWait = { l1BlockNumber: BigInt(l1BlockNumber) };
+  pauseNextTxUntilBlock(l1BlockNumber: number | bigint, timeoutSeconds?: number) {
+    this.nextWait = { l1BlockNumber: BigInt(l1BlockNumber), timeoutSeconds };
   }
 
   /** Delays the next tx to be sent so it lands on the given timestamp. */
-  pauseNextTxUntilTimestamp(l1Timestamp: number | bigint) {
-    this.nextWait = { l1Timestamp: BigInt(l1Timestamp) };
+  pauseNextTxUntilTimestamp(l1Timestamp: number | bigint, timeoutSeconds?: number) {
+    this.nextWait = { l1Timestamp: BigInt(l1Timestamp), timeoutSeconds };
   }
 
   /** Delays the next tx to be sent indefinitely. */
@@ -198,9 +202,14 @@ export function wrapClientWithDelayer<T extends ViemClient>(client: T, delayer:
           // Or wait until the desired block number or timestamp
           wait =
             'l1BlockNumber' in waitUntil
-              ? waitUntilBlock(publicClient, waitUntil.l1BlockNumber - 1n, logger)
+              ? waitUntilBlock(publicClient, waitUntil.l1BlockNumber - 1n, logger, waitUntil.timeoutSeconds)
               : 'l1Timestamp' in waitUntil
-                ? waitUntilL1Timestamp(publicClient, waitUntil.l1Timestamp - delayer.ethereumSlotDuration, logger)
+                ? waitUntilL1Timestamp(
+                    publicClient,
+                    waitUntil.l1Timestamp - delayer.ethereumSlotDuration,
+                    logger,
+                    waitUntil.timeoutSeconds,
+                  )
                 : undefined;
 
           logger.info(`Delaying tx ${txHash} until ${inspect(waitUntil)}`, {