@aztec/end-to-end 0.0.1-commit.42ee6df9b → 0.0.1-commit.431c48d

package/src/{e2e_p2p → p2p}/p2p_network.ts

@@ -1,14 +1,10 @@
-import type { InitialAccountData } from '@aztec/accounts/testing';
+import { type InitialAccountData, generateSchnorrAccounts } from '@aztec/accounts/testing';
 import type { AztecNodeConfig, AztecNodeService } from '@aztec/aztec-node';
+import { getAccountContractAddress } from '@aztec/aztec.js/account';
 import { AztecAddress, EthAddress } from '@aztec/aztec.js/addresses';
 import { Fr } from '@aztec/aztec.js/fields';
 import { getL1ContractsConfigEnvVars } from '@aztec/ethereum/config';
-import {
-  type EmpireSlashingProposerContract,
-  GSEContract,
-  RollupContract,
-  type TallySlashingProposerContract,
-} from '@aztec/ethereum/contracts';
+import { GSEContract, RollupContract, type SlashingProposerContract } from '@aztec/ethereum/contracts';
 import type { Operator } from '@aztec/ethereum/deploy-aztec-l1-contracts';
 import { deployL1Contract } from '@aztec/ethereum/deploy-l1-contract';
 import { MultiAdderArtifact } from '@aztec/ethereum/l1-artifacts';
@@ -24,20 +20,25 @@ import { SpamContract } from '@aztec/noir-test-contracts.js/Spam';
 import type { BootstrapNode } from '@aztec/p2p/bootstrap';
 import { createBootstrapNodeFromPrivateKey, getBootstrapNodeEnr } from '@aztec/p2p/test-helpers';
 import { tryStop } from '@aztec/stdlib/interfaces/server';
-import { SlashFactoryContract } from '@aztec/stdlib/l1-contracts';
 import { TopicType } from '@aztec/stdlib/p2p';
-import type { PublicDataTreeLeaf } from '@aztec/stdlib/trees';
+import type { GenesisData } from '@aztec/stdlib/world-state';
 import { ZkPassportProofParams } from '@aztec/stdlib/zkpassport';
 import { getGenesisValues } from '@aztec/world-state/testing';
 
+import fs from 'fs';
 import getPort from 'get-port';
+import os from 'os';
+import path from 'path';
 import { type GetContractReturnType, getAddress, getContract } from 'viem';
 import { privateKeyToAccount } from 'viem/accounts';
 
+import {
+  SCHNORR_HARDCODED_PRIVATE_KEY,
+  SchnorrHardcodedKeyAccountContract,
+} from '../fixtures/schnorr_hardcoded_account_contract.js';
 import {
   type EndToEndContext,
   type SetupOptions,
-  deployAccounts,
   getPrivateKeyFromIndex,
   getSponsoredFPCAddress,
   setup,
@@ -48,6 +49,7 @@ import {
   createValidatorConfig,
   generatePrivateKeys,
 } from '../fixtures/setup_p2p_test.js';
+import { getStandardContractGenesisNullifiers } from '../fixtures/standard_contracts_genesis.js';
 import { getEndToEndTestTelemetryClient } from '../fixtures/with_telemetry_utils.js';
 import type { TestWallet } from '../test-wallet/test_wallet.js';
 
@@ -76,8 +78,8 @@ export class P2PNetworkTest {
   public peerIdPrivateKeys: string[] = [];
   public validators: Operator[] = [];
 
-  public deployedAccounts: InitialAccountData[] = [];
-  public prefilledPublicData: PublicDataTreeLeaf[] = [];
+  public hardcodedAccountData!: InitialAccountData;
+  public genesis: GenesisData | undefined;
 
   // The re-execution test needs a wallet and a spam contract
   public wallet?: TestWallet;
@@ -86,6 +88,9 @@ export class P2PNetworkTest {
 
   public bootstrapNode?: BootstrapNode;
 
+  // Root temp directory holding every node's data dir. Created in setup(), removed in teardown().
+  public dataDir!: string;
+
   // Store setup options for use in setup()
   private setupOptions: SetupOptions;
   private deployL1ContractsArgs: any;
@@ -124,12 +129,10 @@ export class P2PNetworkTest {
         initialValidatorConfig.aztecProofSubmissionEpochs ?? l1ContractsConfig.aztecProofSubmissionEpochs,
       slashingRoundSizeInEpochs:
         initialValidatorConfig.slashingRoundSizeInEpochs ?? l1ContractsConfig.slashingRoundSizeInEpochs,
-      slasherFlavor: initialValidatorConfig.slasherFlavor ?? 'tally',
+      slasherEnabled: initialValidatorConfig.slasherEnabled ?? true,
       aztecTargetCommitteeSize: numberOfValidators,
       metricsPort: metricsPort,
-      numberOfInitialFundedAccounts: 2,
       startProverNode,
-      walletMinFeePadding: 2.0,
     };
 
     this.deployL1ContractsArgs = {
@@ -137,7 +140,7 @@ export class P2PNetworkTest {
       aztecEpochDuration: initialValidatorConfig.aztecEpochDuration ?? l1ContractsConfig.aztecEpochDuration,
       slashingRoundSizeInEpochs:
         initialValidatorConfig.slashingRoundSizeInEpochs ?? l1ContractsConfig.slashingRoundSizeInEpochs,
-      slasherFlavor: initialValidatorConfig.slasherFlavor ?? 'tally',
+      slasherEnabled: initialValidatorConfig.slasherEnabled ?? true,
 
       ethereumSlotDuration: initialValidatorConfig.ethereumSlotDuration ?? l1ContractsConfig.ethereumSlotDuration,
       aztecSlotDuration: initialValidatorConfig.aztecSlotDuration ?? l1ContractsConfig.aztecSlotDuration,
@@ -192,10 +195,23 @@ export class P2PNetworkTest {
   }
 
   get fundedAccount() {
-    if (!this.deployedAccounts[0]) {
-      throw new Error('Call setupAccount to create a funded account.');
+    if (!this.hardcodedAccountData) {
+      throw new Error('Call setup to initialize the hardcoded account.');
+    }
+    return this.hardcodedAccountData;
+  }
+
+  /**
+   * Returns a per-role data directory nested under this test's root data dir. The multi-node factories
+   * (`createNodes`) append `-<index>` to this base for each node they spawn; single-node factories
+   * (`createProverNode`, `createNonValidatorNode`, `createNode`) use it verbatim. Everything lives under
+   * `this.dataDir`, so a single recursive remove in teardown() cleans up all of it.
+   */
+  dataDirFor(label: string): string {
+    if (!this.dataDir) {
+      throw new Error('Call setup to initialize the data directory.');
     }
-    return this.deployedAccounts[0];
+    return path.join(this.dataDir, label);
   }
 
   async addBootstrapNode() {
@@ -303,17 +319,22 @@ export class P2PNetworkTest {
     await this._sendDummyTx(this.context.deployL1ContractsValues.l1Client);
   }
 
+  /** Points the wallet to a P2P-enabled node so transactions can propagate through the network. */
+  setupWalletOnNode(node: AztecNodeService) {
+    this.logger.info('Pointing wallet to a P2P-enabled node');
+    this.context.wallet.updateNode(node);
+  }
+
+  /** Registers the hardcoded account in PXE without on-chain deployment. No sequencer needed. */
   async setupAccount() {
-    this.logger.info('Setting up account');
-    const { deployedAccounts } = await deployAccounts(
-      1,
-      this.logger,
-    )({
-      wallet: this.context.wallet,
-      initialFundedAccounts: this.context.initialFundedAccounts,
+    this.logger.info('Registering hardcoded account (no deployment)');
+    const contract = new SchnorrHardcodedKeyAccountContract();
+    const accountManager = await (this.context.wallet as TestWallet).createAccount({
+      secret: this.hardcodedAccountData.secret,
+      salt: this.hardcodedAccountData.salt,
+      contract,
     });
-    this.deployedAccounts = deployedAccounts;
-    [{ address: this.defaultAccountAddress }] = deployedAccounts;
+    this.defaultAccountAddress = accountManager.address;
     this.wallet = this.context.wallet;
   }
 
@@ -354,13 +375,31 @@ export class P2PNetworkTest {
 
   async setup() {
     this.logger.info('Setting up subsystems from fresh');
+
+    this.dataDir = fs.mkdtempSync(path.join(os.tmpdir(), `${this.testName}-`));
+
+    // Pre-compute hardcoded account data so it gets funded in genesis.
+    const contract = new SchnorrHardcodedKeyAccountContract();
+    const secret = Fr.random();
+    const salt = Fr.random();
+    this.hardcodedAccountData = {
+      secret,
+      salt,
+      signingKey: SCHNORR_HARDCODED_PRIVATE_KEY,
+      address: await getAccountContractAddress(contract, secret, salt),
+    };
+
+    // Generate funded (initializerless) Schnorr accounts for tests that create accounts from them (e.g. add_rollup).
+    const fundedAccounts = await generateSchnorrAccounts(2);
+
     this.context = await setup(
       0,
       {
         ...this.setupOptions,
         fundSponsoredFPC: true,
-        skipAccountDeployment: true,
-        slasherFlavor: this.setupOptions.slasherFlavor ?? this.deployL1ContractsArgs.slasherFlavor ?? 'none',
+        skipInitialSequencer: true,
+        additionallyFundedAccounts: [...fundedAccounts, this.hardcodedAccountData],
+        slasherEnabled: this.setupOptions.slasherEnabled ?? this.deployL1ContractsArgs.slasherEnabled ?? false,
         aztecTargetCommitteeSize: 0,
         l1ContractsArgs: this.deployL1ContractsArgs,
       },
@@ -370,10 +409,16 @@ export class P2PNetworkTest {
     this.ctx = this.context;
 
     const sponsoredFPCAddress = await getSponsoredFPCAddress();
-    const initialFundedAccounts = [...this.context.initialFundedAccounts.map(a => a.address), sponsoredFPCAddress];
-
-    const { prefilledPublicData } = await getGenesisValues(initialFundedAccounts);
-    this.prefilledPublicData = prefilledPublicData;
+    const initialFundedAccounts = [...this.context.additionallyFundedAccounts.map(a => a.address), sponsoredFPCAddress];
+
+    const { genesis } = await getGenesisValues(
+      initialFundedAccounts,
+      undefined,
+      undefined,
+      this.context.genesis!.genesisTimestamp,
+      await getStandardContractGenesisNullifiers(),
+    );
+    this.genesis = genesis;
 
     const rollupContract = RollupContract.getFromL1ContractsValues(this.context.deployL1ContractsValues);
     this.monitor = new ChainMonitor(rollupContract, this.context.dateProvider).start();
@@ -409,6 +454,7 @@ export class P2PNetworkTest {
     timeoutSeconds = 30,
     checkIntervalSeconds = 0.1,
     topics: TopicType[] = [TopicType.tx],
+    minMeshPeerCount = 1,
   ) {
     const nodeCount = expectedNodeCount ?? nodes.length;
     const minPeerCount = nodeCount - 1;
@@ -435,11 +481,13 @@ export class P2PNetworkTest {
 
     this.logger.warn('All nodes connected to P2P mesh');
 
-    // Wait for GossipSub mesh to form for all specified topics.
-    // We only require at least 1 mesh peer per node because GossipSub
-    // stops grafting once it reaches Dlo peers and won't fill the mesh to all available peers.
+    // Wait for the GossipSub mesh to form for all specified topics. By default we only require at
+    // least 1 mesh peer per node, since GossipSub stops grafting once it reaches Dlo peers and won't
+    // fill the mesh to every available peer. Callers that need a proposal to reach the whole
+    // committee within a slot (e.g. quorum-from-genesis tests) raise `minMeshPeerCount` so the mesh
+    // is fully formed — a single mesh peer can leave some committee members unreached at first.
     for (const topic of topics) {
-      this.logger.warn(`Waiting for GossipSub mesh to form for ${topic} topic...`);
+      this.logger.warn(`Waiting for GossipSub mesh (>= ${minMeshPeerCount} peers per node) for ${topic} topic...`);
       await Promise.all(
         nodes.map(async (node, index) => {
           const p2p = node.getP2P();
@@ -447,15 +495,15 @@ export class P2PNetworkTest {
             async () => {
               const meshPeers = await p2p.getGossipMeshPeerCount(topic);
               this.logger.debug(`Node ${index} has ${meshPeers} gossip mesh peers for ${topic} topic`);
-              return meshPeers >= 1 ? true : undefined;
+              return meshPeers >= minMeshPeerCount ? true : undefined;
             },
-            `Node ${index} to have gossip mesh peers for ${topic} topic`,
+            `Node ${index} to have >= ${minMeshPeerCount} gossip mesh peers for ${topic} topic`,
             timeoutSeconds,
             checkIntervalSeconds,
           );
         }),
       );
-      this.logger.warn(`All nodes have gossip mesh peers for ${topic} topic`);
+      this.logger.warn(`All nodes have >= ${minMeshPeerCount} gossip mesh peers for ${topic} topic`);
     }
   }
 
@@ -463,13 +511,15 @@ export class P2PNetworkTest {
     await this.monitor.stop();
     await tryStop(this.bootstrapNode, this.logger);
     await teardown(this.context);
+    if (this.dataDir) {
+      fs.rmSync(this.dataDir, { recursive: true, force: true, maxRetries: 3 });
+    }
   }
 
   async getContracts(): Promise<{
     rollup: RollupContract;
     slasherContract: GetContractReturnType<typeof SlasherAbi, ViemClient>;
-    slashingProposer: EmpireSlashingProposerContract | TallySlashingProposerContract | undefined;
-    slashFactory: SlashFactoryContract;
+    slashingProposer: SlashingProposerContract | undefined;
   }> {
     if (!this.ctx.deployL1ContractsValues) {
       throw new Error('DeployAztecL1ContractsValues not set');
@@ -486,14 +536,9 @@ export class P2PNetworkTest {
       client: this.ctx.deployL1ContractsValues.l1Client,
     });
 
-    // Get the actual slashing proposer from rollup (which handles both empire and tally)
+    // Get the actual slashing proposer from rollup
     const slashingProposer = await rollup.getSlashingProposer();
 
-    const slashFactory = new SlashFactoryContract(
-      this.ctx.deployL1ContractsValues.l1Client,
-      getAddress(this.ctx.deployL1ContractsValues.l1ContractAddresses.slashFactoryAddress!.toString()),
-    );
-
-    return { rollup, slasherContract, slashingProposer, slashFactory };
+    return { rollup, slasherContract, slashingProposer };
   }
 }

package/src/{e2e_p2p → p2p}/reqresp/utils.ts

@@ -2,19 +2,17 @@ import type { AztecNodeService } from '@aztec/aztec-node';
 import { createLogger } from '@aztec/aztec.js/log';
 import { waitForTx } from '@aztec/aztec.js/node';
 import { Tx } from '@aztec/aztec.js/tx';
+import { PROPOSER_PIPELINING_SLOT_OFFSET } from '@aztec/epoch-cache';
 import { RollupContract } from '@aztec/ethereum/contracts';
 import { CheckpointNumber, SlotNumber } from '@aztec/foundation/branded-types';
 import { timesAsync } from '@aztec/foundation/collection';
 import { retryUntil } from '@aztec/foundation/retry';
 
 import { expect, jest } from '@jest/globals';
-import fs from 'fs';
-import os from 'os';
-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
@@ -22,8 +20,6 @@ export const NUM_VALIDATORS = 6;
 export const NUM_TXS_PER_NODE = 4;
 export const BOOT_NODE_UDP_PORT = getBootNodeUdpPort();
 
-export const createReqrespDataDir = () => fs.mkdtempSync(path.join(os.tmpdir(), 'reqresp-'));
-
 type ReqrespOptions = {
   disableStatusHandshake?: boolean;
 };
@@ -38,17 +34,18 @@ export async function createReqrespTest(options: ReqrespOptions = {}): Promise<P
     // To collect metrics - run in aztec-packages `docker compose --profile metrics up`
     metricsPort: shouldCollectMetrics(),
     initialConfig: {
-      ethereumSlotDuration: 8,
+      ethereumSlotDuration: 12,
       aztecSlotDuration: 36,
       blockDurationMs: 6000,
-      l1PublishingTime: 8,
       minTxsPerBlock: 1,
       maxTxsPerBlock: 2,
-      enforceTimeTable: true,
       aztecProofSubmissionEpochs: 1024, // effectively do not reorg
       ...(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.
+      inboxLag: 2,
     },
   });
   await t.setup();
@@ -56,25 +53,21 @@ export async function createReqrespTest(options: ReqrespOptions = {}): Promise<P
   return t;
 }
 
-export async function cleanupReqrespTest(params: { t: P2PNetworkTest; nodes?: AztecNodeService[]; dataDir: string }) {
-  const { t, nodes, dataDir } = params;
+export async function cleanupReqrespTest(params: { t: P2PNetworkTest; nodes?: AztecNodeService[] }) {
+  const { t, nodes } = params;
   if (nodes) {
     await t.stopNodes(nodes);
   }
   await t.teardown();
-  for (let i = 0; i < NUM_VALIDATORS; i++) {
-    fs.rmSync(`${dataDir}-${i}`, { recursive: true, force: true, maxRetries: 3 });
-  }
 }
 
 const getNodePort = (nodeIndex: number) => BOOT_NODE_UDP_PORT + 1 + nodeIndex;
 
 export async function runReqrespTxTest(params: {
   t: P2PNetworkTest;
-  dataDir: string;
   disableStatusHandshake?: boolean;
 }): Promise<AztecNodeService[]> {
-  const { t, dataDir, disableStatusHandshake = false } = params;
+  const { t, disableStatusHandshake = false } = params;
 
   if (!t.bootstrapNodeEnr) {
     throw new Error('Bootstrap node ENR is not available');
@@ -91,8 +84,8 @@ export async function runReqrespTxTest(params: {
     t.bootstrapNodeEnr,
     NUM_VALIDATORS,
     BOOT_NODE_UDP_PORT,
-    t.prefilledPublicData,
-    dataDir,
+    t.genesis,
+    t.dataDirFor('validator'),
     shouldCollectMetrics(),
   );
 
@@ -125,7 +118,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 = PROPOSER_PIPELINING_SLOT_OFFSET;
+  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)}`);
 
@@ -176,12 +177,17 @@ export async function runReqrespTxTest(params: {
     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`);
       }),
     ),
@@ -194,8 +200,8 @@ export async function runReqrespTxTest(params: {
   // 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);
-      return cps.length > 0 && cps.some(cp => cp.checkpoint.blocks.length >= 2) ? cps : undefined;
+      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,
@@ -203,16 +209,17 @@ export async function runReqrespTxTest(params: {
   );
 
   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++;
     }
@@ -222,7 +229,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,
@@ -234,7 +241,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);
     }),