@aztec/end-to-end 0.0.1-commit.e3c1de76 → 0.0.1-commit.e57c76e

package/src/fixtures/setup.ts

@@ -1,22 +1,23 @@
 import { SchnorrAccountContractArtifact } from '@aztec/accounts/schnorr';
-import { type InitialAccountData, generateSchnorrAccounts, getInitialTestAccountsData } from '@aztec/accounts/testing';
-import { type Archiver, createArchiver } from '@aztec/archiver';
+import { type InitialAccountData, generateSchnorrAccounts } from '@aztec/accounts/testing';
 import { type AztecNodeConfig, AztecNodeService, getConfigEnvVars } from '@aztec/aztec-node';
+import { NO_FROM } from '@aztec/aztec.js/account';
 import { AztecAddress, EthAddress } from '@aztec/aztec.js/addresses';
 import {
   BatchCall,
   type ContractFunctionInteraction,
   type ContractMethod,
+  type DeployOptions,
+  type InteractionWaitOptions,
   getContractClassFromArtifact,
   waitForProven,
 } from '@aztec/aztec.js/contracts';
 import { publishContractClass, publishInstance } from '@aztec/aztec.js/deployment';
 import { Fr } from '@aztec/aztec.js/fields';
 import { type Logger, createLogger } from '@aztec/aztec.js/log';
-import { type AztecNode, createAztecNodeClient, waitForNode } from '@aztec/aztec.js/node';
+import type { AztecNode } from '@aztec/aztec.js/node';
 import type { Wallet } from '@aztec/aztec.js/wallet';
-import { AnvilTestWatcher, CheatCodes } from '@aztec/aztec/testing';
-import { createBlobClientWithFileStores } from '@aztec/blob-client/client';
+import { AnvilTestWatcher, type AnvilTestWatcherOpts, CheatCodes } from '@aztec/aztec/testing';
 import { SPONSORED_FPC_SALT } from '@aztec/constants';
 import { isAnvilTestChain } from '@aztec/ethereum/chain';
 import { createExtendedL1Client } from '@aztec/ethereum/client';
@@ -30,13 +31,9 @@ import {
   type ZKPassportArgs,
   deployAztecL1Contracts,
 } from '@aztec/ethereum/deploy-aztec-l1-contracts';
-import {
-  DelayedTxUtils,
-  EthCheatCodes,
-  EthCheatCodesWithState,
-  createDelayedL1TxUtilsFromViemWallet,
-  startAnvil,
-} from '@aztec/ethereum/test';
+import type { Delayer } from '@aztec/ethereum/l1-tx-utils';
+import { EthCheatCodes, EthCheatCodesWithState, startAnvil } from '@aztec/ethereum/test';
+import type { Anvil } from '@aztec/ethereum/test';
 import { BlockNumber, EpochNumber } from '@aztec/foundation/branded-types';
 import { SecretValue } from '@aztec/foundation/config';
 import { randomBytes } from '@aztec/foundation/crypto/random';
@@ -45,21 +42,23 @@ import { withLoggerBindings } from '@aztec/foundation/log/server';
 import { retryUntil } from '@aztec/foundation/retry';
 import { sleep } from '@aztec/foundation/sleep';
 import { DateProvider, TestDateProvider } from '@aztec/foundation/timer';
-import type { DataStoreConfig } from '@aztec/kv-store/config';
 import { SponsoredFPCContract } from '@aztec/noir-contracts.js/SponsoredFPC';
 import { getVKTreeRoot } from '@aztec/noir-protocol-circuits-types/vk-tree';
 import type { P2PClientDeps } from '@aztec/p2p';
 import { MockGossipSubNetwork, getMockPubSubP2PServiceFactory } from '@aztec/p2p/test-helpers';
 import { protocolContractsHash } from '@aztec/protocol-contracts';
-import { type ProverNode, type ProverNodeConfig, type ProverNodeDeps, createProverNode } from '@aztec/prover-node';
-import { type PXEConfig, getPXEConfig } from '@aztec/pxe/server';
+import type { ProverNodeConfig } from '@aztec/prover-node';
+import { type PXEConfig, type PXECreationOptions, getPXEConfig } from '@aztec/pxe/server';
 import type { SequencerClient } from '@aztec/sequencer-client';
-import type { TestSequencerClient } from '@aztec/sequencer-client/test';
+import { AuthRegistryArtifact, getStandardAuthRegistry } from '@aztec/standard-contracts/auth-registry';
+import { HandshakeRegistryArtifact, getStandardHandshakeRegistry } from '@aztec/standard-contracts/handshake-registry';
+import { PublicChecksArtifact, getStandardPublicChecks } from '@aztec/standard-contracts/public-checks';
+import { ARTIFACT_VERSION_BEFORE_INJECTION } from '@aztec/stdlib/abi';
 import { type ContractInstanceWithAddress, getContractInstanceFromInstantiationParams } from '@aztec/stdlib/contract';
-import type { AztecNodeAdmin } from '@aztec/stdlib/interfaces/client';
+import type { AztecNodeAdmin, AztecNodeDebug } from '@aztec/stdlib/interfaces/client';
 import { tryStop } from '@aztec/stdlib/interfaces/server';
-import type { P2PClientType } from '@aztec/stdlib/p2p';
 import type { PublicDataTreeLeaf } from '@aztec/stdlib/trees';
+import type { GenesisData } from '@aztec/stdlib/world-state';
 import {
   type TelemetryClient,
   type TelemetryClientConfig,
@@ -67,10 +66,9 @@ import {
   initTelemetryClient,
 } from '@aztec/telemetry-client';
 import { BenchmarkTelemetryClient } from '@aztec/telemetry-client/bench';
-import { TestWallet, deployFundedSchnorrAccounts } from '@aztec/test-wallet/server';
+import { deployFundedSchnorrAccounts } from '@aztec/wallets/testing';
 import { getGenesisValues } from '@aztec/world-state/testing';
 
-import type { Anvil } from '@viem/anvil';
 import fs from 'fs/promises';
 import { tmpdir } from 'os';
 import path from 'path';
@@ -84,6 +82,7 @@ import {
 } from 'viem/accounts';
 import { type Chain, foundry } from 'viem/chains';
 
+import { TestWallet } from '../test-wallet/test_wallet.js';
 import { MNEMONIC, TEST_MAX_PENDING_TX_POOL_COUNT, TEST_PEER_CHECK_INTERVAL_MS } from './fixtures.js';
 import { getACVMConfig } from './get_acvm_config.js';
 import { getBBConfig } from './get_bb_config.js';
@@ -92,9 +91,6 @@ import { getEndToEndTestTelemetryClient } from './with_telemetry_utils.js';
 
 export { startAnvil };
 
-const { AZTEC_NODE_URL = '' } = process.env;
-const getAztecUrl = () => AZTEC_NODE_URL;
-
 let telemetry: TelemetryClient | undefined = undefined;
 async function getTelemetryClient(partialConfig: Partial<TelemetryClientConfig> & { benchmark?: boolean } = {}) {
   if (!telemetry) {
@@ -189,14 +185,22 @@ export type SetupOptions = {
   proverNodeConfig?: Partial<ProverNodeConfig>;
   /** Whether to use a mock gossip sub network for p2p clients. */
   mockGossipSubNetwork?: boolean;
+  /** Whether to add simulated latency to the mock gossipsub network (in ms) */
+  mockGossipSubNetworkLatency?: number;
   /** Whether to disable the anvil test watcher (can still be manually started) */
   disableAnvilTestWatcher?: boolean;
+  anvilTestWatcherOpts?: AnvilTestWatcherOpts;
   /** Whether to enable anvil automine during deployment of L1 contracts (consider defaulting this to true). */
   automineL1Setup?: boolean;
   /** How many accounts to seed and unlock in anvil. */
   anvilAccounts?: number;
   /** Port to start anvil (defaults to 8545) */
   anvilPort?: number;
+  /**
+   * Number of slots per epoch for Anvil's finality simulation.
+   * Anvil reports `finalized = latest - slotsInAnEpoch * 2`.
+   */
+  anvilSlotsInAnEpoch?: number;
   /** Key to use for publishing L1 contracts */
   l1PublisherKey?: SecretValue<`0x${string}`>;
   /** ZkPassport configuration (domain, scope, mock verifier) */
@@ -207,8 +211,16 @@ export type SetupOptions = {
   skipAccountDeployment?: boolean;
   /** L1 contracts deployment arguments. */
   l1ContractsArgs?: Partial<DeployAztecL1ContractsArgs>;
-  /** Wallet minimum fee padding multiplier (defaults to 0.5, which is 50% padding). */
+  /** Wallet minimum fee padding multiplier */
   walletMinFeePadding?: number;
+  /** Whether the initial node should be a lightweight RPC-only node (no sequencer, no validator).
+   *  Use for tests that create their own validator nodes and don't need the initial sequencer. */
+  skipInitialSequencer?: boolean;
+  /** Whether to swap the production Sequencer for the minimal AutomineSequencer.
+   * Use only for single-sequencer non-block-building tests. See AUTOMINE_E2E_OPTS in `fixtures.ts`. */
+  useAutomineSequencer?: boolean;
+  /** Options forwarded to PXE creation (e.g. execution hooks). */
+  pxeCreationOptions?: PXECreationOptions;
 } & Partial<AztecNodeConfig>;
 
 /** Context for an end-to-end test as returned by the `setup` function */
@@ -216,14 +228,14 @@ export type EndToEndContext = {
   /** The Anvil instance (only set if anvil was started locally). */
   anvil: Anvil | undefined;
   /** The Aztec Node service or client a connected to it. */
-  aztecNode: AztecNode;
-  /** The Aztec Node as a service (only set if running locally). */
-  aztecNodeService: AztecNodeService | undefined;
-  /** Client to the Aztec Node admin interface (undefined if connected to remote environment) */
-  aztecNodeAdmin: AztecNodeAdmin | undefined;
-  /** The prover node service (only set if startProverNode is true) */
-  proverNode: ProverNode | undefined;
-  /** A client to the sequencer service (undefined if connected to remote environment) */
+  aztecNode: AztecNode & AztecNodeDebug;
+  /** The Aztec Node as a service. */
+  aztecNodeService: AztecNodeService;
+  /** Client to the Aztec Node admin interface. */
+  aztecNodeAdmin: AztecNodeAdmin;
+  /** The aztec node running the prover node subsystem (only set if startProverNode is true). */
+  proverNode: AztecNodeService | undefined;
+  /** A client to the sequencer service. */
   sequencer: SequencerClient | undefined;
   /** Return values from deployAztecL1Contracts function. */
   deployL1ContractsValues: DeployAztecL1ContractsReturnType;
@@ -243,100 +255,54 @@ export type EndToEndContext = {
   cheatCodes: CheatCodes;
   /** The cheat codes for L1 */
   ethCheatCodes: EthCheatCodes;
-  /** The anvil test watcher (undefined if connected to remote environment) */
-  watcher: AnvilTestWatcher | undefined;
-  /** Allows tweaking current system time, used by the epoch cache only (undefined if connected to remote environment) */
-  dateProvider: TestDateProvider | undefined;
+  /** The anvil test watcher. */
+  watcher: AnvilTestWatcher;
+  /** Allows tweaking current system time, used by the epoch cache only. */
+  dateProvider: TestDateProvider;
   /** Telemetry client */
-  telemetryClient: TelemetryClient | undefined;
+  telemetryClient: TelemetryClient;
   /** Mock gossip sub network used for gossipping messages (only if mockGossipSubNetwork was set to true in opts) */
   mockGossipSubNetwork: MockGossipSubNetwork | undefined;
-  /** Prefilled public data used for setting up nodes. */
-  prefilledPublicData: PublicDataTreeLeaf[] | undefined;
+  /** Delayer for sequencer L1 txs (only when enableDelayer is true). */
+  sequencerDelayer: Delayer | undefined;
+  /** Delayer for prover node L1 txs (only when enableDelayer and startProverNode are true). */
+  proverDelayer: Delayer | undefined;
+  /** Genesis data used for setting up nodes. */
+  genesis: GenesisData | undefined;
   /** ACVM config (only set if running locally). */
   acvmConfig: Awaited<ReturnType<typeof getACVMConfig>>;
   /** BB config (only set if running locally). */
   bbConfig: Awaited<ReturnType<typeof getBBConfig>>;
   /** Directory to cleanup on teardown. */
-  directoryToCleanup: string | undefined;
+  directoryToCleanup: string;
   /** Function to stop the started services. */
   teardown: () => Promise<void>;
 };
 
 /**
- * Function to setup the test against a remote deployment. It is assumed that L1 contract are already deployed
+ * When CONTRACT_ARTIFACTS_VERSION is set (backwards compatibility testing), asserts that the loaded artifact's
+ * aztecVersion matches the expected version. This is a sanity check verifying that the legacy artifact resolver
+ * actually swapped in the correct version.
  */
-async function setupWithRemoteEnvironment(
-  account: HDAccount | PrivateKeyAccount,
-  config: AztecNodeConfig & SetupOptions,
-  logger: Logger,
-  numberOfAccounts: number,
-): Promise<EndToEndContext> {
-  const aztecNodeUrl = getAztecUrl();
-  logger.verbose(`Creating Aztec Node client to remote host ${aztecNodeUrl}`);
-  const aztecNode = createAztecNodeClient(aztecNodeUrl);
-  await waitForNode(aztecNode, logger);
-  logger.verbose('JSON RPC client connected to Aztec Node');
-  logger.verbose(`Retrieving contract addresses from ${aztecNodeUrl}`);
-  const { l1ContractAddresses, rollupVersion } = await aztecNode.getNodeInfo();
-
-  const l1Client = createExtendedL1Client(config.l1RpcUrls, account, foundry);
-
-  const deployL1ContractsValues: DeployAztecL1ContractsReturnType = {
-    l1ContractAddresses,
-    l1Client,
-    rollupVersion,
-  };
-  const ethCheatCodes = new EthCheatCodes(config.l1RpcUrls, new DateProvider());
-  const wallet = await TestWallet.create(aztecNode);
-
-  if (config.walletMinFeePadding !== undefined) {
-    wallet.setMinFeePadding(config.walletMinFeePadding);
+function assertContractArtifactsVersion() {
+  const expected = process.env.CONTRACT_ARTIFACTS_VERSION;
+  if (!expected) {
+    return;
   }
-
-  const cheatCodes = await CheatCodes.create(config.l1RpcUrls, aztecNode, new DateProvider());
-  const teardown = () => Promise.resolve();
-
-  logger.verbose('Populating wallet from already registered accounts...');
-  const initialFundedAccounts = await getInitialTestAccountsData();
-
-  if (initialFundedAccounts.length < numberOfAccounts) {
-    throw new Error(`Required ${numberOfAccounts} accounts. Found ${initialFundedAccounts.length}.`);
+  const { aztecVersion } = SponsoredFPCContract.artifact;
+  // TODO(F-557): Remove this bypass once pre-version artifacts are no longer tested.
+  if (aztecVersion === ARTIFACT_VERSION_BEFORE_INJECTION) {
+    createLogger('e2e:setup').info(
+      `Skipping artifact version check: artifact predates version injection (CONTRACT_ARTIFACTS_VERSION=${expected})`,
+    );
+    return;
+  }
+  if (aztecVersion !== expected) {
+    throw new Error(
+      `Artifact version mismatch: expected ${expected} but got ${aztecVersion}. ` +
+        `The legacy artifact resolver may not have swapped in the correct version.`,
+    );
   }
-
-  const testAccounts = await Promise.all(
-    initialFundedAccounts.slice(0, numberOfAccounts).map(async account => {
-      const accountManager = await wallet.createSchnorrAccount(account.secret, account.salt, account.signingKey);
-      return accountManager.address;
-    }),
-  );
-
-  return {
-    anvil: undefined,
-    aztecNode,
-    aztecNodeService: undefined,
-    aztecNodeAdmin: undefined,
-    sequencer: undefined,
-    proverNode: undefined,
-    deployL1ContractsValues,
-    config,
-    aztecNodeConfig: config,
-    initialFundedAccounts,
-    wallet,
-    accounts: testAccounts,
-    logger,
-    cheatCodes,
-    ethCheatCodes,
-    prefilledPublicData: undefined,
-    mockGossipSubNetwork: undefined,
-    watcher: undefined,
-    dateProvider: undefined,
-    telemetryClient: undefined,
-    acvmConfig: undefined,
-    bbConfig: undefined,
-    directoryToCleanup: undefined,
-    teardown,
-  };
 }
 
 /**
@@ -351,10 +317,11 @@ export async function setup(
   pxeOpts: Partial<PXEConfig> = {},
   chain: Chain = foundry,
 ): Promise<EndToEndContext> {
+  assertContractArtifactsVersion();
   let anvil: Anvil | undefined;
   try {
     opts.aztecTargetCommitteeSize ??= 0;
-    opts.slasherFlavor ??= 'none';
+    opts.slasherEnabled ??= false;
 
     const config: AztecNodeConfig & SetupOptions = { ...getConfigEnvVars(), ...opts };
     // use initialValidators for the node config
@@ -366,8 +333,12 @@ export async function setup(
     config.realProofs = !!opts.realProofs;
     // Only enforce the time table if requested
     config.enforceTimeTable = !!opts.enforceTimeTable;
+    // Enable the tx delayer for tests (default config has it disabled, so we force-enable it here)
+    config.enableDelayer = true;
     config.listenAddress = '127.0.0.1';
 
+    config.minTxPoolAgeMs = opts.minTxPoolAgeMs ?? 0;
+
     const logger = getLogger();
 
     // Create a temp directory for any services that need it and cleanup later
@@ -377,20 +348,18 @@ export async function setup(
       config.dataDirectory = directoryToCleanup;
     }
 
+    const dateProvider = new TestDateProvider();
+
     if (!config.l1RpcUrls?.length) {
       if (!isAnvilTestChain(chain.id)) {
         throw new Error(`No ETHEREUM_HOSTS set but non anvil chain requested`);
       }
-      if (AZTEC_NODE_URL) {
-        throw new Error(
-          `AZTEC_NODE_URL provided but no ETHEREUM_HOSTS set. Refusing to run, please set both variables so tests can deploy L1 contracts to the same Anvil instance`,
-        );
-      }
-
       const res = await startAnvil({
         l1BlockTime: opts.ethereumSlotDuration,
         accounts: opts.anvilAccounts,
         port: opts.anvilPort ?? (process.env.ANVIL_PORT ? parseInt(process.env.ANVIL_PORT) : undefined),
+        slotsInAnEpoch: opts.anvilSlotsInAnEpoch,
+        dateProvider,
       });
       anvil = res.anvil;
       config.l1RpcUrls = [res.rpcUrl];
@@ -402,8 +371,6 @@ export async function setup(
       logger.info(`Logging metrics to ${filename}`);
       setupMetricsLogger(filename);
     }
-
-    const dateProvider = new TestDateProvider();
     const ethCheatCodes = new EthCheatCodesWithState(config.l1RpcUrls, dateProvider);
 
     if (opts.stateLoad) {
@@ -421,11 +388,11 @@ export async function setup(
       publisherPrivKeyHex = opts.l1PublisherKey.getValue();
       publisherHdAccount = privateKeyToAccount(publisherPrivKeyHex);
     } else if (
-      config.publisherPrivateKeys &&
-      config.publisherPrivateKeys.length > 0 &&
-      config.publisherPrivateKeys[0].getValue() != NULL_KEY
+      config.sequencerPublisherPrivateKeys &&
+      config.sequencerPublisherPrivateKeys.length > 0 &&
+      config.sequencerPublisherPrivateKeys[0].getValue() != NULL_KEY
     ) {
-      publisherPrivKeyHex = config.publisherPrivateKeys[0].getValue();
+      publisherPrivKeyHex = config.sequencerPublisherPrivateKeys[0].getValue();
       publisherHdAccount = privateKeyToAccount(publisherPrivKeyHex);
     } else if (!MNEMONIC) {
       throw new Error(`Mnemonic not provided and no publisher private key`);
@@ -434,18 +401,13 @@ export async function setup(
       const publisherPrivKeyRaw = publisherHdAccount.getHdKey().privateKey;
       const publisherPrivKey = publisherPrivKeyRaw === null ? null : Buffer.from(publisherPrivKeyRaw);
       publisherPrivKeyHex = `0x${publisherPrivKey!.toString('hex')}` as const;
-      config.publisherPrivateKeys = [new SecretValue(publisherPrivKeyHex)];
+      config.sequencerPublisherPrivateKeys = [new SecretValue(publisherPrivKeyHex)];
     }
 
     if (config.coinbase === undefined) {
       config.coinbase = EthAddress.fromString(publisherHdAccount.address);
     }
 
-    if (AZTEC_NODE_URL) {
-      // we are setting up against a remote environment, l1 contracts are assumed to already be deployed
-      return await setupWithRemoteEnvironment(publisherHdAccount!, config, logger, numberOfAccounts);
-    }
-
     // Determine which addresses to fund in genesis
     const initialFundedAccounts =
       opts.initialFundedAccounts ??
@@ -458,10 +420,12 @@ export async function setup(
       addressesToFund.push(sponsoredFPCAddress);
     }
 
-    const { genesisArchiveRoot, prefilledPublicData, fundingNeeded } = await getGenesisValues(
+    const genesisTimestamp = BigInt(Math.floor(Date.now() / 1000));
+    const { genesisArchiveRoot, genesis, fundingNeeded } = await getGenesisValues(
       addressesToFund,
       opts.initialAccountFeeJuice,
       opts.genesisPublicData,
+      genesisTimestamp,
     );
 
     const wasAutomining = await ethCheatCodes.isAutoMining();
@@ -496,13 +460,37 @@ export async function setup(
       },
     );
 
-    config.l1Contracts = deployL1ContractsValues.l1ContractAddresses;
+    Object.assign(config, deployL1ContractsValues.l1ContractAddresses);
     config.rollupVersion = deployL1ContractsValues.rollupVersion;
 
+    // Propagate L1-contracts-config overrides back to the node config so the archiver's
+    // `l1Constants` (and any other node-side consumer) agrees with what was actually deployed.
+    // Without this, a per-test override like `aztecEpochDuration: 4` lands on the rollup contract
+    // but the node config keeps the default (32), so `archiver.isEpochComplete(0)` computes
+    // `endSlot=31` and `EpochTestSettler`/`EpochMonitor` never fires — letting the
+    // `aztecProofSubmissionEpochs` window expire mid-test and prune the pending chain.
+    // Skip undefined values: callers (e.g. `P2PNetworkTest`) sometimes build `l1ContractsArgs`
+    // by spreading a partial `AztecNodeConfig`, which leaves unset fields (notably `dataDirectory`)
+    // as `undefined`. A blind Object.assign would then clobber the temp `dataDirectory` set earlier
+    // in this function and crash `setupSharedBlobStorage`.
+    if (opts.l1ContractsArgs) {
+      for (const [key, value] of Object.entries(opts.l1ContractsArgs)) {
+        if (value !== undefined) {
+          (config as unknown as Record<string, unknown>)[key] = value;
+        }
+      }
+    }
+
     if (enableAutomine) {
       await ethCheatCodes.setAutomine(false);
       await ethCheatCodes.setIntervalMining(config.ethereumSlotDuration);
-      dateProvider.setTime((await ethCheatCodes.timestamp()) * 1000);
+    }
+
+    // In compose mode (no local anvil), sync dateProvider to L1 time since it may have drifted
+    // ahead of system time due to the local-network watcher warping time forward on each filled slot.
+    // When running with a local anvil, the dateProvider is kept in sync via the stdout listener.
+    if (!anvil) {
+      dateProvider.setTime((await ethCheatCodes.lastBlockTimestamp()) * 1000);
     }
 
     if (opts.l2StartTime) {
@@ -514,6 +502,7 @@ export async function setup(
       deployL1ContractsValues.l1ContractAddresses.rollupAddress,
       deployL1ContractsValues.l1Client,
       dateProvider,
+      opts.anvilTestWatcherOpts,
     );
     if (!opts.disableAnvilTestWatcher) {
       await watcher.start();
@@ -541,10 +530,10 @@ export async function setup(
     }
 
     let mockGossipSubNetwork: MockGossipSubNetwork | undefined;
-    let p2pClientDeps: P2PClientDeps<P2PClientType.Full> | undefined = undefined;
+    let p2pClientDeps: P2PClientDeps | undefined = undefined;
 
     if (opts.mockGossipSubNetwork) {
-      mockGossipSubNetwork = new MockGossipSubNetwork();
+      mockGossipSubNetwork = new MockGossipSubNetwork(opts.mockGossipSubNetworkLatency);
       p2pClientDeps = { p2pServiceFactory: getMockPubSubP2PServiceFactory(mockGossipSubNetwork) };
     }
 
@@ -557,11 +546,17 @@ export async function setup(
       throw new Error('minTxsPerBlock is undefined in e2e test setup');
     }
 
-    // Only set minTxsPerBlock=1 if we're going to deploy accounts and need reliable block inclusion
+    // Whether we're deploying accounts (and therefore need reliable block inclusion past genesis)
     const shouldDeployAccounts = numberOfAccounts > 0 && !opts.skipAccountDeployment;
     // Only set minTxsPerBlock=0 if we need an empty block (no accounts at all, not skipped deployment)
     const needsEmptyBlock = numberOfAccounts === 0 && !opts.skipAccountDeployment;
-    config.minTxsPerBlock = shouldDeployAccounts ? 1 : needsEmptyBlock ? 0 : originalMinTxsPerBlock;
+    // Pipelining is always on: the proposer builds during slot N-1 for slot N. A tx submitted at
+    // slot N start arrives after that build, so forcing minTxsPerBlock=1 would stall the chain on
+    // alternating slots -- hence empty checkpoints are allowed (minTxsPerBlock=0) for account
+    // deployment. Automine is unaffected: its runBuild clamps mempool builds to
+    // Math.max(minTxsPerBlock ?? 1, 1) and still requires minValidTxs: 1.
+    const accountsDeployMinTxs = 0;
+    config.minTxsPerBlock = shouldDeployAccounts ? accountsDeployMinTxs : needsEmptyBlock ? 0 : originalMinTxsPerBlock;
 
     config.p2pEnabled = opts.mockGossipSubNetwork || config.p2pEnabled;
     config.p2pIp = opts.p2pIp ?? config.p2pIp ?? '127.0.0.1';
@@ -572,52 +567,73 @@ export async function setup(
       }
     }
 
+    // When skipInitialSequencer is set, the initial node is a lightweight RPC-only node.
+    // We apply these overrides to a copy so they don't leak into the returned config.
+    // Keep P2P enabled if mockGossipSubNetwork is used (needed for tx propagation to validators).
+    const initialNodeConfig = opts.skipInitialSequencer
+      ? {
+          ...config,
+          disableValidator: true,
+          ...(opts.mockGossipSubNetwork ? {} : { p2pEnabled: false, bootstrapNodes: [] as string[] }),
+        }
+      : config;
+
     const aztecNodeService = await withLoggerBindings({ actor: 'node-0' }, () =>
       AztecNodeService.createAndSync(
-        config,
+        initialNodeConfig,
         { dateProvider, telemetry: telemetryClient, p2pClientDeps },
-        { prefilledPublicData },
+        { genesis, dontStartSequencer: opts.skipInitialSequencer },
       ),
     );
     const sequencerClient = aztecNodeService.getSequencer();
 
-    if (sequencerClient) {
-      const publisher = (sequencerClient as TestSequencerClient).sequencer.publisher;
-      publisher.l1TxUtils = DelayedTxUtils.fromL1TxUtils(publisher.l1TxUtils, config.ethereumSlotDuration, l1Client);
-    }
-
-    let proverNode: ProverNode | undefined = undefined;
+    let proverNode: AztecNodeService | undefined = undefined;
     if (opts.startProverNode) {
       logger.verbose('Creating and syncing a simulated prover node...');
       const proverNodePrivateKey = getPrivateKeyFromIndex(2);
       const proverNodePrivateKeyHex: Hex = `0x${proverNodePrivateKey!.toString('hex')}`;
       const proverNodeDataDirectory = path.join(directoryToCleanup, randomBytes(8).toString('hex'));
-      const proverNodeConfig = {
-        ...config.proverNodeConfig,
-        dataDirectory: proverNodeDataDirectory,
-        p2pEnabled: false,
+
+      const p2pClientDeps: Partial<P2PClientDeps> = {
+        p2pServiceFactory: mockGossipSubNetwork && getMockPubSubP2PServiceFactory(mockGossipSubNetwork!),
+        rpcTxProviders: [aztecNodeService],
       };
-      proverNode = await createAndSyncProverNode(
+
+      ({ proverNode } = await createAndSyncProverNode(
         proverNodePrivateKeyHex,
         config,
-        proverNodeConfig,
-        aztecNodeService,
-        prefilledPublicData,
-      );
+        {
+          ...config.proverNodeConfig,
+          dataDirectory: proverNodeDataDirectory,
+        },
+        { dateProvider, p2pClientDeps, telemetry: telemetryClient },
+        { genesis },
+      ));
     }
 
+    const sequencerDelayer = sequencerClient?.getDelayer();
+    const proverDelayer = proverNode?.getProverNode()?.getDelayer();
+
     logger.verbose('Creating a pxe...');
     const pxeConfig = { ...getPXEConfig(), ...pxeOpts };
     pxeConfig.dataDirectory = path.join(directoryToCleanup, randomBytes(8).toString('hex'));
     // For tests we only want proving enabled if specifically requested
     pxeConfig.proverEnabled = !!pxeOpts.proverEnabled;
-    const wallet = await TestWallet.create(aztecNodeService, pxeConfig, { loggerActorLabel: 'pxe-0' });
+    const wallet = await TestWallet.create(aztecNodeService, pxeConfig, {
+      loggerActorLabel: 'pxe-0',
+      ...opts.pxeCreationOptions,
+    });
 
     if (opts.walletMinFeePadding !== undefined) {
       wallet.setMinFeePadding(opts.walletMinFeePadding);
     }
 
-    const cheatCodes = await CheatCodes.create(config.l1RpcUrls, aztecNodeService, dateProvider);
+    const cheatCodes = await CheatCodes.create(
+      config.l1RpcUrls,
+      aztecNodeService,
+      dateProvider,
+      aztecNodeService.getAutomineSequencer(),
+    );
 
     if (
       (opts.aztecTargetCommitteeSize && opts.aztecTargetCommitteeSize > 0) ||
@@ -635,15 +651,22 @@ export async function setup(
 
     let accounts: AztecAddress[] = [];
 
-    if (shouldDeployAccounts) {
+    if (opts.skipInitialSequencer) {
+      logger.info('Sequencer not started on initial node, skipping block progression');
+    } else if (shouldDeployAccounts) {
       logger.info(
-        `${numberOfAccounts} accounts are being deployed. Reliably progressing past genesis by setting minTxsPerBlock to 1 and waiting for the accounts to be deployed`,
+        `${numberOfAccounts} accounts are being deployed. Reliably progressing past genesis by waiting for the accounts to be deployed`,
       );
       const accountsData = initialFundedAccounts.slice(0, numberOfAccounts);
       const accountManagers = await deployFundedSchnorrAccounts(wallet, accountsData);
       accounts = accountManagers.map(accountManager => accountManager.address);
     } else if (needsEmptyBlock) {
       logger.info('No accounts are being deployed, waiting for an empty block 1 to be mined');
+      // AutomineSequencer only builds on tx arrival; explicitly request an empty block.
+      const automine = aztecNodeService.getAutomineSequencer();
+      if (automine) {
+        await automine.buildEmptyBlock();
+      }
       while ((await aztecNodeService.getBlockNumber()) === 0) {
         await sleep(2000);
       }
@@ -683,7 +706,7 @@ export async function setup(
         logger.error(`Error during e2e test teardown`, err);
       } finally {
         try {
-          await telemetryClient?.stop();
+          await telemetryClient.stop();
         } catch (err) {
           logger.error(`Error during telemetry client stop`, err);
         }
@@ -704,8 +727,10 @@ export async function setup(
       initialFundedAccounts,
       logger,
       mockGossipSubNetwork,
-      prefilledPublicData,
+      genesis,
       proverNode,
+      sequencerDelayer,
+      proverDelayer,
       sequencer: sequencerClient,
       teardown,
       telemetryClient,
@@ -782,100 +807,62 @@ export async function waitForProvenChain(node: AztecNode, targetBlock?: BlockNum
   targetBlock ??= await node.getBlockNumber();
 
   await retryUntil(
-    async () => (await node.getProvenBlockNumber()) >= targetBlock,
+    async () => (await node.getBlockNumber('proven')) >= targetBlock,
     'proven chain status',
     timeoutSec,
     intervalSec,
   );
 }
 
+/**
+ * Creates an AztecNodeService with the prover node enabled as a subsystem.
+ * Returns both the aztec node service (for lifecycle management) and the prover node (for test internals access).
+ */
 export function createAndSyncProverNode(
   proverNodePrivateKey: `0x${string}`,
-  aztecNodeConfig: AztecNodeConfig,
-  proverNodeConfig: Partial<ProverNodeConfig> & Pick<DataStoreConfig, 'dataDirectory'> & { dontStart?: boolean },
-  aztecNode: AztecNode | undefined,
-  prefilledPublicData: PublicDataTreeLeaf[] = [],
-  proverNodeDeps: ProverNodeDeps = {},
-) {
+  baseConfig: AztecNodeConfig,
+  configOverrides: Pick<AztecNodeConfig, 'dataDirectory'>,
+  deps: {
+    telemetry?: TelemetryClient;
+    dateProvider: DateProvider;
+    p2pClientDeps?: P2PClientDeps;
+  },
+  options: { genesis?: GenesisData; dontStart?: boolean },
+): Promise<{ proverNode: AztecNodeService }> {
   return withLoggerBindings({ actor: 'prover-0' }, async () => {
-    const aztecNodeTxProvider = aztecNode && {
-      getTxByHash: aztecNode.getTxByHash.bind(aztecNode),
-      getTxsByHash: aztecNode.getTxsByHash.bind(aztecNode),
-      stop: () => Promise.resolve(),
-    };
-
-    const blobClient = await createBlobClientWithFileStores(aztecNodeConfig, createLogger('blob-client:prover-node'));
-
-    const archiverConfig = { ...aztecNodeConfig, dataDirectory: proverNodeConfig.dataDirectory };
-    const archiver = await createArchiver(
-      archiverConfig,
-      { blobClient, dateProvider: proverNodeDeps.dateProvider },
-      { blockUntilSync: true },
-    );
-
-    const proverConfig: ProverNodeConfig = {
-      ...aztecNodeConfig,
-      txCollectionNodeRpcUrls: [],
-      realProofs: false,
-      proverAgentCount: 2,
-      publisherPrivateKeys: [new SecretValue(proverNodePrivateKey)],
-      proverNodeMaxPendingJobs: 10,
-      proverNodeMaxParallelBlocksPerEpoch: 32,
-      proverNodePollingIntervalMs: 200,
-      txGatheringIntervalMs: 1000,
-      txGatheringBatchSize: 10,
-      txGatheringMaxParallelRequestsPerNode: 10,
-      txGatheringTimeoutMs: 24_000,
-      proverNodeFailedEpochStore: undefined,
-      proverId: EthAddress.fromNumber(1),
-      proverNodeEpochProvingDelayMs: undefined,
-      ...proverNodeConfig,
-    };
-
-    const l1TxUtils = createDelayedL1TxUtils(
-      aztecNodeConfig,
-      proverNodePrivateKey,
-      'prover-node',
-      proverNodeDeps.dateProvider,
+    const proverNode = await AztecNodeService.createAndSync(
+      {
+        ...baseConfig,
+        ...configOverrides,
+        p2pPort: 0,
+        enableProverNode: true,
+        disableValidator: true,
+        proverPublisherPrivateKeys: [new SecretValue(proverNodePrivateKey)],
+      },
+      deps,
+      { genesis: options.genesis, dontStartProverNode: options.dontStart },
     );
 
-    const proverNode = await createProverNode(
-      proverConfig,
-      { ...proverNodeDeps, aztecNodeTxProvider, archiver: archiver as Archiver, l1TxUtils },
-      { prefilledPublicData },
-    );
-    getLogger().info(`Created and synced prover node`, { publisherAddress: l1TxUtils.client.account!.address });
-    if (!proverNodeConfig.dontStart) {
-      await proverNode.start();
+    if (!proverNode.getProverNode()) {
+      throw new Error('Prover node subsystem was not created despite enableProverNode being set');
     }
-    return proverNode;
-  });
-}
 
-function createDelayedL1TxUtils(
-  aztecNodeConfig: AztecNodeConfig,
-  privateKey: `0x${string}`,
-  logName: string,
-  dateProvider?: DateProvider,
-) {
-  const l1Client = createExtendedL1Client(aztecNodeConfig.l1RpcUrls, privateKey, foundry);
-
-  const log = createLogger(logName);
-  const l1TxUtils = createDelayedL1TxUtilsFromViemWallet(l1Client, log, dateProvider, aztecNodeConfig);
-  l1TxUtils.enableDelayer(aztecNodeConfig.ethereumSlotDuration);
-  return l1TxUtils;
+    getLogger().info(`Created and synced prover node`);
+    return { proverNode };
+  });
 }
 
 export type BalancesFn = ReturnType<typeof getBalancesFn>;
 export function getBalancesFn(
   symbol: string,
   method: ContractMethod,
-  from: AztecAddress,
   logger: any,
 ): (...addresses: (AztecAddress | { address: AztecAddress })[]) => Promise<bigint[]> {
   const balances = async (...addressLikes: (AztecAddress | { address: AztecAddress })[]) => {
     const addresses = addressLikes.map(addressLike => ('address' in addressLike ? addressLike.address : addressLike));
-    const b = await Promise.all(addresses.map(address => method(address).simulate({ from })));
+    const b = await Promise.all(
+      addresses.map(async address => (await method(address).simulate({ from: address })).result),
+    );
     const debugString = `${symbol} balances: ${addresses.map((address, i) => `${address}: ${b[i]}`).join(', ')}`;
     logger.verbose(debugString);
     return b;
@@ -910,6 +897,57 @@ export async function expectMappingDelta<K, V extends number | bigint>(
   expect(diffs).toEqual(expectedDiffs);
 }
 
+/**
+ * Registers the auth_registry contract class and publishes its standard instance if not already
+ * present, and registers the artifact with PXE. Publishing is required before exercising the public
+ * authwit path (which relies on the AVM's deployment-nullifier check); the PXE-side registration is
+ * required so revert messages from AuthRegistry calls can be enriched (otherwise assertion strings
+ * surface as generic "Assertion failed:" and tests that match on the real message fail).
+ */
+export async function ensureAuthRegistryPublished(wallet: Wallet, from: AztecAddress) {
+  const { instance, contractClass } = await getStandardAuthRegistry();
+  if (!(await wallet.getContractClassMetadata(contractClass.id)).isContractClassPubliclyRegistered) {
+    await (await publishContractClass(wallet, AuthRegistryArtifact)).send({ from });
+  }
+  if (!(await wallet.getContractMetadata(instance.address)).isContractPublished) {
+    await publishInstance(wallet, instance).send({ from });
+  }
+  await wallet.registerContract(instance, AuthRegistryArtifact);
+}
+
+/**
+ * Registers the public_checks contract class and publishes its standard instance if not already
+ * present, and registers the artifact with PXE. Required for any contract that calls
+ * `privately_check_timestamp` / `privately_check_block_number` (which dispatch into the
+ * deployed PublicChecks contract via an enqueued public call).
+ */
+export async function ensurePublicChecksPublished(wallet: Wallet, from: AztecAddress) {
+  const { instance, contractClass } = await getStandardPublicChecks();
+  if (!(await wallet.getContractClassMetadata(contractClass.id)).isContractClassPubliclyRegistered) {
+    await (await publishContractClass(wallet, PublicChecksArtifact)).send({ from });
+  }
+  if (!(await wallet.getContractMetadata(instance.address)).isContractPublished) {
+    await publishInstance(wallet, instance).send({ from });
+  }
+  await wallet.registerContract(instance, PublicChecksArtifact);
+}
+
+/**
+ * Registers the handshake_registry contract class and publishes its standard instance if not
+ * already present, and registers the artifact with PXE. Required for constrained-delivery flows
+ * that call into the HandshakeRegistry at its well-known address.
+ */
+export async function ensureHandshakeRegistryPublished(wallet: Wallet, from: AztecAddress) {
+  const { instance, contractClass } = await getStandardHandshakeRegistry();
+  if (!(await wallet.getContractClassMetadata(contractClass.id)).isContractClassPubliclyRegistered) {
+    await (await publishContractClass(wallet, HandshakeRegistryArtifact)).send({ from });
+  }
+  if (!(await wallet.getContractMetadata(instance.address)).isContractPublished) {
+    await publishInstance(wallet, instance).send({ from });
+  }
+  await wallet.registerContract(instance, HandshakeRegistryArtifact);
+}
+
 /**
  * Registers the contract class used for test accounts and publicly deploys the instances requested.
  * Use this when you need to make a public call to an account contract, such as for requesting a public authwit.
@@ -944,7 +982,7 @@ export async function ensureAccountContractsPublished(wallet: Wallet, accountsTo
  * Returns deployed account data that can be used by tests.
  */
 export const deployAccounts =
-  (numberOfAccounts: number, logger: Logger) =>
+  (numberOfAccounts: number, logger: Logger, deployOptions?: Partial<DeployOptions<InteractionWaitOptions>>) =>
   async ({ wallet, initialFundedAccounts }: { wallet: TestWallet; initialFundedAccounts: InitialAccountData[] }) => {
     if (initialFundedAccounts.length < numberOfAccounts) {
       throw new Error(`Cannot deploy more than ${initialFundedAccounts.length} initial accounts.`);
@@ -961,8 +999,9 @@ export const deployAccounts =
       );
       const deployMethod = await accountManager.getDeployMethod();
       await deployMethod.send({
-        from: AztecAddress.ZERO,
+        from: NO_FROM,
         skipClassPublication: i !== 0, // Publish the contract class at most once.
+        ...deployOptions,
       });
     }
 
@@ -993,7 +1032,7 @@ export async function publicDeployAccounts(
 
   const batch = new BatchCall(wallet, calls);
 
-  const txReceipt = await batch.send({ from: accountsToDeploy[0] });
+  const { receipt: txReceipt } = await batch.send({ from: accountsToDeploy[0] });
   if (waitUntilProven) {
     if (!node) {
       throw new Error('Need to provide an AztecNode to wait for proven.');