@aztec/end-to-end 0.0.1-commit.29c6b1a3 → 0.0.1-commit.2c85e299c

package/src/e2e_epochs/epochs_test.ts

@@ -1,3 +1,4 @@
+import type { Archiver } from '@aztec/archiver';
 import { type AztecNodeConfig, AztecNodeService } from '@aztec/aztec-node';
 import { getTimestampRangeForEpoch } from '@aztec/aztec.js/block';
 import { getContractInstanceFromInstantiationParams } from '@aztec/aztec.js/contracts';
@@ -9,27 +10,21 @@ import { EpochCache } from '@aztec/epoch-cache';
 import { createExtendedL1Client } from '@aztec/ethereum/client';
 import { DefaultL1ContractsConfig } from '@aztec/ethereum/config';
 import { RollupContract } from '@aztec/ethereum/contracts';
-import { ChainMonitor, DelayedTxUtils, type Delayer, waitUntilL1Timestamp, withDelayer } from '@aztec/ethereum/test';
+import { Delayer, createDelayer, waitUntilL1Timestamp, wrapClientWithDelayer } from '@aztec/ethereum/l1-tx-utils';
+import { ChainMonitor } from '@aztec/ethereum/test';
 import type { ExtendedViemWalletClient } from '@aztec/ethereum/types';
 import { BlockNumber, CheckpointNumber, EpochNumber } from '@aztec/foundation/branded-types';
 import { SecretValue } from '@aztec/foundation/config';
 import { randomBytes } from '@aztec/foundation/crypto/random';
-import { withLogNameSuffix } from '@aztec/foundation/log';
+import { withLoggerBindings } from '@aztec/foundation/log/server';
 import { retryUntil } from '@aztec/foundation/retry';
 import { sleep } from '@aztec/foundation/sleep';
 import { SpamContract } from '@aztec/noir-test-contracts.js/Spam';
 import { TestContract } from '@aztec/noir-test-contracts.js/Test';
 import { getMockPubSubP2PServiceFactory } from '@aztec/p2p/test-helpers';
-import { ProverNode, type ProverNodeConfig, ProverNodePublisher } from '@aztec/prover-node';
-import type { TestProverNode } from '@aztec/prover-node/test';
+import type { ProverNodeConfig } from '@aztec/prover-node';
 import type { PXEConfig } from '@aztec/pxe/config';
-import {
-  type SequencerClient,
-  type SequencerEvents,
-  type SequencerPublisher,
-  SequencerState,
-} from '@aztec/sequencer-client';
-import type { TestSequencerClient } from '@aztec/sequencer-client/test';
+import { type SequencerClient, type SequencerEvents, SequencerState } from '@aztec/sequencer-client';
 import { type BlockParameter, EthAddress } from '@aztec/stdlib/block';
 import { type L1RollupConstants, getProofSubmissionDeadlineTimestamp } from '@aztec/stdlib/epoch-helpers';
 import { tryStop } from '@aztec/stdlib/interfaces/server';
@@ -46,7 +41,7 @@ import {
   setup,
 } from '../fixtures/utils.js';
 
-export const WORLD_STATE_BLOCK_HISTORY = 2;
+export const WORLD_STATE_CHECKPOINT_HISTORY = 2;
 export const WORLD_STATE_BLOCK_CHECK_INTERVAL = 50;
 export const ARCHIVER_POLL_INTERVAL = 50;
 export const DEFAULT_L1_BLOCK_TIME = process.env.CI ? 12 : 8;
@@ -81,7 +76,7 @@ export class EpochsTestContext {
   public proverDelayer!: Delayer;
   public sequencerDelayer!: Delayer;
 
-  public proverNodes: ProverNode[] = [];
+  public proverNodes: AztecNodeService[] = [];
   public nodes: AztecNodeService[] = [];
 
   public epochDuration!: number;
@@ -147,7 +142,7 @@ export class EpochsTestContext {
         // using the prover's eth address if the proverId is used for something in the rollup contract
         // Use numeric EthAddress for deterministic prover id
         proverId: EthAddress.fromNumber(1),
-        worldStateBlockHistory: WORLD_STATE_BLOCK_HISTORY,
+        worldStateCheckpointHistory: WORLD_STATE_CHECKPOINT_HISTORY,
         exitDelaySeconds: DefaultL1ContractsConfig.exitDelaySeconds,
         slasherFlavor: 'none',
         l1PublishingTime,
@@ -169,17 +164,8 @@ export class EpochsTestContext {
     // Loop that tracks L1 and L2 block numbers and logs whenever there's a new one.
     this.monitor = new ChainMonitor(this.rollup, context.dateProvider, this.logger).start();
 
-    // This is hideous.
-    // We ought to have a definite reference to the l1TxUtils that we're using in both places, provided by the test context.
-    this.proverDelayer = context.proverNode
-      ? (((context.proverNode as TestProverNode).publisher as ProverNodePublisher).l1TxUtils as DelayedTxUtils).delayer!
-      : undefined!;
-    this.sequencerDelayer = context.sequencer
-      ? (
-          ((context.sequencer as TestSequencerClient).sequencer.publisher as SequencerPublisher)
-            .l1TxUtils as DelayedTxUtils
-        ).delayer!
-      : undefined!;
+    this.proverDelayer = context.proverDelayer!;
+    this.sequencerDelayer = context.sequencerDelayer!;
 
     if ((context.proverNode && !this.proverDelayer) || (context.sequencer && !this.sequencerDelayer)) {
       throw new Error(`Could not find prover or sequencer delayer`);
@@ -194,6 +180,7 @@ export class EpochsTestContext {
       l1GenesisTime: await this.rollup.getL1GenesisTime(),
       ethereumSlotDuration,
       proofSubmissionEpochs: Number(await this.rollup.getProofSubmissionEpochs()),
+      targetCommitteeSize: await this.rollup.getTargetCommitteeSize(),
     };
 
     this.logger.info(
@@ -211,20 +198,32 @@ export class EpochsTestContext {
   public async createProverNode(opts: { dontStart?: boolean } & Partial<ProverNodeConfig> = {}) {
     this.logger.warn('Creating and syncing a simulated prover node...');
     const proverNodePrivateKey = this.getNextPrivateKey();
-    const suffix = (this.proverNodes.length + 1).toString();
-    const proverNode = await withLogNameSuffix(suffix, () =>
+    const proverIndex = this.proverNodes.length + 1;
+    const { mockGossipSubNetwork } = this.context;
+    const { proverNode } = await withLoggerBindings({ actor: `prover-${proverIndex}` }, () =>
       createAndSyncProverNode(
         proverNodePrivateKey,
-        { ...this.context.config },
         {
-          dataDirectory: join(this.context.config.dataDirectory!, randomBytes(8).toString('hex')),
-          proverId: EthAddress.fromNumber(parseInt(suffix, 10)),
+          ...this.context.config,
+          p2pEnabled: this.context.config.p2pEnabled || mockGossipSubNetwork !== undefined,
+          proverId: EthAddress.fromNumber(proverIndex),
           dontStart: opts.dontStart,
           ...opts,
         },
-        this.context.aztecNode,
-        this.context.prefilledPublicData ?? [],
-        { dateProvider: this.context.dateProvider },
+        {
+          dataDirectory: join(this.context.config.dataDirectory!, randomBytes(8).toString('hex')),
+        },
+        {
+          dateProvider: this.context.dateProvider,
+          p2pClientDeps: {
+            p2pServiceFactory: mockGossipSubNetwork ? getMockPubSubP2PServiceFactory(mockGossipSubNetwork) : undefined,
+            rpcTxProviders: [this.context.aztecNode],
+          },
+        },
+        {
+          prefilledPublicData: this.context.prefilledPublicData ?? [],
+          dontStart: opts.dontStart,
+        },
       ),
     );
     this.proverNodes.push(proverNode);
@@ -238,21 +237,20 @@ export class EpochsTestContext {
 
   public createValidatorNode(
     privateKeys: `0x${string}`[],
-    opts: Partial<AztecNodeConfig> & { txDelayerMaxInclusionTimeIntoSlot?: number; dontStartSequencer?: boolean } = {},
+    opts: Partial<AztecNodeConfig> & { dontStartSequencer?: boolean } = {},
   ) {
     this.logger.warn('Creating and syncing a validator node...');
     return this.createNode({ ...opts, disableValidator: false, validatorPrivateKeys: new SecretValue(privateKeys) });
   }
 
-  private async createNode(
-    opts: Partial<AztecNodeConfig> & { txDelayerMaxInclusionTimeIntoSlot?: number; dontStartSequencer?: boolean } = {},
-  ) {
-    const suffix = (this.nodes.length + 1).toString();
+  private async createNode(opts: Partial<AztecNodeConfig> & { dontStartSequencer?: boolean } = {}) {
+    const nodeIndex = this.nodes.length + 1;
+    const actorPrefix = opts.disableValidator ? 'node' : 'validator';
     const { mockGossipSubNetwork } = this.context;
     const resolvedConfig = { ...this.context.config, ...opts };
     const p2pEnabled = resolvedConfig.p2pEnabled || mockGossipSubNetwork !== undefined;
     const p2pIp = resolvedConfig.p2pIp ?? (p2pEnabled ? '127.0.0.1' : undefined);
-    const node = await withLogNameSuffix(suffix, () =>
+    const node = await withLoggerBindings({ actor: `${actorPrefix}-${nodeIndex}` }, () =>
       AztecNodeService.createAndSync(
         {
           ...resolvedConfig,
@@ -274,26 +272,6 @@ export class EpochsTestContext {
       ),
     );
 
-    // REFACTOR: We're getting too much into the internals of the sequencer here.
-    // We should have a single method for constructing an aztec node that returns a TestAztecNodeService
-    // which directly exposes the delayer and sets any test config.
-    if (opts.txDelayerMaxInclusionTimeIntoSlot !== undefined) {
-      this.logger.info(
-        `Setting tx delayer max inclusion time into slot to ${opts.txDelayerMaxInclusionTimeIntoSlot} seconds`,
-      );
-      // Here we reach into the sequencer and hook in a tx delayer. The problem is that the sequencer's l1 utils only uses a public client, not a wallet.
-      // The delayer needs a wallet (a client that can sign), so we have to create one here.
-      const l1Client = createExtendedL1Client(
-        resolvedConfig.l1RpcUrls!,
-        resolvedConfig.publisherPrivateKeys![0]!.getValue(),
-      );
-      const sequencer = node.getSequencer() as TestSequencerClient;
-      const publisher = sequencer.sequencer.publisher;
-      const delayed = DelayedTxUtils.fromL1TxUtils(publisher.l1TxUtils, this.L1_BLOCK_TIME_IN_S, l1Client);
-      delayed.delayer!.setMaxInclusionTimeIntoSlot(opts.txDelayerMaxInclusionTimeIntoSlot);
-      publisher.l1TxUtils = delayed;
-    }
-
     this.nodes.push(node);
     return node;
   }
@@ -345,7 +323,10 @@ export class EpochsTestContext {
     this.logger.info(`Waiting until last slot of submission window for epoch ${epochNumber} at ${date}`, {
       oneSlotBefore,
     });
-    await waitUntilL1Timestamp(this.l1Client, oneSlotBefore);
+    // Use a timeout that accounts for the full proof submission window
+    const proofSubmissionWindowDuration =
+      this.constants.proofSubmissionEpochs * this.epochDuration * this.L2_SLOT_DURATION_IN_S;
+    await waitUntilL1Timestamp(this.l1Client, oneSlotBefore, undefined, proofSubmissionWindowDuration * 2);
   }
 
   /** Waits for the aztec node to sync to the target block number. */
@@ -397,15 +378,13 @@ export class EpochsTestContext {
 
   /** Creates an L1 client using a fresh account with funds from anvil, with a tx delayer already set up. */
   public async createL1Client() {
-    const { client, delayer } = withDelayer(
-      createExtendedL1Client(
-        [...this.l1Client.chain.rpcUrls.default.http],
-        privateKeyToAccount(this.getNextPrivateKey()),
-        this.l1Client.chain,
-      ),
-      this.context.dateProvider!,
-      { ethereumSlotDuration: this.L1_BLOCK_TIME_IN_S },
+    const rawClient = createExtendedL1Client(
+      [...this.l1Client.chain.rpcUrls.default.http],
+      privateKeyToAccount(this.getNextPrivateKey()),
+      this.l1Client.chain,
     );
+    const delayer = createDelayer(this.context.dateProvider, { ethereumSlotDuration: this.L1_BLOCK_TIME_IN_S }, {});
+    const client = wrapClientWithDelayer(rawClient, delayer);
     expect(await client.getBalance({ address: client.account.address })).toBeGreaterThan(0n);
     return { client, delayer };
   }
@@ -422,6 +401,38 @@ export class EpochsTestContext {
     expect(result).toBe(expectedSuccess);
   }
 
+  /** Verifies at least one checkpoint has the target number of blocks (for MBPS validation). */
+  public async assertMultipleBlocksPerSlot(targetBlockCount: number) {
+    const archiver = (this.context.aztecNode as AztecNodeService).getBlockSource() as Archiver;
+    const checkpoints = await archiver.getCheckpoints(CheckpointNumber(1), 50);
+
+    this.logger.warn(`Retrieved ${checkpoints.length} checkpoints from archiver`, {
+      checkpoints: checkpoints.map(pc => pc.checkpoint.getStats()),
+    });
+
+    let expectedBlockNumber = checkpoints[0].checkpoint.blocks[0].number;
+    let targetFound = false;
+
+    for (const checkpoint of checkpoints) {
+      const blockCount = checkpoint.checkpoint.blocks.length;
+      targetFound = targetFound || blockCount >= targetBlockCount;
+
+      this.logger.verbose(`Checkpoint ${checkpoint.checkpoint.number} has ${blockCount} blocks`, {
+        checkpoint: checkpoint.checkpoint.getStats(),
+      });
+
+      for (let i = 0; i < blockCount; i++) {
+        const block = checkpoint.checkpoint.blocks[i];
+        expect(block.indexWithinCheckpoint).toBe(i);
+        expect(block.checkpointNumber).toBe(checkpoint.checkpoint.number);
+        expect(block.number).toBe(expectedBlockNumber);
+        expectedBlockNumber++;
+      }
+    }
+
+    expect(targetFound).toBe(true);
+  }
+
   public watchSequencerEvents(
     sequencers: SequencerClient[],
     getMetadata: (i: number) => Record<string, any> = () => ({}),

package/src/e2e_fees/bridging_race.notest.ts

@@ -4,11 +4,11 @@ import type { Logger } from '@aztec/aztec.js/log';
 import { Fq } from '@aztec/foundation/curves/bn254';
 import { sleep } from '@aztec/foundation/sleep';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
-import type { TestWallet } from '@aztec/test-wallet/server';
 
 import { jest } from '@jest/globals';
 import type { Hex } from 'viem';
 
+import type { TestWallet } from '../test-wallet/test_wallet.js';
 import { FeesTest } from './fees_test.js';
 
 jest.setTimeout(300_000);

package/src/e2e_fees/fees_test.ts

@@ -1,7 +1,7 @@
 import type { AztecAddress } 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 { CheatCodes, getTokenAllowedSetupFunctions } from '@aztec/aztec/testing';
 import { createExtendedL1Client } from '@aztec/ethereum/client';
 import { RollupContract } from '@aztec/ethereum/contracts';
 import type { DeployAztecL1ContractsArgs } from '@aztec/ethereum/deploy-aztec-l1-contracts';
@@ -20,7 +20,6 @@ import { ProtocolContractAddress } from '@aztec/protocol-contracts';
 import { getCanonicalFeeJuice } from '@aztec/protocol-contracts/fee-juice';
 import { GasSettings } from '@aztec/stdlib/gas';
 import type { AztecNodeAdmin } from '@aztec/stdlib/interfaces/client';
-import { TestWallet } from '@aztec/test-wallet/server';
 
 import { getContract } from 'viem';
 
@@ -36,6 +35,7 @@ import {
 import { mintTokensToPrivate } from '../fixtures/token_utils.js';
 import { type BalancesFn, getBalancesFn, setupSponsoredFPC } from '../fixtures/utils.js';
 import { FeeJuicePortalTestingHarnessFactory, type GasBridgingTestHarness } from '../shared/gas_portal_test_harness.js';
+import { TestWallet } from '../test-wallet/test_wallet.js';
 
 /**
  * Test fixture for testing fees. Provides the following setup steps:
@@ -104,16 +104,19 @@ export class FeesTest {
 
   async setup() {
     this.logger.verbose('Setting up fresh context...');
+    // Token allowlist entries are test-only: FPC-based fee payment with custom tokens won't work on mainnet alpha.
+    const tokenAllowList = await getTokenAllowedSetupFunctions();
     this.context = await setup(0, {
       startProverNode: true,
       ...this.setupOptions,
       fundSponsoredFPC: true,
       skipAccountDeployment: true,
       l1ContractsArgs: { ...this.setupOptions },
+      txPublicSetupAllowListExtend: [...(this.setupOptions.txPublicSetupAllowListExtend ?? []), ...tokenAllowList],
     });
 
     this.rollupContract = RollupContract.getFromConfig(this.context.config);
-    this.chainMonitor = new ChainMonitor(this.rollupContract, this.context.dateProvider!, this.logger, 200).start();
+    this.chainMonitor = new ChainMonitor(this.rollupContract, this.context.dateProvider, this.logger, 200).start();
 
     await this.applyBaseSetup();
 
@@ -126,7 +129,7 @@ export class FeesTest {
   }
 
   setIsMarkingAsProven(b: boolean) {
-    this.context.watcher!.setIsMarkingAsProven(b);
+    this.context.watcher.setIsMarkingAsProven(b);
   }
 
   async catchUpProvenChain() {
@@ -157,15 +160,15 @@ export class FeesTest {
 
   /** Alice mints bananaCoin tokens privately to the target address and redeems them. */
   async mintPrivateBananas(amount: bigint, address: AztecAddress) {
-    const balanceBefore = await this.bananaCoin.methods
+    const { result: balanceBefore } = await this.bananaCoin.methods
       .balance_of_private(address)
-      .simulate({ from: this.aliceAddress });
+      .simulate({ from: address });
 
     await mintTokensToPrivate(this.bananaCoin, this.aliceAddress, address, amount);
 
-    const balanceAfter = await this.bananaCoin.methods
+    const { result: balanceAfter } = await this.bananaCoin.methods
       .balance_of_private(address)
-      .simulate({ from: this.aliceAddress });
+      .simulate({ from: address });
     expect(balanceAfter).toEqual(balanceBefore + amount);
   }
 
@@ -188,8 +191,8 @@ export class FeesTest {
     });
 
     this.wallet = this.context.wallet;
-    this.aztecNode = this.context.aztecNodeService!;
-    this.aztecNodeAdmin = this.context.aztecNodeService!;
+    this.aztecNode = this.context.aztecNodeService;
+    this.aztecNodeAdmin = this.context.aztecNodeService;
     this.gasSettings = GasSettings.default({ maxFeesPerGas: (await this.aztecNode.getCurrentMinFees()).mul(2) });
     this.cheatCodes = this.context.cheatCodes;
     this.accounts = deployedAccounts.map(a => a.address);
@@ -213,16 +216,11 @@ export class FeesTest {
 
     this.feeJuiceContract = FeeJuiceContract.at(ProtocolContractAddress.FeeJuice, this.wallet);
 
-    this.getGasBalanceFn = getBalancesFn(
-      '⛽',
-      this.feeJuiceContract.methods.balance_of_public,
-      this.aliceAddress,
-      this.logger,
-    );
+    this.getGasBalanceFn = getBalancesFn('⛽', this.feeJuiceContract.methods.balance_of_public, this.logger);
 
     this.feeJuiceBridgeTestHarness = await FeeJuicePortalTestingHarnessFactory.create({
-      aztecNode: this.context.aztecNodeService!,
-      aztecNodeAdmin: this.context.aztecNodeService!,
+      aztecNode: this.context.aztecNodeService,
+      aztecNodeAdmin: this.context.aztecNodeService,
       l1Client: this.context.deployL1ContractsValues.l1Client,
       wallet: this.wallet,
       logger: this.logger,
@@ -232,22 +230,16 @@ export class FeesTest {
   async applyDeployBananaToken() {
     this.logger.info('Applying deploy banana token setup');
 
-    const bananaCoin = await BananaCoin.deploy(this.wallet, this.aliceAddress, 'BC', 'BC', 18n).send({
+    const { contract: bananaCoin } = await BananaCoin.deploy(this.wallet, this.aliceAddress, 'BC', 'BC', 18n).send({
       from: this.aliceAddress,
     });
     this.logger.info(`BananaCoin deployed at ${bananaCoin.address}`);
 
     this.bananaCoin = bananaCoin;
-    this.getBananaPublicBalanceFn = getBalancesFn(
-      '🍌.public',
-      this.bananaCoin.methods.balance_of_public,
-      this.aliceAddress,
-      this.logger,
-    );
+    this.getBananaPublicBalanceFn = getBalancesFn('🍌.public', this.bananaCoin.methods.balance_of_public, this.logger);
     this.getBananaPrivateBalanceFn = getBalancesFn(
       '🍌.private',
       this.bananaCoin.methods.balance_of_private,
-      this.aliceAddress,
       this.logger,
     );
   }
@@ -259,7 +251,7 @@ export class FeesTest {
     expect((await this.wallet.getContractMetadata(feeJuiceContract.address)).isContractPublished).toBe(true);
 
     const bananaCoin = this.bananaCoin;
-    const bananaFPC = await FPCContract.deploy(this.wallet, bananaCoin.address, this.fpcAdmin).send({
+    const { contract: bananaFPC } = await FPCContract.deploy(this.wallet, bananaCoin.address, this.fpcAdmin).send({
       from: this.aliceAddress,
     });
 
@@ -290,7 +282,7 @@ export class FeesTest {
 
       // @todo @lherskind As we deal with #13601
       // Right now the value is from `FeeLib.sol`
-      const L1_GAS_PER_EPOCH_VERIFIED = 1000000n;
+      const L1_GAS_PER_EPOCH_VERIFIED = 3600000n;
 
       // We round up
       const mulDiv = (a: bigint, b: bigint, c: bigint) => (a * b) / c + ((a * b) % c > 0n ? 1n : 0n);

package/src/e2e_l1_publisher/write_json.ts

@@ -15,6 +15,7 @@ const AZTEC_GENERATE_TEST_DATA = !!process.env.AZTEC_GENERATE_TEST_DATA;
  */
 export async function writeJson(
   fileName: string,
+  checkpointHeader: CheckpointHeader,
   block: L2Block,
   l1ToL2Content: Fr[],
   blobs: Blob[],
@@ -33,12 +34,6 @@ export async function writeJson(
     return `0x${buffer.toString('hex').padStart(size, '0')}`;
   };
 
-  // Create a checkpoint header for this block
-  const checkpointHeader = CheckpointHeader.random({
-    slotNumber: block.slot,
-    timestamp: block.timestamp,
-  });
-
   const jsonObject = {
     populate: {
       l1ToL2Content: l1ToL2Content.map(value => asHex(value)),

package/src/e2e_nested_contract/nested_contract_test.ts

@@ -44,7 +44,7 @@ export class NestedContractTest {
     });
     this.wallet = this.context.wallet;
     [{ address: this.defaultAccountAddress }] = deployedAccounts;
-    this.aztecNode = this.context.aztecNodeService!;
+    this.aztecNode = this.context.aztecNodeService;
 
     this.logger.info('Public deploy accounts');
     await publicDeployAccounts(this.wallet, [this.defaultAccountAddress]);
@@ -65,9 +65,11 @@ export class NestedContractTest {
 
   async applyManual() {
     this.logger.info('Deploying parent and child contracts');
-    const parentContract = await ParentContract.deploy(this.wallet).send({ from: this.defaultAccountAddress });
-    const childContract = await ChildContract.deploy(this.wallet).send({ from: this.defaultAccountAddress });
-    this.parentContract = parentContract;
-    this.childContract = childContract;
+    ({ contract: this.parentContract } = await ParentContract.deploy(this.wallet).send({
+      from: this.defaultAccountAddress,
+    }));
+    ({ contract: this.childContract } = await ChildContract.deploy(this.wallet).send({
+      from: this.defaultAccountAddress,
+    }));
   }
 }

package/src/e2e_p2p/inactivity_slash_test.ts

@@ -98,13 +98,13 @@ export class P2PInactivityTest {
     this.rollup = rollup;
 
     if (!this.keepInitialNode) {
-      await this.test.ctx.aztecNodeService!.stop();
+      await this.test.ctx.aztecNodeService.stop();
     }
 
     // Create all active nodes
     this.activeNodes = await createNodes(
       this.test.ctx.aztecNodeConfig,
-      this.test.ctx.dateProvider!,
+      this.test.ctx.dateProvider,
       this.test.bootstrapNodeEnr,
       NUM_NODES - this.inactiveNodeCount - Number(this.keepInitialNode),
       BOOT_NODE_UDP_PORT,
@@ -118,7 +118,7 @@ export class P2PInactivityTest {
     const inactiveConfig = { ...this.test.ctx.aztecNodeConfig, dontStartSequencer: true };
     this.inactiveNodes = await createNodes(
       inactiveConfig,
-      this.test.ctx.dateProvider!,
+      this.test.ctx.dateProvider,
       this.test.bootstrapNodeEnr,
       this.inactiveNodeCount,
       BOOT_NODE_UDP_PORT,
@@ -129,7 +129,7 @@ export class P2PInactivityTest {
     );
 
     this.nodes = [
-      ...(this.keepInitialNode ? [this.test.ctx.aztecNodeService!] : []),
+      ...(this.keepInitialNode ? [this.test.ctx.aztecNodeService] : []),
       ...this.activeNodes,
       ...this.inactiveNodes,
     ];

package/src/e2e_p2p/p2p_network.ts

@@ -12,7 +12,7 @@ import {
 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';
-import { createL1TxUtilsFromViemWallet } from '@aztec/ethereum/l1-tx-utils';
+import { createL1TxUtils } from '@aztec/ethereum/l1-tx-utils';
 import { ChainMonitor } from '@aztec/ethereum/test';
 import type { ExtendedViemWalletClient, ViemClient } from '@aztec/ethereum/types';
 import { EpochNumber } from '@aztec/foundation/branded-types';
@@ -25,9 +25,9 @@ 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 { ZkPassportProofParams } from '@aztec/stdlib/zkpassport';
-import type { TestWallet } from '@aztec/test-wallet/server';
 import { getGenesisValues } from '@aztec/world-state/testing';
 
 import getPort from 'get-port';
@@ -49,6 +49,7 @@ import {
   generatePrivateKeys,
 } from '../fixtures/setup_p2p_test.js';
 import { getEndToEndTestTelemetryClient } from '../fixtures/with_telemetry_utils.js';
+import type { TestWallet } from '../test-wallet/test_wallet.js';
 
 // Use a fixed bootstrap node private key so that we can re-use the same snapshot and the nodes can find each other
 const BOOTSTRAP_NODE_PRIVATE_KEY = '080212208f988fc0899e4a73a5aee4d271a5f20670603a756ad8d84f2c94263a6427c591';
@@ -58,7 +59,7 @@ export const WAIT_FOR_TX_TIMEOUT = l1ContractsConfig.aztecSlotDuration * 3;
 export const SHORTENED_BLOCK_TIME_CONFIG_NO_PRUNES = {
   aztecSlotDuration: 12,
   ethereumSlotDuration: 4,
-  aztecProofSubmissionWindow: 640,
+  aztecProofSubmissionEpochs: 640,
 };
 
 export class P2PNetworkTest {
@@ -322,8 +323,9 @@ export class P2PNetworkTest {
       throw new Error('Call setupAccount before deploying spam contract');
     }
 
-    const spamContract = await SpamContract.deploy(this.wallet).send({ from: this.defaultAccountAddress! });
-    this.spamContract = spamContract;
+    ({ contract: this.spamContract } = await SpamContract.deploy(this.wallet).send({
+      from: this.defaultAccountAddress!,
+    }));
   }
 
   async removeInitialNode() {
@@ -333,9 +335,9 @@ export class P2PNetworkTest {
     const block = await this.context.deployL1ContractsValues.l1Client.getBlock({
       blockNumber: receipt.blockNumber,
     });
-    this.context.dateProvider!.setTime(Number(block.timestamp) * 1000);
+    this.context.dateProvider.setTime(Number(block.timestamp) * 1000);
 
-    await this.context.aztecNodeService!.stop();
+    await this.context.aztecNodeService.stop();
   }
 
   async sendDummyTx() {
@@ -343,7 +345,7 @@ export class P2PNetworkTest {
   }
 
   private async _sendDummyTx(l1Client: ExtendedViemWalletClient) {
-    const l1TxUtils = createL1TxUtilsFromViemWallet(l1Client);
+    const l1TxUtils = createL1TxUtils(l1Client);
     return await l1TxUtils.sendAndMonitorTransaction({
       to: l1Client.account!.address,
       value: 1n,
@@ -374,8 +376,8 @@ export class P2PNetworkTest {
     this.prefilledPublicData = prefilledPublicData;
 
     const rollupContract = RollupContract.getFromL1ContractsValues(this.context.deployL1ContractsValues);
-    this.monitor = new ChainMonitor(rollupContract, this.context.dateProvider!).start();
-    this.monitor.on('l1-block', ({ timestamp }) => this.context.dateProvider!.setTime(Number(timestamp) * 1000));
+    this.monitor = new ChainMonitor(rollupContract, this.context.dateProvider).start();
+    this.monitor.on('l1-block', ({ timestamp }) => this.context.dateProvider.setTime(Number(timestamp) * 1000));
   }
 
   async stopNodes(nodes: AztecNodeService[]) {
@@ -406,6 +408,7 @@ export class P2PNetworkTest {
     expectedNodeCount?: number,
     timeoutSeconds = 30,
     checkIntervalSeconds = 0.1,
+    topics: TopicType[] = [TopicType.tx],
   ) {
     const nodeCount = expectedNodeCount ?? nodes.length;
     const minPeerCount = nodeCount - 1;
@@ -431,6 +434,29 @@ 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.
+    for (const topic of topics) {
+      this.logger.warn(`Waiting for GossipSub mesh to form for ${topic} topic...`);
+      await Promise.all(
+        nodes.map(async (node, index) => {
+          const p2p = node.getP2P();
+          await retryUntil(
+            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;
+            },
+            `Node ${index} to have gossip mesh peers for ${topic} topic`,
+            timeoutSeconds,
+            checkIntervalSeconds,
+          );
+        }),
+      );
+      this.logger.warn(`All nodes have gossip mesh peers for ${topic} topic`);
+    }
   }
 
   async teardown() {