@aztec/end-to-end 0.0.1-commit.96dac018d → 0.0.1-commit.9a89641

package/src/fixtures/e2e_prover_test.ts

@@ -1,15 +1,10 @@
-import type { InitialAccountData } from '@aztec/accounts/testing';
-import { AztecNodeService } from '@aztec/aztec-node';
+import { type InitialAccountData, generateSchnorrAccounts } from '@aztec/accounts/testing';
+import { AztecNodeService, createAztecNodeService } from '@aztec/aztec-node';
 import { AztecAddress, EthAddress } from '@aztec/aztec.js/addresses';
-import { type Logger, createLogger } from '@aztec/aztec.js/log';
+import { createLogger } from '@aztec/aztec.js/log';
 import type { AztecNode } from '@aztec/aztec.js/node';
 import { CheatCodes } from '@aztec/aztec/testing';
-import {
-  BBCircuitVerifier,
-  type ClientProtocolCircuitVerifier,
-  QueuedIVCVerifier,
-  TestCircuitVerifier,
-} from '@aztec/bb-prover';
+import type { ClientProtocolCircuitVerifier } from '@aztec/bb-prover';
 import { BackendType, Barretenberg } from '@aztec/bb.js';
 import type { DeployAztecL1ContractsReturnType } from '@aztec/ethereum/deploy-aztec-l1-contracts';
 import { Buffer32 } from '@aztec/foundation/buffer';
@@ -24,19 +19,12 @@ import { type Hex, getContract } from 'viem';
 import { privateKeyToAddress } from 'viem/accounts';
 
 import { TokenSimulator } from '../simulators/token_simulator.js';
+import { SingleNodeTestContext, type SingleNodeTestOpts } from '../single-node/single_node_test_context.js';
 import { TestWallet } from '../test-wallet/test_wallet.js';
 import { getACVMConfig } from './get_acvm_config.js';
 import { getBBConfig } from './get_bb_config.js';
-import {
-  type EndToEndContext,
-  deployAccounts,
-  getPrivateKeyFromIndex,
-  getSponsoredFPCAddress,
-  publicDeployAccounts,
-  setup,
-  setupPXEAndGetWallet,
-  teardown,
-} from './setup.js';
+import { getPrivateKeyFromIndex, getSponsoredFPCAddress, setup, setupPXEAndGetWallet } from './setup.js';
+import { getStandardContractGenesisNullifiers } from './standard_contracts_genesis.js';
 
 type ProvenSetup = {
   wallet: TestWallet;
@@ -48,17 +36,21 @@ type ProvenSetup = {
  * However, we then setup a second PXE with a full prover instance.
  * We configure this instance with all of the accounts and contracts.
  * We then prove and verify transactions created via this full prover PXE.
+ *
+ * The real-prover sub-base of the single-node topology: extends {@link SingleNodeTestContext} so it
+ * reuses the base node tracking / chain monitor / teardown machinery, but builds its environment with
+ * the bespoke prover opts below (real BB, `realVerifier` L1, the snapshot/account + TokenSimulator
+ * harness, and a hand-built prover node) rather than the base's default fake-prover config.
  */
 
-export class FullProverTest {
+export class FullProverTest extends SingleNodeTestContext {
   static TOKEN_NAME = 'USDC';
   static TOKEN_SYMBOL = 'USD';
   static TOKEN_DECIMALS = 18n;
-  logger: Logger;
   wallet!: TestWallet;
   provenWallet!: TestWallet;
   accounts: AztecAddress[] = [];
-  deployedAccounts!: InitialAccountData[];
+  fundedAccounts!: InitialAccountData[];
   fakeProofsAsset!: TokenContract;
   fakeProofsAssetInstance!: ContractInstanceWithAddress;
   tokenSim!: TokenSimulator;
@@ -68,18 +60,23 @@ export class FullProverTest {
   private provenComponents: ProvenSetup[] = [];
   private bbConfigCleanup?: () => Promise<void>;
   private acvmConfigCleanup?: () => Promise<void>;
-  circuitProofVerifier?: ClientProtocolCircuitVerifier;
+  /** Returns the proof verifier from the prover node (for test assertions). */
+  get circuitProofVerifier(): ClientProtocolCircuitVerifier | undefined {
+    return this.proverAztecNode?.getProofVerifier();
+  }
   provenAsset!: TokenContract;
-  context!: EndToEndContext;
   private proverAztecNode!: AztecNodeService;
   private simulatedProverAztecNode!: AztecNodeService;
   public l1Contracts!: DeployAztecL1ContractsReturnType;
   public proverAddress!: EthAddress;
+  private testName: string;
   private minNumberOfTxsPerBlock: number;
   private coinbase: EthAddress;
   private realProofs: boolean;
 
   constructor(testName: string, minNumberOfTxsPerBlock: number, coinbase: EthAddress, realProofs = true) {
+    super();
+    this.testName = testName;
     this.logger = createLogger(`e2e:full_prover_test:${testName}`);
     this.minNumberOfTxsPerBlock = minNumberOfTxsPerBlock;
     this.coinbase = coinbase;
@@ -90,20 +87,13 @@ export class FullProverTest {
    * Applies base setup: deploys 2 accounts and token contract.
    */
   private async applyBaseSetup() {
-    this.logger.info('Applying base setup: deploying accounts');
-    const { deployedAccounts } = await deployAccounts(
-      2,
-      this.logger,
-    )({
-      wallet: this.context.wallet,
-      initialFundedAccounts: this.context.initialFundedAccounts,
-    });
-    this.deployedAccounts = deployedAccounts;
-    this.accounts = deployedAccounts.map(a => a.address);
+    this.logger.info('Applying base setup: registering funded accounts');
+    this.fundedAccounts = this.context.additionallyFundedAccounts;
+    this.accounts = this.fundedAccounts.map(a => a.address);
     this.wallet = this.context.wallet;
-
-    this.logger.info('Applying base setup: publicly deploying accounts');
-    await publicDeployAccounts(this.wallet, this.accounts.slice(0, 2));
+    for (const { secret, salt, signingKey } of this.fundedAccounts) {
+      await this.wallet.createSchnorrInitializerlessAccount(secret, salt, signingKey);
+    }
 
     this.logger.info('Applying base setup: deploying token contract');
     const { contract: asset, instance } = await TokenContract.deploy(
@@ -112,7 +102,7 @@ export class FullProverTest {
       FullProverTest.TOKEN_NAME,
       FullProverTest.TOKEN_SYMBOL,
       FullProverTest.TOKEN_DECIMALS,
-    ).send({ from: this.accounts[0], wait: { returnReceipt: true } });
+    ).send({ from: this.accounts[0] });
     this.logger.verbose(`Token deployed to ${asset.address}`);
 
     this.fakeProofsAsset = asset;
@@ -121,29 +111,33 @@ export class FullProverTest {
 
     this.tokenSim = new TokenSimulator(this.fakeProofsAsset, this.wallet, this.accounts[0], this.logger, this.accounts);
 
-    expect(await this.fakeProofsAsset.methods.get_admin().simulate({ from: this.accounts[0] })).toBe(
+    expect((await this.fakeProofsAsset.methods.get_admin().simulate({ from: this.accounts[0] })).result).toBe(
       this.accounts[0].toBigInt(),
     );
   }
 
-  async setup() {
+  override async setup(opts: SingleNodeTestOpts = {}) {
     this.logger.info('Setting up subsystems from fresh');
-    this.context = await setup(0, {
+    const context = await setup(0, {
+      ...opts,
       startProverNode: true,
       coinbase: this.coinbase,
       fundSponsoredFPC: true,
-      skipAccountDeployment: true,
+      additionallyFundedAccounts: await generateSchnorrAccounts(2),
       l1ContractsArgs: { realVerifier: this.realProofs },
     });
 
+    // Reuse the base context machinery (rollup, epoch cache, chain monitor, node tracking, teardown)
+    // over the environment built above. Restore the FullProverTest-named logger afterwards, since
+    // hydrateFromContext repoints `this.logger` at the context logger.
+    await this.hydrateFromContext(context);
+    this.logger = createLogger(`e2e:full_prover_test:${this.testName}`);
+
     await this.applyBaseSetup();
     await this.applyMint();
 
     this.logger.info(`Enabling proving`, { realProofs: this.realProofs });
 
-    // We don't wish to mark as proven automatically, so we set the flag to false
-    this.context.watcher.setIsMarkingAsProven(false);
-
     this.simulatedProverAztecNode = this.context.proverNode!;
     ({
       aztecNode: this.aztecNode,
@@ -168,9 +162,6 @@ export class FullProverTest {
 
       await Barretenberg.initSingleton({ backend: BackendType.NativeUnixSocket });
 
-      const verifier = await BBCircuitVerifier.new(bbConfig);
-      this.circuitProofVerifier = new QueuedIVCVerifier(bbConfig, verifier);
-
       this.logger.debug(`Configuring the node for real proofs...`);
       await this.aztecNodeAdmin.setConfig({
         realProofs: true,
@@ -178,7 +169,6 @@ export class FullProverTest {
       });
     } else {
       this.logger.debug(`Configuring the node min txs per block ${this.minNumberOfTxsPerBlock}...`);
-      this.circuitProofVerifier = new TestCircuitVerifier();
       await this.aztecNodeAdmin.setConfig({
         minTxsPerBlock: this.minNumberOfTxsPerBlock,
       });
@@ -193,6 +183,7 @@ export class FullProverTest {
     this.logger.verbose(`Main setup completed, initializing full prover PXE, Node, and Prover Node`);
     const { wallet: provenWallet, teardown: provenTeardown } = await setupPXEAndGetWallet(
       this.aztecNode,
+      this.context.aztecNode,
       { proverEnabled: this.realProofs },
       undefined,
       'pxe-proven',
@@ -201,8 +192,18 @@ export class FullProverTest {
     await provenWallet.registerContract(this.fakeProofsAssetInstance, TokenContract.artifact);
 
     for (let i = 0; i < 2; i++) {
-      await provenWallet.createSchnorrAccount(this.deployedAccounts[i].secret, this.deployedAccounts[i].salt);
-      await this.wallet.createSchnorrAccount(this.deployedAccounts[i].secret, this.deployedAccounts[i].salt);
+      // Mirror the initializerless funded accounts (created via createFundedAccounts) in both wallets so
+      // their addresses match the genesis-funded ones.
+      await provenWallet.createSchnorrInitializerlessAccount(
+        this.fundedAccounts[i].secret,
+        this.fundedAccounts[i].salt,
+        this.fundedAccounts[i].signingKey,
+      );
+      await this.wallet.createSchnorrInitializerlessAccount(
+        this.fundedAccounts[i].secret,
+        this.fundedAccounts[i].salt,
+        this.fundedAccounts[i].signingKey,
+      );
     }
 
     const asset = TokenContract.at(this.fakeProofsAsset.address, provenWallet);
@@ -229,11 +230,15 @@ export class FullProverTest {
 
     this.logger.verbose('Starting prover node');
     const sponsoredFPCAddress = await getSponsoredFPCAddress();
-    const { prefilledPublicData } = await getGenesisValues(
-      this.context.initialFundedAccounts.map(a => a.address).concat(sponsoredFPCAddress),
+    const { genesis } = await getGenesisValues(
+      this.context.additionallyFundedAccounts.map(a => a.address).concat(sponsoredFPCAddress),
+      undefined,
+      undefined,
+      this.context.genesis!.genesisTimestamp,
+      await getStandardContractGenesisNullifiers(),
     );
 
-    const proverNodeConfig: Parameters<typeof AztecNodeService.createAndSync>[0] = {
+    const proverNodeConfig: Parameters<typeof createAztecNodeService>[0] = {
       ...config,
       enableProverNode: true,
       disableValidator: true,
@@ -249,19 +254,24 @@ export class FullProverTest {
       txGatheringIntervalMs: 1000,
       txGatheringBatchSize: 10,
       txGatheringMaxParallelRequestsPerNode: 100,
-      txGatheringTimeoutMs: 24_000,
+      // The test warps the L1 clock forward a full epoch via cheatcodes; the prover-node
+      // tracks L1 time, so an in-flight tx-gather would see its deadline jump into the
+      // past. Use a generous window so the deadline survives the warp.
+      txGatheringTimeoutMs: 10 * 60 * 1000,
       proverNodeFailedEpochStore: undefined,
       proverNodeEpochProvingDelayMs: undefined,
       validatorPrivateKeys: new SecretValue([]),
     };
 
-    this.proverAztecNode = await AztecNodeService.createAndSync(
+    this.proverAztecNode = await createAztecNodeService(
       proverNodeConfig,
       { dateProvider: this.context.dateProvider, p2pClientDeps: { rpcTxProviders: [this.aztecNode] } },
-      { prefilledPublicData },
+      { genesis },
     );
+    // Track the real prover node so the base teardown stops it (the simulated one created by `setup`
+    // was already stopped above).
+    this.proverNodes = [this.proverAztecNode];
     this.logger.warn(`Proofs are now enabled`, { realProofs: this.realProofs });
-    return this;
   }
 
   private async mintFeeJuice(recipient: Hex) {
@@ -273,20 +283,22 @@ export class FullProverTest {
     await this.context.deployL1ContractsValues.l1Client.waitForTransactionReceipt({ hash });
   }
 
-  async teardown() {
+  override async teardown() {
     // Cleanup related to the full prover PXEs
     for (let i = 0; i < this.provenComponents.length; i++) {
       await this.provenComponents[i].teardown();
     }
 
-    // clean up the full prover node (by stopping its hosting aztec node)
+    // Stop the prover node before destroying the BB singleton it proves with.
     await this.proverAztecNode.stop();
 
     await Barretenberg.destroySingleton();
     await this.bbConfigCleanup?.();
     await this.acvmConfigCleanup?.();
 
-    await teardown(this.context);
+    // Stops the chain monitor, the tracked nodes (main node + the already-stopped prover node, a
+    // safe no-op), and the context.
+    await super.teardown();
   }
 
   private async applyMint() {
@@ -310,16 +322,20 @@ export class FullProverTest {
     } = this;
     tokenSim.mintPublic(address, publicAmount);
 
-    const publicBalance = await fakeProofsAsset.methods.balance_of_public(address).simulate({ from: address });
+    const { result: publicBalance } = await fakeProofsAsset.methods
+      .balance_of_public(address)
+      .simulate({ from: address });
     this.logger.verbose(`Public balance of wallet 0: ${publicBalance}`);
     expect(publicBalance).toEqual(this.tokenSim.balanceOfPublic(address));
 
     tokenSim.mintPrivate(address, publicAmount);
-    const privateBalance = await fakeProofsAsset.methods.balance_of_private(address).simulate({ from: address });
+    const { result: privateBalance } = await fakeProofsAsset.methods
+      .balance_of_private(address)
+      .simulate({ from: address });
     this.logger.verbose(`Private balance of wallet 0: ${privateBalance}`);
     expect(privateBalance).toEqual(tokenSim.balanceOfPrivate(address));
 
-    const totalSupply = await fakeProofsAsset.methods.total_supply().simulate({ from: address });
+    const { result: totalSupply } = await fakeProofsAsset.methods.total_supply().simulate({ from: address });
     this.logger.verbose(`Total supply: ${totalSupply}`);
     expect(totalSupply).toEqual(tokenSim.totalSupply);
   }

package/src/fixtures/fixtures.ts

@@ -1,5 +1,97 @@
+import type { AztecNode } from '@aztec/aztec.js/node';
+import { TEST_FEE_PADDING } from '@aztec/aztec/testing';
+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). Same multiplier and same class of problem as the published
+ * {@link TEST_FEE_PADDING}, re-exported under a name that captures the pipelining rationale.
+ */
+export const PIPELINED_FEE_PADDING = TEST_FEE_PADDING;
+
+/**
+ * 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: TEST_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;
@@ -21,6 +113,14 @@ export const TEST_PEER_CHECK_INTERVAL_MS = 1000;
 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');
 

package/src/fixtures/get_acvm_config.ts

@@ -7,13 +7,7 @@ import { promises as fs } from 'fs';
 
 export { deployAndInitializeTokenAndBridgeContracts } from '../shared/cross_chain_test_harness.js';
 
-const {
-  NOIR_RELEASE_DIR = 'noir-repo/target/release',
-  TEMP_DIR = '/tmp',
-  ACVM_BINARY_PATH = '',
-  ACVM_WORKING_DIRECTORY = '',
-  ACVM_FORCE_WASM = '',
-} = process.env;
+const { TEMP_DIR = '/tmp', ACVM_BINARY_PATH = '', ACVM_WORKING_DIRECTORY = '', ACVM_FORCE_WASM = '' } = process.env;
 
 // Determines if we have access to the acvm binary and a tmp folder for temp files
 export async function getACVMConfig(logger: Logger): Promise<
@@ -28,7 +22,7 @@ export async function getACVMConfig(logger: Logger): Promise<
     if (parseBooleanEnv(ACVM_FORCE_WASM)) {
       return undefined;
     }
-    const acvmBinaryPath = ACVM_BINARY_PATH ? ACVM_BINARY_PATH : `../../noir/${NOIR_RELEASE_DIR}/acvm`;
+    const acvmBinaryPath = ACVM_BINARY_PATH ? ACVM_BINARY_PATH : `../../labs-aztec-toolchain/bin/acvm`;
     await fs.access(acvmBinaryPath, fs.constants.R_OK);
     const tempWorkingDirectory = `${TEMP_DIR}/${randomBytes(4).toString('hex')}`;
     const acvmWorkingDirectory = ACVM_WORKING_DIRECTORY ? ACVM_WORKING_DIRECTORY : `${tempWorkingDirectory}/acvm`;

package/src/fixtures/get_bb_config.ts

@@ -8,13 +8,14 @@ import path from 'path';
 import { fileURLToPath } from 'url';
 
 const {
-  BB_RELEASE_DIR = 'barretenberg/cpp/build/bin',
   BB_BINARY_PATH,
   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 (
@@ -23,7 +24,7 @@ export const getBBConfig = async (
   try {
     const bbBinaryPath =
       BB_BINARY_PATH ??
-      path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../../../../', BB_RELEASE_DIR, 'bb-avm');
+      path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../../../../labs-aztec-toolchain/bin/bb-avm');
     await fs.access(bbBinaryPath, fs.constants.R_OK);
 
     let bbWorkingDirectory: string;
@@ -41,16 +42,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,15 +11,15 @@ 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 */
   haSigningEnabled: boolean;
   /** Polling interval in ms */
   pollingIntervalMs: number;
-  /** Signing timeout in ms */
-  signingTimeoutMs: 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;
 }
@@ -28,14 +28,16 @@ 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,
     nodeId,
     haSigningEnabled: true,
     pollingIntervalMs: 100,
-    signingTimeoutMs: 3000,
+    peerSigningTimeoutMs: 3000,
     maxStuckDutiesAgeMs: 72000,
   };
 }
@@ -52,6 +54,10 @@ export function setupHADatabase(databaseUrl: string, logger?: Logger): Pool {
     // 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;

package/src/fixtures/index.ts

@@ -3,4 +3,5 @@ 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/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());
+      },
+    };
+  }
+}