@aztec/end-to-end 0.0.1-commit.b9865e97 → 0.0.1-commit.be03c316

package/src/fixtures/e2e_prover_test.ts

@@ -1,7 +1,7 @@
-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 type { ClientProtocolCircuitVerifier } from '@aztec/bb-prover';
@@ -19,20 +19,11 @@ 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,
-  type SetupOptions,
-  deployAccounts,
-  getPrivateKeyFromIndex,
-  getSponsoredFPCAddress,
-  publicDeployAccounts,
-  setup,
-  setupPXEAndGetWallet,
-  teardown,
-} from './setup.js';
+import { getPrivateKeyFromIndex, getSponsoredFPCAddress, setup, setupPXEAndGetWallet } from './setup.js';
 
 type ProvenSetup = {
   wallet: TestWallet;
@@ -44,17 +35,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;
@@ -69,16 +64,18 @@ export class FullProverTest {
     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;
@@ -89,20 +86,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(
@@ -125,25 +115,28 @@ export class FullProverTest {
     );
   }
 
-  async setup(opts: Partial<SetupOptions> = {}) {
+  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,
@@ -189,6 +182,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',
@@ -197,8 +191,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);
@@ -226,13 +230,13 @@ export class FullProverTest {
     this.logger.verbose('Starting prover node');
     const sponsoredFPCAddress = await getSponsoredFPCAddress();
     const { genesis } = await getGenesisValues(
-      this.context.initialFundedAccounts.map(a => a.address).concat(sponsoredFPCAddress),
+      this.context.additionallyFundedAccounts.map(a => a.address).concat(sponsoredFPCAddress),
       undefined,
       undefined,
       this.context.genesis!.genesisTimestamp,
     );
 
-    const proverNodeConfig: Parameters<typeof AztecNodeService.createAndSync>[0] = {
+    const proverNodeConfig: Parameters<typeof createAztecNodeService>[0] = {
       ...config,
       enableProverNode: true,
       disableValidator: true,
@@ -248,19 +252,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] } },
       { 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) {
@@ -272,20 +281,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() {

package/src/fixtures/fixtures.ts

@@ -1,4 +1,5 @@
 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;
@@ -17,22 +18,29 @@ export const LARGE_MIN_FEE_PADDING = 15;
  * 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).
+ * 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 = 30;
+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 sets:
+ * 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 = {
@@ -40,14 +48,15 @@ export const PIPELINING_SETUP_OPTS = {
   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 `e2e_p2p/*`,
- * `e2e_epochs/*`, `e2e_slashing/*`, `e2e_block_building`, or any multi-validator suite.
+ * (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 });
  *
@@ -55,22 +64,22 @@ export const PIPELINING_SETUP_OPTS = {
  * - 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 the validator client (the AutomineSequencer needs none).
  * - 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.
+ * - 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,
-  disableAnvilTestWatcher: true,
   inboxLag: 1,
   minTxsPerBlock: 0,
   aztecSlotDuration: 12,
   ethereumSlotDuration: 4,
-  walletMinFeePadding: PIPELINED_FEE_PADDING,
+  walletMinFeePadding: TEST_FEE_PADDING,
 } as const;
 
 /** Returns worst-case predicted min fees with padding applied, mirroring the BaseWallet pattern. */
@@ -104,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/ha_setup.ts

@@ -18,8 +18,8 @@ export interface HADatabaseConfig {
   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;
 }
@@ -37,7 +37,7 @@ export function createHADatabaseConfig(nodeId: string): HADatabaseConfig {
     nodeId,
     haSigningEnabled: true,
     pollingIntervalMs: 100,
-    signingTimeoutMs: 3000,
+    peerSigningTimeoutMs: 3000,
     maxStuckDutiesAgeMs: 72000,
   };
 }
@@ -54,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';