@aztec/ethereum 0.0.1-commit.a5db02d → 0.0.1-commit.aa0c64f

package/src/l1_tx_utils/l1_tx_utils.ts

@@ -36,6 +36,7 @@ import {
   type L1TxConfig,
   type L1TxRequest,
   type L1TxState,
+  L1TxTimeoutError,
   type SigningCallback,
   TerminalTxUtilsState,
   TxUtilsState,
@@ -306,6 +307,7 @@ export class L1TxUtils extends ReadOnlyL1TxUtils {
         txConfigOverrides: gasConfigOverrides ?? {},
         sentAtL1Ts: now,
         lastSentAtL1Ts: now,
+        gasPriceHistory: [baseState.gasPrice],
       };
 
       // And persist it
@@ -504,6 +506,7 @@ export class L1TxUtils extends ReadOnlyL1TxUtils {
         if (timePassed >= stallTimeMs && attempts <= maxSpeedUpAttempts) {
           const newGasPrice = await this.getGasPrice(gasConfig, isBlobTx, attempts, state.gasPrice);
           state.gasPrice = newGasPrice;
+          state.gasPriceHistory?.push(newGasPrice);
 
           this.logger.debug(
             `Tx ${currentTxHash} with nonce ${nonce} from ${account} appears stuck. ` +
@@ -672,8 +675,22 @@ export class L1TxUtils extends ReadOnlyL1TxUtils {
     blobInputs?: L1BlobInputs,
   ): Promise<{ receipt: TransactionReceipt; state: L1TxState }> {
     const { state } = await this.sendTransaction(request, gasConfig, blobInputs);
-    const receipt = await this.monitorTransaction(state);
-    return { receipt, state };
+    try {
+      const receipt = await this.monitorTransaction(state);
+      return { receipt, state };
+    } catch (err) {
+      if (err instanceof TimeoutError) {
+        // Snapshot the ladder now: the fire-and-forget cancellation mutates state.gasPrice moments later.
+        throw new L1TxTimeoutError(err.message, {
+          gasPriceHistory: state.gasPriceHistory ? [...state.gasPriceHistory] : undefined,
+          finalGasPrice: state.gasPrice,
+          attempts: state.txHashes.length,
+          nonce: state.nonce,
+          gasLimit: state.gasLimit,
+        });
+      }
+      throw err;
+    }
   }
 
   public override async simulate(

package/src/l1_tx_utils/types.ts

@@ -1,4 +1,5 @@
 import type { BlobKzgInstance } from '@aztec/blob-lib/types';
+import { TimeoutError } from '@aztec/foundation/error';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import type { ViemTransactionSignature } from '@aztec/foundation/eth-signature';
 
@@ -55,6 +56,12 @@ export type L1TxState = {
   cancelTxHashes: Hex[];
   gasLimit: bigint;
   gasPrice: GasPrice;
+  /**
+   * Prices used for each attempt (initial send followed by each speed-up), in order. Always set on
+   * newly sent txs; optional because states restored from the state store predate the field.
+   * In-memory only — not persisted by the state store.
+   */
+  gasPriceHistory?: GasPrice[];
   txConfigOverrides: L1TxConfig;
   request: L1TxRequest;
   status: TxUtilsState;
@@ -83,3 +90,28 @@ export class DroppedTransactionError extends Error {
     this.name = 'DroppedTransactionError';
   }
 }
+
+/** Snapshot of what a timed-out L1 tx tried to pay, taken when the timeout is raised. */
+export type TimedOutTxState = {
+  /** Prices used across the initial send and each speed-up, in order (undefined only for restored states). */
+  gasPriceHistory?: GasPrice[];
+  /** The last price the tx was sent at before timing out. */
+  finalGasPrice: GasPrice;
+  /** Number of send attempts (initial + speed-ups). */
+  attempts: number;
+  nonce: number;
+  gasLimit: bigint;
+};
+
+/**
+ * Thrown by sendAndMonitorTransaction when a tx times out. Subclasses TimeoutError so existing
+ * `instanceof TimeoutError` checks keep working, while carrying the gas-price ladder for diagnostics.
+ */
+export class L1TxTimeoutError extends TimeoutError {
+  constructor(
+    message: string,
+    public readonly txState: TimedOutTxState,
+  ) {
+    super(message);
+  }
+}

package/src/queries.ts

@@ -186,5 +186,11 @@ export async function getL1ContractsConfig(
     slashAmountMedium: slashingAmounts[1],
     slashAmountLarge: slashingAmounts[2],
     initialEthPerFeeAsset: DefaultL1ContractsConfig.initialEthPerFeeAsset,
+    // Not exposed by the rollup contract; fall back to defaults like the other non-on-chain fields above.
+    entryQueueBootstrapValidatorSetSize: DefaultL1ContractsConfig.entryQueueBootstrapValidatorSetSize,
+    entryQueueBootstrapFlushSize: DefaultL1ContractsConfig.entryQueueBootstrapFlushSize,
+    entryQueueFlushSizeMin: DefaultL1ContractsConfig.entryQueueFlushSizeMin,
+    entryQueueFlushSizeQuotient: DefaultL1ContractsConfig.entryQueueFlushSizeQuotient,
+    entryQueueMaxFlushSize: DefaultL1ContractsConfig.entryQueueMaxFlushSize,
   };
 }

package/src/test/eth_cheat_codes.ts

@@ -505,19 +505,40 @@ export class EthCheatCodes {
    * reorg is needed because anvil applies a new gas limit only to future blocks: without it the just-mined
    * blocks would keep the tiny gas limit, and an `eth_call` against `latest` (whose gas is capped by the
    * block gas limit) would revert with "intrinsic gas too high".
+   *
+   * The replacement blocks advance L1 time. `anvil_reorg` stamps each replacement as `parent + N*interval`,
+   * so on its own it would freeze L1 time at the parent timestamp; callers that measure elapsed L1 time
+   * (L1TxUtils stall/timeout detection, `syncDateProvider`-driven slot advancement) rely on it moving
+   * forward. We reproduce the wall-clock advance the mine step just made (at least 1s per block) via a
+   * temporary block-timestamp interval, then restore any pre-existing interval.
    */
   public async mineEmptyBlock(blockCount: number = 1): Promise<void> {
     await this.execWithPausedAnvil(async () => {
       const originalGasLimit = await this.getBlockGasLimit();
+      const parentTimestamp = await this.lastBlockTimestamp();
+      // anvil has no getter for the block-timestamp interval, but the pending block is stamped
+      // `latest + interval`, so this delta is the standing interval (0 when none is set).
+      const priorInterval = (await this.nextBlockTimestamp()) - parentTimestamp;
       try {
         await this.setBlockGasLimit(1n);
         await this.doMine(blockCount);
       } finally {
         await this.setBlockGasLimit(originalGasLimit);
       }
+      const advance = (await this.lastBlockTimestamp()) - parentTimestamp;
+      const perBlockInterval = Math.max(1, Math.floor(advance / blockCount));
       // Replace the tiny-gas-limit blocks with empty blocks at the restored gas limit, keeping the same
-      // height and timestamps. The reorged-out blocks held no transactions, so nothing returns to the pool.
-      await this.doRpcCall('anvil_reorg', [blockCount, []]);
+      // height. The reorged-out blocks held no transactions, so nothing returns to the pool.
+      await this.doRpcCall('anvil_setBlockTimestampInterval', [perBlockInterval]);
+      try {
+        await this.doRpcCall('anvil_reorg', [blockCount, []]);
+      } finally {
+        if (priorInterval > 0) {
+          await this.doRpcCall('anvil_setBlockTimestampInterval', [priorInterval]);
+        } else {
+          await this.doRpcCall('anvil_removeBlockTimestampInterval', []);
+        }
+      }
     });
 
     this.logger.warn(`Mined ${blockCount} empty L1 ${pluralize('block', blockCount)}`);

package/src/utils.ts

@@ -235,18 +235,18 @@ export function formatViemError(error: any, abi: Abi = ErrorsAbi): FormattedViem
     // If decoding fails, we fall back to the original formatting
   }
 
-  // Strip ABI from the error object before formatting. We clone first to avoid mutating the
-  // caller's error, but structuredClone throws DataCloneError on values it cannot clone (e.g.
-  // viem RPC errors carrying function-valued request context). If cloning fails, fall back to
-  // formatting the original error untouched rather than letting the clone failure mask it.
+  // Strip ABI from the error object before formatting
   if (error && typeof error === 'object') {
-    try {
-      const errorClone = structuredClone(error);
-      stripAbis(errorClone);
-      error = errorClone;
-    } catch {
-      // Leave `error` as the original; we skip stripAbis to avoid mutating the caller's object.
-    }
+    // Create a clone to avoid modifying the original
+    const errorClone = structuredClone(error);
+
+    // Helper function to recursively remove ABI properties
+
+    // Strip ABIs from the clone
+    stripAbis(errorClone);
+
+    // Use the cleaned clone for further processing
+    error = errorClone;
   }
 
   // If it's a regular Error instance, return it with its message

package/dest/generated/l1-contracts-defaults.d.ts

@@ -1,30 +0,0 @@
-/** Default L1 contracts configuration values from network-defaults.yml */
-export declare const l1ContractsDefaultEnv: {
-    readonly ETHEREUM_SLOT_DURATION: 12;
-    readonly AZTEC_SLOT_DURATION: 72;
-    readonly AZTEC_EPOCH_DURATION: 32;
-    readonly AZTEC_TARGET_COMMITTEE_SIZE: 48;
-    readonly AZTEC_LAG_IN_EPOCHS_FOR_VALIDATOR_SET: 2;
-    readonly AZTEC_LAG_IN_EPOCHS_FOR_RANDAO: 2;
-    readonly AZTEC_ACTIVATION_THRESHOLD: 100000000000000000000;
-    readonly AZTEC_EJECTION_THRESHOLD: 50000000000000000000;
-    readonly AZTEC_LOCAL_EJECTION_THRESHOLD: 98000000000000000000;
-    readonly AZTEC_EXIT_DELAY_SECONDS: 172800;
-    readonly AZTEC_INBOX_LAG: 2;
-    readonly AZTEC_PROOF_SUBMISSION_EPOCHS: 1;
-    readonly AZTEC_MANA_TARGET: 100000000;
-    readonly AZTEC_PROVING_COST_PER_MANA: 100;
-    readonly AZTEC_INITIAL_ETH_PER_FEE_ASSET: 10000000;
-    readonly AZTEC_SLASHER_ENABLED: true;
-    readonly AZTEC_SLASHING_ROUND_SIZE_IN_EPOCHS: 4;
-    readonly AZTEC_SLASHING_LIFETIME_IN_ROUNDS: 5;
-    readonly AZTEC_SLASHING_EXECUTION_DELAY_IN_ROUNDS: 0;
-    readonly AZTEC_SLASHING_OFFSET_IN_ROUNDS: 2;
-    readonly AZTEC_SLASHING_VETOER: "0x0000000000000000000000000000000000000000";
-    readonly AZTEC_SLASHING_DISABLE_DURATION: 432000;
-    readonly AZTEC_SLASH_AMOUNT_SMALL: 10000000000000000000;
-    readonly AZTEC_SLASH_AMOUNT_MEDIUM: 20000000000000000000;
-    readonly AZTEC_SLASH_AMOUNT_LARGE: 50000000000000000000;
-    readonly AZTEC_GOVERNANCE_PROPOSER_ROUND_SIZE: 300;
-};
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibDEtY29udHJhY3RzLWRlZmF1bHRzLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvZ2VuZXJhdGVkL2wxLWNvbnRyYWN0cy1kZWZhdWx0cy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFHQSwwRUFBMEU7QUFDMUUsZUFBTyxNQUFNLHFCQUFxQjs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0NBMkJ4QixDQUFDIn0=

package/dest/generated/l1-contracts-defaults.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"l1-contracts-defaults.d.ts","sourceRoot":"","sources":["../../src/generated/l1-contracts-defaults.ts"],"names":[],"mappings":"AAGA,0EAA0E;AAC1E,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2BxB,CAAC"}

package/dest/generated/l1-contracts-defaults.js

@@ -1,30 +0,0 @@
-// Auto-generated from spartan/environments/network-defaults.yml
-// Do not edit manually - run yarn generate to regenerate
-/** Default L1 contracts configuration values from network-defaults.yml */ export const l1ContractsDefaultEnv = {
-    ETHEREUM_SLOT_DURATION: 12,
-    AZTEC_SLOT_DURATION: 72,
-    AZTEC_EPOCH_DURATION: 32,
-    AZTEC_TARGET_COMMITTEE_SIZE: 48,
-    AZTEC_LAG_IN_EPOCHS_FOR_VALIDATOR_SET: 2,
-    AZTEC_LAG_IN_EPOCHS_FOR_RANDAO: 2,
-    AZTEC_ACTIVATION_THRESHOLD: 100000000000000000000,
-    AZTEC_EJECTION_THRESHOLD: 50000000000000000000,
-    AZTEC_LOCAL_EJECTION_THRESHOLD: 98000000000000000000,
-    AZTEC_EXIT_DELAY_SECONDS: 172800,
-    AZTEC_INBOX_LAG: 2,
-    AZTEC_PROOF_SUBMISSION_EPOCHS: 1,
-    AZTEC_MANA_TARGET: 100000000,
-    AZTEC_PROVING_COST_PER_MANA: 100,
-    AZTEC_INITIAL_ETH_PER_FEE_ASSET: 10000000,
-    AZTEC_SLASHER_ENABLED: true,
-    AZTEC_SLASHING_ROUND_SIZE_IN_EPOCHS: 4,
-    AZTEC_SLASHING_LIFETIME_IN_ROUNDS: 5,
-    AZTEC_SLASHING_EXECUTION_DELAY_IN_ROUNDS: 0,
-    AZTEC_SLASHING_OFFSET_IN_ROUNDS: 2,
-    AZTEC_SLASHING_VETOER: '0x0000000000000000000000000000000000000000',
-    AZTEC_SLASHING_DISABLE_DURATION: 432000,
-    AZTEC_SLASH_AMOUNT_SMALL: 10000000000000000000,
-    AZTEC_SLASH_AMOUNT_MEDIUM: 20000000000000000000,
-    AZTEC_SLASH_AMOUNT_LARGE: 50000000000000000000,
-    AZTEC_GOVERNANCE_PROPOSER_ROUND_SIZE: 300
-};

package/src/generated/l1-contracts-defaults.ts

@@ -1,32 +0,0 @@
-// Auto-generated from spartan/environments/network-defaults.yml
-// Do not edit manually - run yarn generate to regenerate
-
-/** Default L1 contracts configuration values from network-defaults.yml */
-export const l1ContractsDefaultEnv = {
-  ETHEREUM_SLOT_DURATION: 12,
-  AZTEC_SLOT_DURATION: 72,
-  AZTEC_EPOCH_DURATION: 32,
-  AZTEC_TARGET_COMMITTEE_SIZE: 48,
-  AZTEC_LAG_IN_EPOCHS_FOR_VALIDATOR_SET: 2,
-  AZTEC_LAG_IN_EPOCHS_FOR_RANDAO: 2,
-  AZTEC_ACTIVATION_THRESHOLD: 100000000000000000000,
-  AZTEC_EJECTION_THRESHOLD: 50000000000000000000,
-  AZTEC_LOCAL_EJECTION_THRESHOLD: 98000000000000000000,
-  AZTEC_EXIT_DELAY_SECONDS: 172800,
-  AZTEC_INBOX_LAG: 2,
-  AZTEC_PROOF_SUBMISSION_EPOCHS: 1,
-  AZTEC_MANA_TARGET: 100000000,
-  AZTEC_PROVING_COST_PER_MANA: 100,
-  AZTEC_INITIAL_ETH_PER_FEE_ASSET: 10000000,
-  AZTEC_SLASHER_ENABLED: true,
-  AZTEC_SLASHING_ROUND_SIZE_IN_EPOCHS: 4,
-  AZTEC_SLASHING_LIFETIME_IN_ROUNDS: 5,
-  AZTEC_SLASHING_EXECUTION_DELAY_IN_ROUNDS: 0,
-  AZTEC_SLASHING_OFFSET_IN_ROUNDS: 2,
-  AZTEC_SLASHING_VETOER: '0x0000000000000000000000000000000000000000',
-  AZTEC_SLASHING_DISABLE_DURATION: 432000,
-  AZTEC_SLASH_AMOUNT_SMALL: 10000000000000000000,
-  AZTEC_SLASH_AMOUNT_MEDIUM: 20000000000000000000,
-  AZTEC_SLASH_AMOUNT_LARGE: 50000000000000000000,
-  AZTEC_GOVERNANCE_PROPOSER_ROUND_SIZE: 300,
-} as const;