@aztec/end-to-end 0.0.1-commit.0c875d939 → 0.0.1-commit.0dc957cde

package/src/bench/client_flows/client_flows_benchmark.ts

@@ -1,10 +1,11 @@
+import { NO_FROM } from '@aztec/aztec.js/account';
 import { AztecAddress } from '@aztec/aztec.js/addresses';
 import { FeeJuicePaymentMethodWithClaim } from '@aztec/aztec.js/fee';
 import { type FeePaymentMethod, PrivateFeePaymentMethod, SponsoredFeePaymentMethod } from '@aztec/aztec.js/fee';
 import { type Logger, createLogger } from '@aztec/aztec.js/log';
 import type { AztecNode } from '@aztec/aztec.js/node';
 import type { Wallet } from '@aztec/aztec.js/wallet';
-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';
@@ -27,7 +28,7 @@ import type { ContractInstanceWithAddress } from '@aztec/stdlib/contract';
 import { GasSettings } from '@aztec/stdlib/gas';
 import { deriveSigningKey } from '@aztec/stdlib/keys';
 
-import { MNEMONIC } from '../../fixtures/fixtures.js';
+import { MNEMONIC, getPaddedMaxFeesPerGas } from '../../fixtures/fixtures.js';
 import { type EndToEndContext, type SetupOptions, deployAccounts, setup, teardown } from '../../fixtures/setup.js';
 import { mintTokensToPrivate } from '../../fixtures/token_utils.js';
 import { setupSponsoredFPC } from '../../fixtures/utils.js';
@@ -130,11 +131,14 @@ export class ClientFlowsBenchmark {
 
   async setup() {
     this.logger.info('Setting up subsystems from fresh');
+    // 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, {
       ...this.setupOptions,
       fundSponsoredFPC: true,
       skipAccountDeployment: true,
       l1ContractsArgs: this.setupOptions,
+      txPublicSetupAllowListExtend: [...(this.setupOptions.txPublicSetupAllowListExtend ?? []), ...tokenAllowList],
     });
     await this.applyBaseSetup();
 
@@ -148,6 +152,7 @@ export class ClientFlowsBenchmark {
 
   async teardown() {
     await this.chainMonitor.stop();
+    await this.userWallet?.stop();
     await teardown(this.context);
   }
 
@@ -161,11 +166,15 @@ export class ClientFlowsBenchmark {
 
   /** Admin mints bananaCoin tokens privately to the target address and redeems them. */
   async mintPrivateBananas(amount: bigint, address: AztecAddress) {
-    const balanceBefore = await this.bananaCoin.methods.balance_of_private(address).simulate({ from: address });
+    const { result: balanceBefore } = await this.bananaCoin.methods
+      .balance_of_private(address)
+      .simulate({ from: address });
 
     await mintTokensToPrivate(this.bananaCoin, this.adminAddress, address, amount);
 
-    const balanceAfter = await this.bananaCoin.methods.balance_of_private(address).simulate({ from: address });
+    const { result: balanceAfter } = await this.bananaCoin.methods
+      .balance_of_private(address)
+      .simulate({ from: address });
     expect(balanceAfter).toEqual(balanceBefore + amount);
   }
 
@@ -247,7 +256,9 @@ export class ClientFlowsBenchmark {
       'BC',
       'BC',
       18n,
-    ).send({ from: this.adminAddress, wait: { returnReceipt: true } });
+    ).send({
+      from: this.adminAddress,
+    });
     this.logger.info(`BananaCoin deployed at ${bananaCoin.address}`);
     this.bananaCoin = bananaCoin;
     this.bananaCoinInstance = bananaCoinInstance;
@@ -261,7 +272,9 @@ export class ClientFlowsBenchmark {
       'CBC',
       'CBC',
       18n,
-    ).send({ from: this.adminAddress, wait: { returnReceipt: true } });
+    ).send({
+      from: this.adminAddress,
+    });
     this.logger.info(`CandyBarCoin deployed at ${candyBarCoin.address}`);
     this.candyBarCoin = candyBarCoin;
     this.candyBarCoinInstance = candyBarCoinInstance;
@@ -277,7 +290,9 @@ export class ClientFlowsBenchmark {
       this.adminWallet,
       bananaCoin.address,
       this.adminAddress,
-    ).send({ from: this.adminAddress, wait: { returnReceipt: true } });
+    ).send({
+      from: this.adminAddress,
+    });
 
     this.logger.info(`BananaPay deployed at ${bananaFPC.address}`);
 
@@ -326,7 +341,7 @@ export class ClientFlowsBenchmark {
     const claim = await this.feeJuiceBridgeTestHarness.prepareTokensOnL1(benchysAddress);
     const behchysDeployMethod = await benchysAccountManager.getDeployMethod();
     await behchysDeployMethod.send({
-      from: AztecAddress.ZERO,
+      from: NO_FROM,
       fee: { paymentMethod: new FeeJuicePaymentMethodWithClaim(benchysAddress, claim) },
     });
     // Register benchy on the user's Wallet, where we're going to be interacting from
@@ -346,13 +361,15 @@ export class ClientFlowsBenchmark {
       'LPT',
       'LPT',
       18n,
-    ).send({ from: this.adminAddress, wait: { returnReceipt: true } });
+    ).send({
+      from: this.adminAddress,
+    });
     const { contract: amm, instance: ammInstance } = await AMMContract.deploy(
       this.adminWallet,
       this.bananaCoin.address,
       this.candyBarCoin.address,
       liquidityToken.address,
-    ).send({ from: this.adminAddress, wait: { returnReceipt: true } });
+    ).send({ from: this.adminAddress });
     this.logger.info(`AMM deployed at ${amm.address}`);
     await liquidityToken.methods.set_minter(amm.address, true).send({ from: this.adminAddress });
     this.liquidityToken = liquidityToken;
@@ -369,8 +386,8 @@ export class ClientFlowsBenchmark {
   public async getPrivateFPCPaymentMethodForWallet(wallet: Wallet, sender: AztecAddress) {
     // The private fee paying method assembled on the app side requires knowledge of the maximum
     // fee the user is willing to pay
-    const maxFeesPerGas = (await this.aztecNode.getCurrentMinFees()).mul(1.5);
-    const gasSettings = GasSettings.default({ maxFeesPerGas });
+    const maxFeesPerGas = await getPaddedMaxFeesPerGas(this.aztecNode);
+    const gasSettings = GasSettings.fallback({ maxFeesPerGas });
     return new PrivateFeePaymentMethod(this.bananaFPC.address, sender, wallet, gasSettings);
   }
 

package/src/bench/utils.ts

@@ -25,7 +25,7 @@ export async function benchmarkSetup(
 ) {
   const context = await setup(1, { ...opts, telemetryConfig: { benchmark: true } });
   const defaultAccountAddress = context.accounts[0];
-  const contract = await BenchmarkingContract.deploy(context.wallet).send({ from: defaultAccountAddress });
+  const { contract } = await BenchmarkingContract.deploy(context.wallet).send({ from: defaultAccountAddress });
   context.logger.info(`Deployed benchmarking contract at ${contract.address}`);
   const sequencer = (context.aztecNode as AztecNodeService).getSequencer()!;
   const telemetry = context.telemetryClient as BenchmarkTelemetryClient;
@@ -149,7 +149,12 @@ export async function sendTxs(
   context.logger.info(`Creating ${txCount} txs`);
   const [from] = context.accounts;
   context.logger.info(`Sending ${txCount} txs`);
-  return Promise.all(calls.map(call => call.send({ from, wait: NO_WAIT })));
+  return Promise.all(
+    calls.map(async call => {
+      const { txHash } = await call.send({ from, wait: NO_WAIT });
+      return txHash;
+    }),
+  );
 }
 
 export async function waitTxs(txs: TxHash[], context: EndToEndContext, txWaitOpts?: WaitOpts) {

package/src/e2e_blacklist_token_contract/blacklist_token_contract_test.ts

@@ -10,6 +10,7 @@ import { TokenBlacklistContract } from '@aztec/noir-contracts.js/TokenBlacklist'
 import { GenericProxyContract } from '@aztec/noir-test-contracts.js/GenericProxy';
 import { InvalidAccountContract } from '@aztec/noir-test-contracts.js/InvalidAccount';
 import type { SequencerClient } from '@aztec/sequencer-client';
+import type { AztecNodeDebug } from '@aztec/stdlib/interfaces/client';
 
 import { jest } from '@jest/globals';
 
@@ -57,7 +58,7 @@ export class BlacklistTokenContractTest {
   authwitProxy!: GenericProxyContract;
   cheatCodes!: CheatCodes;
   sequencer!: SequencerClient;
-  aztecNode!: AztecNode;
+  aztecNode!: AztecNode & AztecNodeDebug;
 
   adminAddress!: AztecAddress;
   otherAddress!: AztecAddress;
@@ -68,11 +69,7 @@ export class BlacklistTokenContractTest {
   }
 
   async crossTimestampOfChange() {
-    await this.cheatCodes.warpL2TimeAtLeastBy(
-      this.sequencer,
-      this.aztecNode,
-      BlacklistTokenContractTest.CHANGE_ROLES_DELAY,
-    );
+    await this.cheatCodes.warpL2TimeAtLeastBy(this.aztecNode, BlacklistTokenContractTest.CHANGE_ROLES_DELAY);
   }
 
   /**
@@ -107,20 +104,24 @@ export class BlacklistTokenContractTest {
     await publicDeployAccounts(this.wallet, [this.adminAddress, this.otherAddress, this.blacklistedAddress]);
 
     this.logger.verbose(`Deploying TokenContract...`);
-    this.asset = await TokenBlacklistContract.deploy(this.wallet, this.adminAddress).send({
+    ({ contract: this.asset } = await TokenBlacklistContract.deploy(this.wallet, this.adminAddress).send({
       from: this.adminAddress,
-    });
+    }));
     this.logger.verbose(`Token deployed to ${this.asset.address}`);
 
     this.logger.verbose(`Deploying bad account...`);
-    this.badAccount = await InvalidAccountContract.deploy(this.wallet).send({ from: this.adminAddress });
+    ({ contract: this.badAccount } = await InvalidAccountContract.deploy(this.wallet).send({
+      from: this.adminAddress,
+    }));
     this.logger.verbose(`Deployed to ${this.badAccount.address}.`);
 
     // Deploy a proxy contract for "on behalf of other" tests. The note owner must be the tx sender
     // (so their notes are in scope), but msg_sender in the target must differ from the note owner
     // to trigger authwit validation. The proxy forwards calls so that msg_sender != tx sender.
     this.logger.verbose(`Deploying generic proxy...`);
-    this.authwitProxy = await GenericProxyContract.deploy(this.wallet).send({ from: this.adminAddress });
+    ({ contract: this.authwitProxy } = await GenericProxyContract.deploy(this.wallet).send({
+      from: this.adminAddress,
+    }));
     this.logger.verbose(`Deployed to ${this.authwitProxy.address}.`);
 
     await this.crossTimestampOfChange();
@@ -133,9 +134,9 @@ export class BlacklistTokenContractTest {
       [this.adminAddress, this.otherAddress, this.blacklistedAddress],
     );
 
-    expect(await this.asset.methods.get_roles(this.adminAddress).simulate({ from: this.adminAddress })).toEqual(
-      new Role().withAdmin().toNoirStruct(),
-    );
+    expect(
+      (await this.asset.methods.get_roles(this.adminAddress).simulate({ from: this.adminAddress })).result,
+    ).toEqual(new Role().withAdmin().toNoirStruct());
   }
 
   async setup() {
@@ -189,9 +190,9 @@ export class BlacklistTokenContractTest {
 
     await this.crossTimestampOfChange();
 
-    expect(await this.asset.methods.get_roles(this.adminAddress).simulate({ from: this.adminAddress })).toEqual(
-      adminMinterRole.toNoirStruct(),
-    );
+    expect(
+      (await this.asset.methods.get_roles(this.adminAddress).simulate({ from: this.adminAddress })).result,
+    ).toEqual(adminMinterRole.toNoirStruct());
 
     this.logger.verbose(`Minting ${amount} publicly...`);
     await asset.methods.mint_public(this.adminAddress, amount).send({ from: this.adminAddress });
@@ -199,7 +200,7 @@ export class BlacklistTokenContractTest {
     this.logger.verbose(`Minting ${amount} privately...`);
     const secret = Fr.random();
     const secretHash = await computeSecretHash(secret);
-    const receipt = await asset.methods.mint_private(amount, secretHash).send({ from: this.adminAddress });
+    const { receipt } = await asset.methods.mint_private(amount, secretHash).send({ from: this.adminAddress });
 
     await this.addPendingShieldNoteToPXE(asset, this.adminAddress, amount, secretHash, receipt.txHash);
     await asset.methods.redeem_shield(this.adminAddress, amount, secret).send({ from: this.adminAddress });
@@ -207,20 +208,20 @@ export class BlacklistTokenContractTest {
 
     tokenSim.mintPublic(this.adminAddress, amount);
 
-    const publicBalance = await asset.methods
+    const { result: publicBalance } = await asset.methods
       .balance_of_public(this.adminAddress)
       .simulate({ from: this.adminAddress });
     this.logger.verbose(`Public balance of wallet 0: ${publicBalance}`);
     expect(publicBalance).toEqual(this.tokenSim.balanceOfPublic(this.adminAddress));
 
     tokenSim.mintPrivate(this.adminAddress, amount);
-    const privateBalance = await asset.methods
+    const { result: privateBalance } = await asset.methods
       .balance_of_private(this.adminAddress)
       .simulate({ from: this.adminAddress });
     this.logger.verbose(`Private balance of wallet 0: ${privateBalance}`);
     expect(privateBalance).toEqual(tokenSim.balanceOfPrivate(this.adminAddress));
 
-    const totalSupply = await asset.methods.total_supply().simulate({ from: this.adminAddress });
+    const { result: totalSupply } = await asset.methods.total_supply().simulate({ from: this.adminAddress });
     this.logger.verbose(`Total supply: ${totalSupply}`);
     expect(totalSupply).toEqual(tokenSim.totalSupply);
   }

package/src/e2e_epochs/epochs_test.ts

@@ -1,4 +1,7 @@
+import type { InitialAccountData } from '@aztec/accounts/testing';
+import type { Archiver } from '@aztec/archiver';
 import { type AztecNodeConfig, AztecNodeService } from '@aztec/aztec-node';
+import { getAccountContractAddress } from '@aztec/aztec.js/account';
 import { getTimestampRangeForEpoch } from '@aztec/aztec.js/block';
 import { getContractInstanceFromInstantiationParams } from '@aztec/aztec.js/contracts';
 import { Fr } from '@aztec/aztec.js/fields';
@@ -9,7 +12,8 @@ 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';
@@ -20,24 +24,22 @@ 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';
+import type { SlashingProtectionDatabase } from '@aztec/validator-ha-signer/types';
 
 import { join } from 'path';
 import type { Hex } 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,
@@ -45,8 +47,9 @@ import {
   getPrivateKeyFromIndex,
   setup,
 } from '../fixtures/utils.js';
+import type { TestWallet } from '../test-wallet/test_wallet.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;
@@ -55,6 +58,8 @@ export type EpochsTestOpts = Partial<SetupOptions> & {
   numberOfAccounts?: number;
   pxeOpts?: Partial<PXEConfig>;
   aztecSlotDurationInL1Slots?: number;
+  /** Skip creating/registering the hardcoded account during setup (for tests that handle accounts themselves). */
+  skipHardcodedAccount?: boolean;
 };
 
 export type TrackedSequencerEvent = {
@@ -81,7 +86,7 @@ export class EpochsTestContext {
   public proverDelayer!: Delayer;
   public sequencerDelayer!: Delayer;
 
-  public proverNodes: ProverNode[] = [];
+  public proverNodes: AztecNodeService[] = [];
   public nodes: AztecNodeService[] = [];
 
   public epochDuration!: number;
@@ -125,10 +130,18 @@ export class EpochsTestContext {
     this.L1_BLOCK_TIME_IN_S = ethereumSlotDuration;
     this.L2_SLOT_DURATION_IN_S = aztecSlotDuration;
 
+    // When skipInitialSequencer is set, auto-create a hardcoded account funded via genesis.
+    // This avoids needing to deploy accounts on-chain (which would require a running sequencer).
+    const useHardcodedAccount = opts.skipInitialSequencer && !opts.skipHardcodedAccount;
+    let hardcodedAccountData: InitialAccountData | undefined;
+    if (useHardcodedAccount) {
+      hardcodedAccountData = await EpochsTestContext.getHardcodedAccountData(Fr.random(), Fr.random());
+    }
+
     // Set up system without any account nor protocol contracts
     // and with faster block times and shorter epochs.
     const context = await setup(
-      opts.numberOfAccounts ?? 0,
+      useHardcodedAccount ? 0 : (opts.numberOfAccounts ?? 0),
       {
         automineL1Setup: true,
         checkIntervalMs: 50,
@@ -143,15 +156,13 @@ export class EpochsTestContext {
         realProofs: false,
         startProverNode: true,
         proverTestDelayMs: opts.proverTestDelayMs ?? 0,
-        // We use numeric incremental prover ids for simplicity, but we can switch to
-        // 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',
+        slasherEnabled: false,
         l1PublishingTime,
         ...opts,
+        ...(hardcodedAccountData ? { initialFundedAccounts: [hardcodedAccountData], numberOfAccounts: 0 } : {}),
       },
       // Use checkpointed chain tip for PXE by default to avoid issues with blocks being dropped due to pruned anchor blocks.
       // Can be overridden via opts.pxeOpts.
@@ -159,6 +170,11 @@ export class EpochsTestContext {
     );
 
     this.context = context;
+
+    // Register the hardcoded account in PXE (local only, no on-chain deployment needed).
+    if (hardcodedAccountData) {
+      await this.registerHardcodedAccount(hardcodedAccountData);
+    }
     this.proverNodes = context.proverNode ? [context.proverNode] : [];
     this.nodes = context.aztecNode ? [context.aztecNode as AztecNodeService] : [];
     this.logger = context.logger;
@@ -169,17 +185,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`);
@@ -195,6 +202,7 @@ export class EpochsTestContext {
       ethereumSlotDuration,
       proofSubmissionEpochs: Number(await this.rollup.getProofSubmissionEpochs()),
       targetCommitteeSize: await this.rollup.getTargetCommitteeSize(),
+      rollupManaLimit: Number(await this.rollup.getManaLimit()),
     };
 
     this.logger.info(
@@ -209,31 +217,63 @@ export class EpochsTestContext {
     await this.context.teardown();
   }
 
+  /**
+   * Computes InitialAccountData for a SchnorrHardcodedKeyAccountContract.
+   * This contract has a hardcoded signing key and no initializer, so it can be used without
+   * on-chain deployment. Pass the returned data in `initialFundedAccounts` so the address
+   * gets funded with fee juice in genesis.
+   */
+  public static async getHardcodedAccountData(secret: Fr, salt: Fr): Promise<InitialAccountData> {
+    const contract = new SchnorrHardcodedKeyAccountContract();
+    const address = await getAccountContractAddress(contract, secret, salt);
+    const signingKey = SCHNORR_HARDCODED_PRIVATE_KEY;
+    return { secret, salt, signingKey, address };
+  }
+
+  /**
+   * Registers a SchnorrHardcodedKeyAccountContract in PXE. The account must have been funded
+   * at genesis (via getHardcodedAccountData). No on-chain deployment or block mining needed.
+   */
+  public async registerHardcodedAccount(accountData: InitialAccountData) {
+    const contract = new SchnorrHardcodedKeyAccountContract();
+    const wallet = this.context.wallet;
+    const accountManager = await (wallet as TestWallet).createAccount({
+      secret: accountData.secret,
+      salt: accountData.salt,
+      contract,
+    });
+    this.context.accounts = [accountManager.address];
+    return accountManager.address;
+  }
+
   public async createProverNode(opts: { dontStart?: boolean } & Partial<ProverNodeConfig> = {}) {
     this.logger.warn('Creating and syncing a simulated prover node...');
     const proverNodePrivateKey = this.getNextPrivateKey();
     const proverIndex = this.proverNodes.length + 1;
     const { mockGossipSubNetwork } = this.context;
-    const proverNode = await withLoggerBindings({ actor: `prover-${proverIndex}` }, () =>
+    const { proverNode } = await withLoggerBindings({ actor: `prover-${proverIndex}` }, () =>
       createAndSyncProverNode(
         proverNodePrivateKey,
         {
           ...this.context.config,
           p2pEnabled: this.context.config.p2pEnabled || mockGossipSubNetwork !== undefined,
-        },
-        {
-          dataDirectory: join(this.context.config.dataDirectory!, randomBytes(8).toString('hex')),
           proverId: EthAddress.fromNumber(proverIndex),
           dontStart: opts.dontStart,
           ...opts,
         },
-        this.context.aztecNode,
-        this.context.prefilledPublicData ?? [],
+        {
+          dataDirectory: join(this.context.config.dataDirectory!, randomBytes(8).toString('hex')),
+        },
         {
           dateProvider: this.context.dateProvider,
-          p2pClientDeps: mockGossipSubNetwork
-            ? { p2pServiceFactory: getMockPubSubP2PServiceFactory(mockGossipSubNetwork) }
-            : undefined,
+          p2pClientDeps: {
+            p2pServiceFactory: mockGossipSubNetwork ? getMockPubSubP2PServiceFactory(mockGossipSubNetwork) : undefined,
+            rpcTxProviders: [this.context.aztecNode],
+          },
+        },
+        {
+          genesis: this.context.genesis,
+          dontStart: opts.dontStart,
         },
       ),
     );
@@ -248,14 +288,20 @@ export class EpochsTestContext {
 
   public createValidatorNode(
     privateKeys: `0x${string}`[],
-    opts: Partial<AztecNodeConfig> & { txDelayerMaxInclusionTimeIntoSlot?: number; dontStartSequencer?: boolean } = {},
+    opts: Partial<AztecNodeConfig> & {
+      dontStartSequencer?: boolean;
+      slashingProtectionDb?: SlashingProtectionDatabase;
+    } = {},
   ) {
     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 } = {},
+    opts: Partial<AztecNodeConfig> & {
+      dontStartSequencer?: boolean;
+      slashingProtectionDb?: SlashingProtectionDatabase;
+    } = {},
   ) {
     const nodeIndex = this.nodes.length + 1;
     const actorPrefix = opts.disableValidator ? 'node' : 'validator';
@@ -269,6 +315,7 @@ export class EpochsTestContext {
           ...resolvedConfig,
           dataDirectory: join(this.context.config.dataDirectory!, randomBytes(8).toString('hex')),
           validatorPrivateKeys: opts.validatorPrivateKeys ?? new SecretValue([]),
+          nodeId: resolvedConfig.nodeId || `${actorPrefix}-${nodeIndex}`,
           p2pEnabled,
           p2pIp,
         },
@@ -277,34 +324,15 @@ export class EpochsTestContext {
           p2pClientDeps: {
             p2pServiceFactory: mockGossipSubNetwork ? getMockPubSubP2PServiceFactory(mockGossipSubNetwork) : undefined,
           },
+          slashingProtectionDb: opts.slashingProtectionDb,
         },
         {
-          prefilledPublicData: this.context.prefilledPublicData,
+          genesis: this.context.genesis,
           ...opts,
         },
       ),
     );
 
-    // 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;
   }
@@ -356,7 +384,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. */
@@ -408,15 +439,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 };
   }
@@ -433,6 +462,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> = () => ({}),