@aztec/end-to-end 0.0.1-commit.04852196a → 0.0.1-commit.04d373f

package/src/e2e_p2p/reqresp/utils.ts

@@ -14,7 +14,7 @@ import path from 'path';
 
 import { getBootNodeUdpPort, shouldCollectMetrics } from '../../fixtures/fixtures.js';
 import { createNodes } from '../../fixtures/setup_p2p_test.js';
-import { P2PNetworkTest, WAIT_FOR_TX_TIMEOUT } from '../p2p_network.js';
+import { P2PNetworkTest } from '../p2p_network.js';
 import { prepareTransactions } from '../shared.js';
 
 // Don't set this to a higher value than 9 because each node will use a different L1 publisher account and anvil seeds
@@ -49,6 +49,10 @@ export async function createReqrespTest(options: ReqrespOptions = {}): Promise<P
       ...(disableStatusHandshake ? { p2pDisableStatusHandshake: true } : {}),
       listenAddress: '127.0.0.1',
       aztecEpochDuration: 64, // stable committee
+      // Pipelining: target-slot is one ahead of build-slot; inboxLag sources L1->L2
+      // messages from the previous checkpoint to avoid L1ToL2MessagesNotReadyError.
+      enableProposerPipelining: true,
+      inboxLag: 2,
     },
   });
   await t.setup();
@@ -91,7 +95,7 @@ export async function runReqrespTxTest(params: {
     t.bootstrapNodeEnr,
     NUM_VALIDATORS,
     BOOT_NODE_UDP_PORT,
-    t.prefilledPublicData,
+    t.genesis,
     dataDir,
     shouldCollectMetrics(),
   );
@@ -125,7 +129,15 @@ export async function runReqrespTxTest(params: {
   t.ctx.dateProvider.setTime(Number(timestamp) * 1000);
   const startSlotTimestamp = BigInt(timestamp);
 
-  const { proposerIndexes, nodesToTurnOffTxGossip } = await getProposerIndexes(t, startSlotTimestamp);
+  // Under pipelining the active builder during wallclock slot S targets slot S+1, so
+  // we must address the proposer of S+1 (not S) for batch 0. Shift the proposer lookup
+  // window by the pipelining offset so we always send to the currently-building proposer.
+  const proposerSlotOffset = t.ctx.aztecNodeConfig.enableProposerPipelining ? 1 : 0;
+  const { proposerIndexes, nodesToTurnOffTxGossip } = await getProposerIndexes(
+    t,
+    startSlotTimestamp,
+    proposerSlotOffset,
+  );
   t.logger.info(`Turning off tx gossip for nodes: ${nodesToTurnOffTxGossip.map(getNodePort)}`);
   t.logger.info(`Sending txs to proposer nodes: ${proposerIndexes.map(getNodePort)}`);
 
@@ -149,6 +161,13 @@ export async function runReqrespTxTest(params: {
   const submittedTxs = await Promise.all(
     txBatches.map(async (batch, batchIndex) => {
       const proposerNode = nodes[proposerIndexes[batchIndex]];
+      for (const tx of batch) {
+        t.logger.info(`Tx ${tx.getTxHash().toString()} base64: ${tx.toBuffer().toString('base64')}`);
+      }
+      const txHashes = batch.map(tx => tx.getTxHash().toString());
+      t.logger.info(
+        `Sending batch ${batchIndex} to proposer ${getNodePort(proposerIndexes[batchIndex])}: ${txHashes.join(', ')}`,
+      );
       await Promise.all(
         batch.map(async tx => {
           try {
@@ -163,12 +182,23 @@ export async function runReqrespTxTest(params: {
     }),
   );
 
+  // Log pool state per node after sending
+  for (let i = 0; i < NUM_VALIDATORS; i++) {
+    const count = await nodes[i].getPendingTxCount();
+    t.logger.info(`Node ${getNodePort(i)} pool has ${count} pending txs`);
+  }
+
+  // Use the test's own aztecSlotDuration (not the env default that p2p_network's
+  // WAIT_FOR_TX_TIMEOUT is derived from) so the timeout scales with this test's 36s slot.
+  // Under pipelining the round-trip is roughly build-slot + target-slot + L1 publish, so
+  // budget for >= 3 slots.
+  const waitForTxTimeout = t.ctx.aztecNodeConfig.aztecSlotDuration * 4.5;
   t.logger.info('Waiting for all transactions to be mined');
   await Promise.all(
     submittedTxs.flatMap((batch, batchIndex) =>
       batch.map(async (submittedTx, txIndex) => {
         t.logger.info(`Waiting for tx ${batchIndex}-${txIndex} ${submittedTx.txHash.toString()} to be mined`);
-        await waitForTx(submittedTx.node, submittedTx.txHash, { timeout: WAIT_FOR_TX_TIMEOUT * 1.5 });
+        await waitForTx(submittedTx.node, submittedTx.txHash, { timeout: waitForTxTimeout });
         t.logger.info(`Tx ${batchIndex}-${txIndex} ${submittedTx.txHash.toString()} has been mined`);
       }),
     ),
@@ -178,20 +208,29 @@ export async function runReqrespTxTest(params: {
 
   // Assert that multiple blocks were built for at least one slot
   t.logger.info('Verifying multiple blocks for at least one checkpoint');
-  const checkpoints = await nodes[0].getCheckpoints(CheckpointNumber(1), 50);
-  expect(checkpoints.length).toBeGreaterThan(0);
+  // Wait for L1 checkpoint sync, which may lag behind P2P block propagation.
+  const checkpoints = await retryUntil(
+    async () => {
+      const cps = await nodes[0].getCheckpoints(CheckpointNumber(1), 50, { includeBlocks: true });
+      return cps.length > 0 && cps.some(cp => (cp.blocks?.length ?? 0) >= 2) ? cps : undefined;
+    },
+    'waiting for multi-block checkpoint to sync from L1',
+    30,
+    1,
+  );
 
   let mbpsFound = false;
-  let expectedBlockNumber = checkpoints[0].checkpoint.blocks[0].number;
+  let expectedBlockNumber = checkpoints[0].blocks![0].number;
 
   for (const published of checkpoints) {
-    const blockCount = published.checkpoint.blocks.length;
+    const blocks = published.blocks!;
+    const blockCount = blocks.length;
     mbpsFound = mbpsFound || blockCount >= 2;
 
     for (let i = 0; i < blockCount; i++) {
-      const block = published.checkpoint.blocks[i];
+      const block = blocks[i];
       expect(block.indexWithinCheckpoint).toBe(i);
-      expect(block.checkpointNumber).toBe(published.checkpoint.number);
+      expect(block.checkpointNumber).toBe(published.number);
       expect(block.number).toBe(expectedBlockNumber);
       expectedBlockNumber++;
     }
@@ -201,7 +240,7 @@ export async function runReqrespTxTest(params: {
   return nodes;
 }
 
-async function getProposerIndexes(t: P2PNetworkTest, startSlotTimestamp: bigint) {
+async function getProposerIndexes(t: P2PNetworkTest, startSlotTimestamp: bigint, slotOffset = 0) {
   // Get the nodes for the next set of slots
   const rollupContract = new RollupContract(
     t.ctx.deployL1ContractsValues.l1Client,
@@ -213,7 +252,7 @@ async function getProposerIndexes(t: P2PNetworkTest, startSlotTimestamp: bigint)
 
   const proposers = await Promise.all(
     Array.from({ length: 3 }, async (_, i) => {
-      const slot = SlotNumber(startSlot + i);
+      const slot = SlotNumber(startSlot + slotOffset + i);
       const slotTimestamp = await rollupContract.getTimestampForSlot(slot);
       return await rollupContract.getProposerAt(slotTimestamp);
     }),

package/src/e2e_p2p/shared.ts

@@ -7,11 +7,7 @@ import type { Logger } from '@aztec/aztec.js/log';
 import { TxHash } from '@aztec/aztec.js/tx';
 import type { RollupCheatCodes } from '@aztec/aztec/testing';
 import type { EpochCacheInterface } from '@aztec/epoch-cache';
-import type {
-  EmpireSlashingProposerContract,
-  RollupContract,
-  TallySlashingProposerContract,
-} from '@aztec/ethereum/contracts';
+import type { RollupContract, SlashingProposerContract } from '@aztec/ethereum/contracts';
 import { EpochNumber, SlotNumber } from '@aztec/foundation/branded-types';
 import { timesAsync, unique } from '@aztec/foundation/collection';
 import { EthAddress } from '@aztec/foundation/eth-address';
@@ -22,8 +18,8 @@ import { TestContract, TestContractArtifact } from '@aztec/noir-test-contracts.j
 import { getPXEConfig, getPXEConfig as getRpcConfig } from '@aztec/pxe/server';
 import { getRoundForOffense } from '@aztec/slasher';
 import type { AztecNodeAdmin } from '@aztec/stdlib/interfaces/client';
-import type { SlashFactoryContract } from '@aztec/stdlib/l1-contracts';
 
+import { SchnorrHardcodedKeyAccountContract } from '../fixtures/schnorr_hardcoded_account_contract.js';
 import { submitTxsTo } from '../shared/submit-transactions.js';
 import { TestWallet } from '../test-wallet/test_wallet.js';
 import { type ProvenTx, proveInteraction } from '../test-wallet/utils.js';
@@ -60,10 +56,17 @@ export const submitTransactions = async (
   rpcConfig.proverEnabled = false;
   const wallet = await TestWallet.create(
     node,
-    { ...getPXEConfig(), proverEnabled: false },
+    // Use checkpointed chain tip to avoid anchoring on provisional blocks that the archiver can prune
+    // when their slot ends without a checkpoint landing on L1.
+    { ...getPXEConfig(), proverEnabled: false, syncChainTip: 'checkpointed' },
     { loggerActorLabel: 'pxe-tx' },
   );
-  const fundedAccountManager = await wallet.createSchnorrAccount(fundedAccount.secret, fundedAccount.salt);
+  const contract = new SchnorrHardcodedKeyAccountContract();
+  const fundedAccountManager = await wallet.createAccount({
+    secret: fundedAccount.secret,
+    salt: fundedAccount.salt,
+    contract,
+  });
   return submitTxsTo(wallet, fundedAccountManager.address, numTxs, logger);
 };
 
@@ -78,10 +81,15 @@ export async function prepareTransactions(
 
   const wallet = await TestWallet.create(
     node,
-    { ...getPXEConfig(), proverEnabled: false },
+    { ...getPXEConfig(), proverEnabled: false, syncChainTip: 'checkpointed' },
     { loggerActorLabel: 'pxe-tx' },
   );
-  const fundedAccountManager = await wallet.createSchnorrAccount(fundedAccount.secret, fundedAccount.salt);
+  const accountContract = new SchnorrHardcodedKeyAccountContract();
+  const fundedAccountManager = await wallet.createAccount({
+    secret: fundedAccount.secret,
+    salt: fundedAccount.salt,
+    contract: accountContract,
+  });
 
   const testContractInstance = await getContractInstanceFromInstantiationParams(TestContractArtifact, {
     salt: Fr.random(),
@@ -99,7 +107,7 @@ export async function prepareTransactions(
 }
 
 export function awaitProposalExecution(
-  slashingProposer: EmpireSlashingProposerContract | TallySlashingProposerContract,
+  slashingProposer: SlashingProposerContract,
   timeoutSeconds: number,
   logger: Logger,
 ): Promise<bigint> {
@@ -109,24 +117,12 @@ export function awaitProposalExecution(
       reject(new Error(`Timeout waiting for proposal execution after ${timeoutSeconds}s`));
     }, timeoutSeconds * 1000);
 
-    if (slashingProposer.type === 'empire') {
-      const unwatch = slashingProposer.listenToPayloadSubmitted(args => {
-        logger.warn(`Proposal ${args.payload} from round ${args.round} executed`);
-        clearTimeout(timeout);
-        unwatch();
-        resolve(args.round);
-      });
-    } else if (slashingProposer.type === 'tally') {
-      const unwatch = slashingProposer.listenToRoundExecuted(args => {
-        logger.warn(`Slash from round ${args.round} executed`);
-        clearTimeout(timeout);
-        unwatch();
-        resolve(args.round);
-      });
-    } else {
+    const unwatch = slashingProposer.listenToRoundExecuted(args => {
+      logger.warn(`Slash from round ${args.round} executed`);
       clearTimeout(timeout);
-      reject(new Error(`Unknown slashing proposer type: ${(slashingProposer as any).type}`));
-    }
+      unwatch();
+      resolve(args.round);
+    });
   });
 }
 
@@ -152,11 +148,14 @@ export async function awaitCommitteeExists({
 }
 
 /**
- * Advance epochs until we find one where the target proposer is selected for at least one slot.
- * With N validators and M slots per epoch, a specific proposer may not be selected in any given epoch.
- * For example, with 4 validators and 2 slots/epoch, there is about a 44% chance per epoch.
+ * Advance epochs until we find one where the target proposer is selected for at least one slot,
+ * then stop one epoch before it. This leaves time for the caller to start sequencers before
+ * warping to the target epoch, avoiding the race where the target epoch passes before sequencers
+ * are ready.
+ *
+ * Returns the target epoch number so the caller can warp to it after starting sequencers.
  */
-export async function awaitEpochWithProposer({
+export async function advanceToEpochBeforeProposer({
   epochCache,
   cheatCodes,
   targetProposer,
@@ -168,25 +167,32 @@ export async function awaitEpochWithProposer({
   targetProposer: EthAddress;
   logger: Logger;
   maxAttempts?: number;
-}): Promise<void> {
+}): Promise<{ targetEpoch: EpochNumber }> {
   const { epochDuration } = await cheatCodes.getConfig();
 
   for (let attempt = 0; attempt < maxAttempts; attempt++) {
     const currentEpoch = await cheatCodes.getEpoch();
-    const startSlot = Number(currentEpoch) * Number(epochDuration);
+    // Check the NEXT epoch's slots so we stay one epoch before the target,
+    // giving the caller time to start sequencers before the target epoch arrives.
+    const nextEpoch = Number(currentEpoch) + 1;
+    const startSlot = nextEpoch * Number(epochDuration);
     const endSlot = startSlot + Number(epochDuration);
 
-    logger.info(`Checking epoch ${currentEpoch} (slots ${startSlot}-${endSlot - 1}) for proposer ${targetProposer}`);
+    logger.info(
+      `Checking next epoch ${nextEpoch} (slots ${startSlot}-${endSlot - 1}) for proposer ${targetProposer} (current epoch: ${currentEpoch})`,
+    );
 
     for (let s = startSlot; s < endSlot; s++) {
       const proposer = await epochCache.getProposerAttesterAddressInSlot(SlotNumber(s));
       if (proposer && proposer.equals(targetProposer)) {
-        logger.warn(`Found target proposer ${targetProposer} in slot ${s} of epoch ${currentEpoch}`);
-        return;
+        logger.warn(
+          `Found target proposer ${targetProposer} in slot ${s} of epoch ${nextEpoch}. Staying at epoch ${currentEpoch} to allow sequencer startup.`,
+        );
+        return { targetEpoch: EpochNumber(nextEpoch) };
       }
     }
 
-    logger.info(`Target proposer not found in epoch ${currentEpoch}, advancing to next epoch`);
+    logger.info(`Target proposer not found in epoch ${nextEpoch}, advancing to next epoch`);
     await cheatCodes.advanceToNextEpoch();
   }
 
@@ -235,7 +241,6 @@ export async function awaitCommitteeKicked({
   rollup,
   cheatCodes,
   committee,
-  slashFactory,
   slashingProposer,
   slashingRoundSize,
   aztecSlotDuration,
@@ -246,8 +251,7 @@ export async function awaitCommitteeKicked({
   rollup: RollupContract;
   cheatCodes: RollupCheatCodes;
   committee: readonly `0x${string}`[];
-  slashFactory: SlashFactoryContract;
-  slashingProposer: EmpireSlashingProposerContract | TallySlashingProposerContract | undefined;
+  slashingProposer: SlashingProposerContract | undefined;
   slashingRoundSize: number;
   aztecSlotDuration: number;
   aztecEpochDuration: number;
@@ -260,36 +264,14 @@ export async function awaitCommitteeKicked({
 
   await cheatCodes.debugRollup();
 
-  if (slashingProposer.type === 'empire') {
-    // Await for the slash payload to be created if empire (no payload is created on tally until execution time)
-    const targetEpoch = EpochNumber((await cheatCodes.getEpoch()) + (await rollup.getLagInEpochsForValidatorSet()) + 1);
-    logger.info(`Advancing to epoch ${targetEpoch} so we start slashing`);
-    await cheatCodes.advanceToEpoch(targetEpoch);
-
-    const slashPayloadEvents = await retryUntil(
-      async () => {
-        const events = await slashFactory.getSlashPayloadCreatedEvents();
-        return events.length > 0 ? events : undefined;
-      },
-      'slash payload created',
-      120,
-      1,
-    );
-    expect(slashPayloadEvents.length).toBe(1);
-    // The uniqueness check is needed since a validator may be slashed more than once on the same round (eg because they let two epochs be pruned)
-    expect(unique(slashPayloadEvents[0].slashes.map(slash => slash.validator.toString()))).toHaveLength(
-      committee.length,
-    );
-  } else {
-    // Use the slash offset to ensure we are in the right epoch for tally
-    const slashOffsetInRounds = await slashingProposer.getSlashOffsetInRounds();
-    const slashingRoundSizeInEpochs = slashingRoundSize / aztecEpochDuration;
-    const slashingOffsetInEpochs = Number(slashOffsetInRounds) * slashingRoundSizeInEpochs;
-    const firstEpochInOffenseRound = offenseEpoch - (offenseEpoch % slashingRoundSizeInEpochs);
-    const targetEpoch = firstEpochInOffenseRound + slashingOffsetInEpochs;
-    logger.info(`Advancing to epoch ${targetEpoch} so we start slashing`);
-    await cheatCodes.advanceToEpoch(EpochNumber(targetEpoch), { offset: -aztecSlotDuration / 2 });
-  }
+  // Use the slash offset to ensure we are in the right epoch for tally
+  const slashOffsetInRounds = await slashingProposer.getSlashOffsetInRounds();
+  const slashingRoundSizeInEpochs = slashingRoundSize / aztecEpochDuration;
+  const slashingOffsetInEpochs = Number(slashOffsetInRounds) * slashingRoundSizeInEpochs;
+  const firstEpochInOffenseRound = offenseEpoch - (offenseEpoch % slashingRoundSizeInEpochs);
+  const targetEpoch = firstEpochInOffenseRound + slashingOffsetInEpochs;
+  logger.info(`Advancing to epoch ${targetEpoch} so we start slashing`);
+  await cheatCodes.advanceToEpoch(EpochNumber(targetEpoch), { offset: -aztecSlotDuration / 2 });
 
   const attestersPre = await rollup.getAttesters();
   expect(attestersPre.length).toBe(committee.length);
@@ -299,7 +281,10 @@ export async function awaitCommitteeKicked({
     expect(attesterInfo.status).toEqual(1); // Validating
   }
 
-  const timeout = slashingRoundSize * 2 * aztecSlotDuration + 30;
+  // Allow up to four round-lengths so that under proposer pipelining, where individual rounds
+  // sometimes fail to gather quorum because parts of the committee miss votes due to chain-state
+  // races, we still see a later round execute the slash.
+  const timeout = slashingRoundSize * 4 * aztecSlotDuration + 30;
   logger.info(`Waiting for slash to be executed (timeout ${timeout}s)`);
   await awaitProposalExecution(slashingProposer, timeout, logger);
 

package/src/e2e_token_contract/token_contract_test.ts

@@ -7,7 +7,15 @@ import { InvalidAccountContract } from '@aztec/noir-test-contracts.js/InvalidAcc
 
 import { jest } from '@jest/globals';
 
-import { type EndToEndContext, deployAccounts, publicDeployAccounts, setup, teardown } from '../fixtures/setup.js';
+import {
+  type EndToEndContext,
+  type SetupOptions,
+  deployAccounts,
+  ensureAuthRegistryPublished,
+  publicDeployAccounts,
+  setup,
+  teardown,
+} from '../fixtures/setup.js';
 import { mintTokensToPrivate } from '../fixtures/token_utils.js';
 import { TokenSimulator } from '../simulators/token_simulator.js';
 import type { TestWallet } from '../test-wallet/test_wallet.js';
@@ -77,6 +85,7 @@ export class TokenContractTest {
     [this.adminAddress, this.account1Address, this.account2Address] = deployedAccounts.map(acc => acc.address);
 
     this.logger.info('Applying base setup - deploying token contract');
+    await ensureAuthRegistryPublished(this.wallet, this.adminAddress);
     this.logger.verbose(`Public deploy accounts...`);
     await publicDeployAccounts(this.wallet, [this.adminAddress, this.account1Address]);
 
@@ -115,8 +124,9 @@ export class TokenContractTest {
     );
   }
 
-  async setup() {
+  async setup(opts: Partial<SetupOptions> = {}) {
     this.context = await setup(0, {
+      ...opts,
       metricsPort: this.metricsPort,
       fundSponsoredFPC: true,
       skipAccountDeployment: true,

package/src/fixtures/authwit_proxy.ts

@@ -17,6 +17,10 @@ async function buildProxyCall(proxy: GenericProxyContract, action: ContractFunct
     return proxy.methods.forward_private_3(call.to, call.selector, call.args);
   } else if (argCount === 4) {
     return proxy.methods.forward_private_4(call.to, call.selector, call.args);
+  } else if (argCount === 5) {
+    return proxy.methods.forward_private_5(call.to, call.selector, call.args);
+  } else if (argCount === 6) {
+    return proxy.methods.forward_private_6(call.to, call.selector, call.args);
   }
   throw new Error(`No forward_private_${argCount} method on proxy`);
 }

package/src/fixtures/e2e_prover_test.ts

@@ -4,12 +4,7 @@ import { AztecAddress, EthAddress } from '@aztec/aztec.js/addresses';
 import { type Logger, 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';
@@ -29,6 +24,7 @@ import { getACVMConfig } from './get_acvm_config.js';
 import { getBBConfig } from './get_bb_config.js';
 import {
   type EndToEndContext,
+  type SetupOptions,
   deployAccounts,
   getPrivateKeyFromIndex,
   getSponsoredFPCAddress,
@@ -68,7 +64,10 @@ 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;
@@ -106,15 +105,13 @@ export class FullProverTest {
     await publicDeployAccounts(this.wallet, this.accounts.slice(0, 2));
 
     this.logger.info('Applying base setup: deploying token contract');
-    const {
-      receipt: { contract: asset, instance },
-    } = await TokenContract.deploy(
+    const { contract: asset, instance } = await TokenContract.deploy(
       this.wallet,
       this.accounts[0],
       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;
@@ -128,9 +125,10 @@ export class FullProverTest {
     );
   }
 
-  async setup() {
+  async setup(opts: Partial<SetupOptions> = {}) {
     this.logger.info('Setting up subsystems from fresh');
     this.context = await setup(0, {
+      ...opts,
       startProverNode: true,
       coinbase: this.coinbase,
       fundSponsoredFPC: true,
@@ -170,9 +168,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,
@@ -180,7 +175,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,
       });
@@ -231,8 +225,11 @@ export class FullProverTest {
 
     this.logger.verbose('Starting prover node');
     const sponsoredFPCAddress = await getSponsoredFPCAddress();
-    const { prefilledPublicData } = await getGenesisValues(
+    const { genesis } = await getGenesisValues(
       this.context.initialFundedAccounts.map(a => a.address).concat(sponsoredFPCAddress),
+      undefined,
+      undefined,
+      this.context.genesis!.genesisTimestamp,
     );
 
     const proverNodeConfig: Parameters<typeof AztecNodeService.createAndSync>[0] = {
@@ -260,7 +257,7 @@ export class FullProverTest {
     this.proverAztecNode = await AztecNodeService.createAndSync(
       proverNodeConfig,
       { dateProvider: this.context.dateProvider, p2pClientDeps: { rpcTxProviders: [this.aztecNode] } },
-      { prefilledPublicData },
+      { genesis },
     );
     this.logger.warn(`Proofs are now enabled`, { realProofs: this.realProofs });
     return this;

package/src/fixtures/fixtures.ts

@@ -1,5 +1,91 @@
+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:
+ * - `enableProposerPipelining: true` so the sequencer builds for `slot + 1`.
+ * - `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 = {
+  enableProposerPipelining: true,
+  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).
+ * - Disables proposer pipelining and uses `inboxLag: 1` (synchronous, non-pipelined).
+ * - 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,
+  enableProposerPipelining: false,
+  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,