@aztec/end-to-end 0.0.1-commit.b655e406 → 0.0.1-commit.b8a057fa

package/src/fixtures/fixtures.ts

@@ -1,5 +1,95 @@
+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 runs the production Sequencer with the always-enforced timetable at real (wall-clock)
+ * timing, yielding exactly 2 blocks per slot. It 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.
+ * - `blockDurationMs: 3000` to cut exactly 2 blocks per slot. With `ethereumSlotDuration < 8` the
+ *   timing model normalizes to `init=0.5`, `assemble=0.5`, `P=0`, `minExec=1`, so
+ *   `maxBlocks = floor((S - init - (assemble + 2P + D)) / D) = floor((12 - 0.5 - (0.5 + 0 + 3)) / 3)
+ *   = floor(8/3) = 2`. (`blockDurationMs: 2000` would give 4 blocks/slot; 3000 also matches the
+ *   production default.)
+ * - `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,
+  blockDurationMs: 3000,
+  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 `p2p/*`,
+ * `multi-node/*`, `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 (the AutomineSequencer needs none).
+ * - Uses `inboxLag: 1` (synchronous) since the AutomineSequencer publishes one block per tx.
+ * - Runs anvil at a 4s interval (`ethereumSlotDuration: 4`); at runtime the AutomineSequencer
+ *   flips anvil into automine so each submitted tx mines its L1 block immediately. Initial L1
+ *   contract deployment (which runs before the sequencer starts) is mined immediately too via the
+ *   global `automineL1Setup` default in `setup()`, instead of stalling on the 4s interval.
+ *
+ * Requires `aztecTargetCommitteeSize: 0`, which is the e2e default at `setup.ts:317`.
+ */
+export const AUTOMINE_E2E_OPTS = {
+  useAutomineSequencer: 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;
@@ -7,10 +97,28 @@ export const shouldCollectMetrics = () => {
   return undefined;
 };
 
+/** Returns the boot node UDP port from environment variable or default value. */
+export function getBootNodeUdpPort(): number {
+  return process.env.BOOT_NODE_UDP_PORT ? parseInt(process.env.BOOT_NODE_UDP_PORT, 10) : 4500;
+}
+
+/** Returns the anvil port from environment variable or default value. */
+export function getAnvilPort(): number {
+  return process.env.ANVIL_PORT ? parseInt(process.env.ANVIL_PORT, 10) : 8545;
+}
+
 export const TEST_PEER_CHECK_INTERVAL_MS = 1000;
-export const TEST_MAX_TX_POOL_SIZE = 2 * 1024 * 1024 * 1024; // 2GB
+export const TEST_MAX_PENDING_TX_POOL_COUNT = 10_000; // Number of max pending TXs ~ 1.56GB
 
 export const MNEMONIC = 'test test test test test test test test test test test junk';
+
+// Mnemonic account index for tests that issue direct L1 writes (e.g. bridging fee juice) while a
+// sequencer is running. The deployer/sequencer publisher uses index 0, the prover index 2, and
+// validators index 3+. Test-side viem writes and the publisher's l1-tx-utils track nonces
+// independently, so sharing an account causes "replacement transaction underpriced" races; index 1
+// is otherwise unused, so issuing those writes from it keeps them off the publisher's nonce stream.
+export const L1_DIRECT_WRITE_ACCOUNT_INDEX = 1;
+
 export const privateKey = Buffer.from('ac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80', 'hex');
 export const privateKey2 = Buffer.from('59c6995e998f97a5a0044966f0945389dc9e86dae88c7a8412f4603b6b78690d', 'hex');
 
@@ -22,8 +130,5 @@ export const BITSIZE_TOO_BIG_ERROR = "Assertion failed: call to assert_max_bit_s
 export const DUPLICATE_NULLIFIER_ERROR = /dropped|nullifier|reverted/i;
 export const NO_L1_TO_L2_MSG_ERROR =
   /No non-nullified L1 to L2 message found for message hash|Tried to consume nonexistent L1-to-L2 message/;
-export const STATIC_CALL_STATE_MODIFICATION_ERROR =
-  /Static call cannot update the state, emit L2->L1 messages or generate logs.*/;
+export const STATIC_CALL_STATE_MODIFICATION_ERROR = /Static call cannot update the state.*/;
 export const STATIC_CONTEXT_ASSERTION_ERROR = /Assertion failed: Function .* can only be called statically.*/;
-
-export const DEFAULT_BLOB_SINK_PORT = '5052';

package/src/fixtures/get_acvm_config.ts

@@ -1,6 +1,6 @@
 import type { Logger } from '@aztec/aztec.js/log';
 import { parseBooleanEnv } from '@aztec/foundation/config';
-import { randomBytes } from '@aztec/foundation/crypto';
+import { randomBytes } from '@aztec/foundation/crypto/random';
 import { tryRmDir } from '@aztec/foundation/fs';
 
 import { promises as fs } from 'fs';

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

@@ -0,0 +1,192 @@
+import { EthAddress } from '@aztec/aztec.js/addresses';
+import { Fr } from '@aztec/aztec.js/fields';
+import type { Logger } from '@aztec/aztec.js/log';
+import { SecretValue } from '@aztec/foundation/config';
+
+import { Pool } from 'pg';
+import { privateKeyToAccount } from 'viem/accounts';
+
+/**
+ * Configuration for HA database connection
+ */
+export interface HADatabaseConfig {
+  /** PostgreSQL connection URL */
+  databaseUrl: SecretValue<string>;
+  /** Node ID for HA coordination */
+  nodeId: string;
+  /** Enable HA signing */
+  haSigningEnabled: boolean;
+  /** Polling interval in ms */
+  pollingIntervalMs: number;
+  /** How long to wait for a peer node's in-progress signing in ms */
+  peerSigningTimeoutMs: number;
+  /** Max stuck duties age in ms */
+  maxStuckDutiesAgeMs: number;
+}
+
+/**
+ * Get database configuration from environment variables
+ */
+export function createHADatabaseConfig(nodeId: string): HADatabaseConfig {
+  const databaseUrl = new SecretValue(
+    process.env.DATABASE_URL || 'postgresql://aztec:aztec@localhost:5432/aztec_ha_test',
+  );
+
+  return {
+    databaseUrl,
+    nodeId,
+    haSigningEnabled: true,
+    pollingIntervalMs: 100,
+    peerSigningTimeoutMs: 3000,
+    maxStuckDutiesAgeMs: 72000,
+  };
+}
+
+/**
+ * Setup PostgreSQL database connection pool for HA tests
+ *
+ * Note: Database migrations should be run separately before starting tests,
+ * either via docker-compose entrypoint or manually with: aztec migrate-ha-db up
+ */
+export function setupHADatabase(databaseUrl: string, logger?: Logger): Pool {
+  try {
+    // Create connection pool for test usage
+    // Migrations are already run by docker-compose entrypoint before tests start
+    const pool = new Pool({ connectionString: databaseUrl });
+
+    // pg-pool re-emits idle-client errors on the pool; with no listener the emit throws - in production this crashes
+    // the validator process.
+    pool.on('error', (err: Error) => logger?.warn(`HA database pool error: ${err.message}`));
+
+    logger?.info('Connected to HA database (migrations should already be applied)');
+
+    return pool;
+  } catch (error) {
+    logger?.error(`Failed to connect to HA database: ${error}`);
+    throw error;
+  }
+}
+
+/**
+ * Clean up HA database - drop all tables
+ * Use this between tests to ensure clean state
+ */
+export async function cleanupHADatabase(pool: Pool, logger?: Logger): Promise<void> {
+  try {
+    // Drop all HA tables
+    await pool.query('DROP TABLE IF EXISTS validator_duties CASCADE');
+    await pool.query('DROP TABLE IF EXISTS schema_version CASCADE');
+    // Drop migration tracking table (node-pg-migrate uses 'pgmigrations' by default)
+    // This ensures migrations will run fresh on next startup
+    await pool.query('DROP TABLE IF EXISTS pgmigrations CASCADE');
+
+    logger?.info('HA database cleaned up successfully');
+  } catch (error) {
+    logger?.error(`Failed to cleanup HA database: ${error}`);
+    throw error;
+  }
+}
+
+/**
+ * Query validator duties from the database
+ */
+export async function getValidatorDuties(
+  pool: Pool,
+  slot: bigint,
+  dutyType?: 'ATTESTATION' | 'BLOCK_PROPOSAL' | 'GOVERNANCE_VOTE' | 'SLASHING_VOTE',
+): Promise<
+  Array<{
+    slot: string;
+    dutyType: string;
+    validatorAddress: string;
+    nodeId: string;
+    startedAt: Date;
+    completedAt: Date | undefined;
+  }>
+> {
+  const query = dutyType
+    ? 'SELECT slot, duty_type, validator_address, node_id, started_at, completed_at FROM validator_duties WHERE slot = $1 AND duty_type = $2 ORDER BY started_at'
+    : 'SELECT slot, duty_type, validator_address, node_id, started_at, completed_at FROM validator_duties WHERE slot = $1 ORDER BY started_at';
+
+  const params = dutyType ? [slot.toString(), dutyType] : [slot.toString()];
+
+  const result = await pool.query<{
+    slot: string;
+    duty_type: string;
+    validator_address: string;
+    node_id: string;
+    started_at: Date;
+    completed_at: Date | undefined;
+  }>(query, params);
+
+  return result.rows.map(row => ({
+    slot: row.slot,
+    dutyType: row.duty_type,
+    validatorAddress: row.validator_address,
+    nodeId: row.node_id,
+    startedAt: row.started_at,
+    completedAt: row.completed_at,
+  }));
+}
+
+/**
+ * Convert private keys to Ethereum addresses
+ */
+export function getAddressesFromPrivateKeys(privateKeys: `0x${string}`[]): string[] {
+  return privateKeys.map(pk => {
+    const account = privateKeyToAccount(pk);
+    return account.address;
+  });
+}
+
+/**
+ * Create initial validators from private keys for L1 contract deployment
+ */
+export function createInitialValidatorsFromPrivateKeys(attesterPrivateKeys: `0x${string}`[]): Array<{
+  attester: EthAddress;
+  withdrawer: EthAddress;
+  privateKey: `0x${string}`;
+  bn254SecretKey: SecretValue<bigint>;
+}> {
+  return attesterPrivateKeys.map(pk => {
+    const account = privateKeyToAccount(pk);
+    return {
+      attester: EthAddress.fromString(account.address),
+      withdrawer: EthAddress.fromString(account.address),
+      privateKey: pk,
+      bn254SecretKey: new SecretValue(Fr.random().toBigInt()),
+    };
+  });
+}
+
+/**
+ * Verify no duplicate attestations per validator (HA coordination check)
+ * Groups duties by validator address and verifies each validator attested exactly once
+ */
+export function verifyNoDuplicateAttestations(
+  attestationDuties: Array<{
+    validatorAddress: string;
+    nodeId: string;
+    completedAt: Date | undefined;
+  }>,
+  logger?: Logger,
+): Map<string, typeof attestationDuties> {
+  const dutiesByValidator = new Map<string, typeof attestationDuties>();
+  for (const duty of attestationDuties) {
+    const existing = dutiesByValidator.get(duty.validatorAddress) || [];
+    existing.push(duty);
+    dutiesByValidator.set(duty.validatorAddress, existing);
+  }
+
+  for (const [validatorAddress, validatorDuties] of dutiesByValidator.entries()) {
+    if (validatorDuties.length !== 1) {
+      throw new Error(`Validator ${validatorAddress} attested ${validatorDuties.length} times (expected exactly once)`);
+    }
+    if (!validatorDuties[0].completedAt) {
+      throw new Error(`Validator ${validatorAddress} attestation duty not completed`);
+    }
+    logger?.info(`Validator ${validatorAddress} attested once via node ${validatorDuties[0].nodeId}`);
+  }
+
+  return dutiesByValidator;
+}

package/src/fixtures/index.ts

@@ -1,5 +1,7 @@
 export * from './fixtures.js';
+export * from './ha_setup.js';
 export * from './logging.js';
 export * from './utils.js';
 export * from './token_utils.js';
+export * from './wait_helpers.js';
 export * from './with_telemetry_utils.js';

package/src/fixtures/l1_to_l2_messaging.ts

@@ -1,5 +1,7 @@
-import { type ExtendedViemWalletClient, type L1ContractAddresses, RollupContract } from '@aztec/ethereum';
-import { Fr } from '@aztec/foundation/fields';
+import { RollupContract } from '@aztec/ethereum/contracts';
+import type { L1ContractAddresses } from '@aztec/ethereum/l1-contract-addresses';
+import type { ExtendedViemWalletClient } from '@aztec/ethereum/types';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { tryJsonStringify } from '@aztec/foundation/json-rpc';
 import { InboxAbi } from '@aztec/l1-artifacts';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';

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());
+      },
+    };
+  }
+}