@aztec/end-to-end 0.0.1-commit.2448fdb → 0.0.1-commit.2606882

package/src/fixtures/elu_monitor.ts

@@ -0,0 +1,126 @@
+import { appendFileSync } from 'node:fs';
+import { type EventLoopUtilization, type IntervalHistogram, monitorEventLoopDelay, performance } from 'node:perf_hooks';
+
+const NANOS_PER_MS = 1_000_000;
+
+/** Samples event-loop utilization, delay histogram, and heap usage per test, writing columnar text to a file. */
+export class EluMonitor {
+  private filePath: string;
+  private intervalMs: number;
+  private timer: ReturnType<typeof setInterval> | undefined;
+  private lastELU: EventLoopUtilization | undefined;
+  private histogram: IntervalHistogram;
+  private testName: string | undefined;
+  private testStart: number | undefined;
+  private eluSamples: number[] = [];
+
+  constructor(filePath: string, intervalMs?: number) {
+    this.filePath = filePath;
+    this.intervalMs = intervalMs ?? 2000;
+    this.histogram = monitorEventLoopDelay({ resolution: 20 });
+  }
+
+  /** Begin sampling for a test. Writes a header line and starts the periodic sampler. */
+  startTest(testName: string): void {
+    this.stopTest();
+
+    this.testName = testName;
+    this.testStart = performance.now();
+    this.eluSamples = [];
+
+    appendFileSync(this.filePath, `\n=== Test: ${testName} ===\n`);
+    appendFileSync(
+      this.filePath,
+      padColumns('TIME', 'ELU', 'EL_DLY_P50', 'EL_DLY_P99', 'EL_DLY_MAX', 'HEAP_MB') + '\n',
+    );
+
+    this.lastELU = performance.eventLoopUtilization();
+    this.histogram.enable();
+
+    this.timer = setInterval(() => this.sample(), this.intervalMs);
+    // Allow the process to exit even if the timer is still running.
+    this.timer.unref();
+  }
+
+  /** Stop sampling and write a summary line. */
+  stopTest(): void {
+    if (!this.timer) {
+      return;
+    }
+
+    // Take a final sample before stopping.
+    this.sample();
+
+    clearInterval(this.timer);
+    this.timer = undefined;
+    this.histogram.disable();
+    this.histogram.reset();
+
+    this.writeSummary();
+
+    this.lastELU = undefined;
+    this.testName = undefined;
+    this.testStart = undefined;
+    this.eluSamples = [];
+  }
+
+  /** Alias for stopTest — call on process exit to flush any remaining data. */
+  stop(): void {
+    this.stopTest();
+  }
+
+  private sample(): void {
+    const newELU = performance.eventLoopUtilization();
+    const delta = performance.eventLoopUtilization(newELU, this.lastELU);
+    this.lastELU = newELU;
+
+    const elu = delta.utilization;
+    this.eluSamples.push(elu);
+
+    const p50 = this.histogram.percentile(50) / NANOS_PER_MS;
+    const p99 = this.histogram.percentile(99) / NANOS_PER_MS;
+    const max = this.histogram.max / NANOS_PER_MS;
+    const heapMb = Math.round(process.memoryUsage().heapUsed / (1024 * 1024));
+
+    const now = new Date();
+    const time = [now.getHours(), now.getMinutes(), now.getSeconds()].map(n => String(n).padStart(2, '0')).join(':');
+
+    const line = padColumns(
+      time,
+      elu.toFixed(2),
+      `${p50.toFixed(1)}ms`,
+      `${p99.toFixed(1)}ms`,
+      `${max.toFixed(1)}ms`,
+      String(heapMb),
+    );
+    appendFileSync(this.filePath, line + '\n');
+
+    // Reset histogram so next sample only reflects the new interval.
+    this.histogram.reset();
+  }
+
+  private writeSummary(): void {
+    if (this.eluSamples.length === 0 || this.testStart === undefined) {
+      return;
+    }
+
+    const mean = this.eluSamples.reduce((a, b) => a + b, 0) / this.eluSamples.length;
+    const maxElu = Math.max(...this.eluSamples);
+    const sorted = [...this.eluSamples].sort((a, b) => a - b);
+    const p90Elu = sorted[Math.floor(sorted.length * 0.9)] ?? maxElu;
+    const durationS = ((performance.now() - this.testStart) / 1000).toFixed(1);
+
+    let summary = `--- Summary: mean_elu=${mean.toFixed(2)} max_elu=${maxElu.toFixed(2)} p90_elu=${p90Elu.toFixed(2)} duration=${durationS}s`;
+    if (maxElu > 0.85) {
+      summary += ' WARNING:ELU>0.85';
+    }
+    summary += ' ---\n';
+
+    appendFileSync(this.filePath, summary);
+  }
+}
+
+function padColumns(...cols: string[]): string {
+  const widths = [11, 7, 12, 12, 12, 8];
+  return cols.map((col, i) => col.padEnd(widths[i] ?? 10)).join('');
+}

package/src/fixtures/fixtures.ts

@@ -1,5 +1,88 @@
+import type { AztecNode } from '@aztec/aztec.js/node';
+import type { GasFees } from '@aztec/stdlib/gas';
+
 export const METRICS_PORT = 4318;
 
+/** Default fee padding applied to predicted min fees in e2e tests. */
+export const DEFAULT_MIN_FEE_PADDING = 5;
+
+/**
+ * Large fee padding for txs that may be mined significantly later than when they were created,
+ * such as cloned txs in throughput/capacity benchmarks, where fees may spike between creation and mining.
+ */
+export const LARGE_MIN_FEE_PADDING = 15;
+
+/**
+ * Fee padding used by tests running under proposer pipelining. Under pipelining the fee-asset
+ * price modifier evolves faster across the build/publish gap, so client-set maxFeesPerGas (sized
+ * for the default 5x padding) was getting bumped past by the time the tx mined a few slots later.
+ * Observed worst case in CI: fee evolved ~20x between PXE snapshot and inclusion, exceeding even
+ * LARGE_MIN_FEE_PADDING (15x).
+ */
+export const PIPELINED_FEE_PADDING = 30;
+
+/**
+ * Setup option preset that opts a test into proposer pipelining. Use with `setup()`:
+ *
+ *     await setup(N, { ...PIPELINING_SETUP_OPTS, ...otherOpts });
+ *
+ * The preset sets:
+ * - `inboxLag: 2` so the sequencer sources L1->L2 messages from checkpoint N-1 (already sealed),
+ *   avoiding `L1ToL2MessagesNotReadyError` when building for slot N during slot N-1.
+ * - `minTxsPerBlock: 0` so empty checkpoints land even when a tx arrives late in the build window
+ *   (otherwise the chain stalls on alternating slots).
+ * - `aztecSlotDuration: 12` / `ethereumSlotDuration: 4` so the pipelined cycle fits inside the
+ *   default 300s Jest hook budget. Tests that depend on the env-default 72s/12s should override.
+ * - `walletMinFeePadding: PIPELINED_FEE_PADDING` (30x) to absorb the wider fee evolution window.
+ */
+export const PIPELINING_SETUP_OPTS = {
+  inboxLag: 2,
+  minTxsPerBlock: 0,
+  aztecSlotDuration: 12,
+  ethereumSlotDuration: 4,
+  walletMinFeePadding: PIPELINED_FEE_PADDING,
+} as const;
+
+/**
+ * Setup option preset that opts a test into the deterministic AutomineSequencer path.
+ * Use only for single-sequencer tests that don't exercise block-building or consensus
+ * (e.g. e2e_token, e2e_amm, e2e_authwit). Not compatible with `e2e_p2p/*`,
+ * `e2e_epochs/*`, `e2e_slashing/*`, `e2e_block_building`, or any multi-validator suite.
+ *
+ *     await setup(N, { ...AUTOMINE_E2E_OPTS, ...otherOpts });
+ *
+ * The preset:
+ * - Swaps the production Sequencer for an AutomineSequencer that builds one block per
+ *   submitted tx, publishes synchronously to L1, and owns all time control through a
+ *   serial queue (see `sequencer-client/src/sequencer/automine/automine_sequencer.ts`).
+ * - Disables the validator client and AnvilTestWatcher (the AutomineSequencer needs
+ *   neither).
+ * - Uses `inboxLag: 1` (synchronous) since the AutomineSequencer publishes one block per tx.
+ * - Switches anvil into automine mode at setup time (no interval mining); each L1 tx
+ *   mines an L1 block immediately.
+ *
+ * Requires `aztecTargetCommitteeSize: 0`, which is the e2e default at `setup.ts:317`.
+ */
+export const AUTOMINE_E2E_OPTS = {
+  useAutomineSequencer: true,
+  disableAnvilTestWatcher: true,
+  inboxLag: 1,
+  minTxsPerBlock: 0,
+  aztecSlotDuration: 12,
+  ethereumSlotDuration: 4,
+  walletMinFeePadding: PIPELINED_FEE_PADDING,
+} as const;
+
+/** Returns worst-case predicted min fees with padding applied, mirroring the BaseWallet pattern. */
+export async function getPaddedMaxFeesPerGas(node: AztecNode, padding = DEFAULT_MIN_FEE_PADDING): Promise<GasFees> {
+  const predicted = await node.getPredictedMinFees();
+  const worstCase =
+    predicted.length > 0
+      ? predicted.reduce((worst, fees) => (fees.feePerL2Gas > worst.feePerL2Gas ? fees : worst))
+      : await node.getCurrentMinFees();
+  return worstCase.mul(1 + padding);
+}
+
 export const shouldCollectMetrics = () => {
   if (process.env.COLLECT_METRICS) {
     return METRICS_PORT;

package/src/fixtures/get_bb_config.ts

@@ -13,8 +13,10 @@ const {
   BB_SKIP_CLEANUP = '',
   TEMP_DIR = tmpdir(),
   BB_WORKING_DIRECTORY = '',
-  BB_NUM_IVC_VERIFIERS = '1',
+  BB_NUM_IVC_VERIFIERS = '8',
   BB_IVC_CONCURRENCY = '1',
+  BB_CHONK_VERIFY_MAX_BATCH = '16',
+  BB_CHONK_VERIFY_BATCH_CONCURRENCY = '6',
 } = process.env;
 
 export const getBBConfig = async (
@@ -41,16 +43,15 @@ export const getBBConfig = async (
     const bbSkipCleanup = ['1', 'true'].includes(BB_SKIP_CLEANUP);
     const cleanup = bbSkipCleanup ? () => Promise.resolve() : () => tryRmDir(directoryToCleanup);
 
-    const numIvcVerifiers = Number(BB_NUM_IVC_VERIFIERS);
-    const ivcConcurrency = Number(BB_IVC_CONCURRENCY);
-
     return {
       bbSkipCleanup,
       bbBinaryPath,
       bbWorkingDirectory,
       cleanup,
-      numConcurrentIVCVerifiers: numIvcVerifiers,
-      bbIVCConcurrency: ivcConcurrency,
+      numConcurrentIVCVerifiers: Number(BB_NUM_IVC_VERIFIERS),
+      bbIVCConcurrency: Number(BB_IVC_CONCURRENCY),
+      bbChonkVerifyMaxBatch: Number(BB_CHONK_VERIFY_MAX_BATCH),
+      bbChonkVerifyConcurrency: Number(BB_CHONK_VERIFY_BATCH_CONCURRENCY),
     };
   } catch (err) {
     logger.error(`Native BB not available, error: ${err}`);

package/src/fixtures/ha_setup.ts

@@ -11,7 +11,7 @@ import { privateKeyToAccount } from 'viem/accounts';
  */
 export interface HADatabaseConfig {
   /** PostgreSQL connection URL */
-  databaseUrl: string;
+  databaseUrl: SecretValue<string>;
   /** Node ID for HA coordination */
   nodeId: string;
   /** Enable HA signing */
@@ -28,7 +28,9 @@ export interface HADatabaseConfig {
  * Get database configuration from environment variables
  */
 export function createHADatabaseConfig(nodeId: string): HADatabaseConfig {
-  const databaseUrl = process.env.DATABASE_URL || 'postgresql://aztec:aztec@localhost:5432/aztec_ha_test';
+  const databaseUrl = new SecretValue(
+    process.env.DATABASE_URL || 'postgresql://aztec:aztec@localhost:5432/aztec_ha_test',
+  );
 
   return {
     databaseUrl,

package/src/fixtures/schnorr_hardcoded_account_contract.ts

@@ -0,0 +1,49 @@
+import { DefaultAccountContract } from '@aztec/accounts/defaults';
+import type { ContractArtifact } from '@aztec/aztec.js/abi';
+import type { AuthWitnessProvider } from '@aztec/aztec.js/account';
+import type { CompleteAddress } from '@aztec/aztec.js/addresses';
+import { AuthWitness } from '@aztec/aztec.js/authorization';
+import type { Fr } from '@aztec/aztec.js/fields';
+import { Schnorr } from '@aztec/foundation/crypto/schnorr';
+import { GrumpkinScalar } from '@aztec/foundation/curves/grumpkin';
+import { SchnorrHardcodedAccountContractArtifact } from '@aztec/noir-contracts.js/SchnorrHardcodedAccount';
+
+/**
+ * The private key that matches the hardcoded public key in the SchnorrHardcodedAccountContract.
+ * The corresponding public key is baked into the Noir contract as a global constant.
+ */
+export const SCHNORR_HARDCODED_PRIVATE_KEY = GrumpkinScalar.fromHexString(
+  '0xd35d743ac0dfe3d6dbe6be8c877cb524a00ab1e3d52d7bada095dfc8894ccfa',
+);
+
+/**
+ * Account contract backed by the SchnorrHardcodedAccount Noir contract.
+ * This contract verifies Schnorr signatures against a public key that is hardcoded
+ * in the contract artifact (not stored in a note), so it does not require on-chain
+ * deployment or initialization. Useful for tests that need a working account without
+ * mining any blocks.
+ */
+export class SchnorrHardcodedKeyAccountContract extends DefaultAccountContract {
+  constructor(private privateKey: GrumpkinScalar = SCHNORR_HARDCODED_PRIVATE_KEY) {
+    super();
+  }
+
+  override getContractArtifact(): Promise<ContractArtifact> {
+    return Promise.resolve(SchnorrHardcodedAccountContractArtifact);
+  }
+
+  getInitializationFunctionAndArgs() {
+    return Promise.resolve(undefined);
+  }
+
+  getAuthWitnessProvider(_address: CompleteAddress): AuthWitnessProvider {
+    const privateKey = this.privateKey;
+    return {
+      async createAuthWit(messageHash: Fr): Promise<AuthWitness> {
+        const signer = new Schnorr();
+        const signature = await signer.constructSignature(messageHash, privateKey);
+        return new AuthWitness(messageHash, signature.toLimbFields());
+      },
+    };
+  }
+}