@aztec/end-to-end 0.0.1-commit.4d79d1f2d → 0.0.1-commit.4d9804df

package/src/fixtures/setup.ts

@@ -1,22 +1,13 @@
-import { SchnorrAccountContractArtifact } from '@aztec/accounts/schnorr';
 import { type InitialAccountData, generateSchnorrAccounts } from '@aztec/accounts/testing';
-import { type Archiver, createArchiver } from '@aztec/archiver';
-import { type AztecNodeConfig, AztecNodeService, getConfigEnvVars } from '@aztec/aztec-node';
+import { type AztecNodeConfig, AztecNodeService, createAztecNodeService, getConfigEnvVars } from '@aztec/aztec-node';
 import { AztecAddress, EthAddress } from '@aztec/aztec.js/addresses';
-import {
-  BatchCall,
-  type ContractFunctionInteraction,
-  type ContractMethod,
-  getContractClassFromArtifact,
-  waitForProven,
-} from '@aztec/aztec.js/contracts';
+import type { ContractMethod } 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 } 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 { 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,36 +21,34 @@ 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, warmBlobKzg } from '@aztec/ethereum/test';
+import type { Anvil } from '@aztec/ethereum/test';
+import type { ExtendedViemWalletClient } from '@aztec/ethereum/types';
 import { BlockNumber, EpochNumber } from '@aztec/foundation/branded-types';
 import { SecretValue } from '@aztec/foundation/config';
 import { randomBytes } from '@aztec/foundation/crypto/random';
 import { tryRmDir } from '@aztec/foundation/fs';
 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 +56,9 @@ import {
   initTelemetryClient,
 } from '@aztec/telemetry-client';
 import { BenchmarkTelemetryClient } from '@aztec/telemetry-client/bench';
-import { deployFundedSchnorrAccounts } from '@aztec/wallets/testing';
+import { createFundedInitializerlessAccounts } 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';
@@ -89,6 +77,7 @@ import { MNEMONIC, TEST_MAX_PENDING_TX_POOL_COUNT, TEST_PEER_CHECK_INTERVAL_MS }
 import { getACVMConfig } from './get_acvm_config.js';
 import { getBBConfig } from './get_bb_config.js';
 import { isMetricsLoggingRequested, setupMetricsLogger } from './logging.js';
+import { testSpan } from './timing.js';
 import { getEndToEndTestTelemetryClient } from './with_telemetry_utils.js';
 
 export { startAnvil };
@@ -121,6 +110,8 @@ export async function setupSharedBlobStorage(config: { dataDirectory?: string }
 /**
  * Sets up Private eXecution Environment (PXE) and returns the corresponding test wallet.
  * @param aztecNode - An instance of Aztec Node.
+ * @param nodeDebug - The node's debug API, used to register public function signatures for named traces; pass
+ *   `undefined` when the node does not expose it.
  * @param opts - Partial configuration for the PXE.
  * @param logger - The logger to be used.
  * @param actor - Actor label to include in log output (e.g., 'pxe-test').
@@ -128,6 +119,7 @@ export async function setupSharedBlobStorage(config: { dataDirectory?: string }
  */
 export async function setupPXEAndGetWallet(
   aztecNode: AztecNode,
+  nodeDebug: AztecNodeDebug | undefined,
   opts: Partial<PXEConfig> = {},
   logger = getLogger(),
   actor?: string,
@@ -148,7 +140,10 @@ export async function setupPXEAndGetWallet(
 
   const teardown = configuredDataDirectory ? () => Promise.resolve() : () => tryRmDir(PXEConfig.dataDirectory!);
 
-  const wallet = await TestWallet.create(aztecNode, PXEConfig, { loggerActorLabel: actor });
+  const wallet = await TestWallet.create(aztecNode, PXEConfig, {
+    loggerActorLabel: actor,
+    nodeDebug,
+  });
 
   return {
     wallet,
@@ -158,7 +153,7 @@ export async function setupPXEAndGetWallet(
 }
 
 /** Options for the e2e tests setup */
-export type SetupOptions = {
+export type SetupOptions<TDeployExtraL1ContractsReturnType = unknown> = {
   /** State load */
   stateLoad?: string;
   /** Whether to enable metrics collection, if undefined, metrics collection is disabled */
@@ -167,10 +162,11 @@ export type SetupOptions = {
   deployL1ContractsValues?: DeployAztecL1ContractsReturnType;
   /** Initial fee juice for default accounts */
   initialAccountFeeJuice?: Fr;
-  /** Number of initial accounts funded with fee juice */
-  numberOfInitialFundedAccounts?: number;
-  /** Data of the initial funded accounts */
-  initialFundedAccounts?: InitialAccountData[];
+  /**
+   * Extra accounts to fund at genesis beyond the `numberOfAccounts` initializerless accounts that setup
+   * creates. Setup funds these but does NOT create or deploy them — the test creates/deploys them itself
+   */
+  additionallyFundedAccounts?: InitialAccountData[];
   /** An initial set of validators */
   initialValidators?: (Operator & { privateKey: `0x${string}` })[];
   /** Anvil Start time */
@@ -187,40 +183,69 @@ export type SetupOptions = {
   proverNodeConfig?: Partial<ProverNodeConfig>;
   /** Whether to use a mock gossip sub network for p2p clients. */
   mockGossipSubNetwork?: boolean;
-  /** Whether to disable the anvil test watcher (can still be manually started) */
-  disableAnvilTestWatcher?: boolean;
-  /** Whether to enable anvil automine during deployment of L1 contracts (consider defaulting this to true). */
+  /** Whether to add simulated latency to the mock gossipsub network (in ms) */
+  mockGossipSubNetworkLatency?: number;
+  /**
+   * Whether to mine the L1 setup txs (Multicall3 + rollup contract deployment) under anvil automine
+   * instead of waiting on the block interval. Defaults to `true` (set in `setupInner`); only suites
+   * that assert on genesis-relative L1 timing need to opt out with `false`.
+   */
   automineL1Setup?: boolean;
+  /**
+   * Hook invoked after the Aztec L1 rollup contracts are deployed but BEFORE the node/sequencer
+   * start, while anvil automine is still enabled (when `automineL1Setup` is true, the default).
+   * Deploy extra L1 contracts a test needs here (e.g. a cross-chain token portal + ERC20) so they
+   * mine instantly under automine instead of paying the L1 block interval once the node is running
+   * (and racing the live sequencer/archiver). The resolved value is exposed on the returned context
+   * as `extraL1DeployResult`. The hook receives setup's L1 deployer client (the same one used to
+   * deploy Multicall3).
+   */
+  deployExtraL1Contracts?: (deps: {
+    l1Client: ExtendedViemWalletClient;
+    deployL1ContractsValues: DeployAztecL1ContractsReturnType;
+    logger: Logger;
+  }) => Promise<TDeployExtraL1ContractsReturnType>;
   /** 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) */
   zkPassportArgs?: ZKPassportArgs;
   /** Whether to fund the sponsored FPC in genesis (defaults to false). */
   fundSponsoredFPC?: boolean;
-  /** Whether to skip deploying accounts during setup (legacy behavior for tests using deployAccounts helper). */
-  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 */
-export type EndToEndContext = {
+export type EndToEndContext<TDeployExtraL1ContractsReturnType = unknown> = {
   /** 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;
+  aztecNode: AztecNode & AztecNodeDebug;
   /** The Aztec Node as a service. */
   aztecNodeService: AztecNodeService;
   /** Client to the Aztec Node admin interface. */
   aztecNodeAdmin: AztecNodeAdmin;
-  /** The prover node service (only set if startProverNode is true) */
-  proverNode: ProverNode | undefined;
+  /** 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. */
@@ -229,8 +254,8 @@ export type EndToEndContext = {
   config: AztecNodeConfig;
   /** The Aztec Node configuration (alias for config for backward compatibility). */
   aztecNodeConfig: AztecNodeConfig;
-  /** The data for the initial funded accounts. */
-  initialFundedAccounts: InitialAccountData[];
+  /** Data for the extra accounts funded at genesis but not created by setup (the test creates/deploys them). */
+  additionallyFundedAccounts: InitialAccountData[];
   /** The wallet to be used. */
   wallet: TestWallet;
   /** The wallets to be used. */
@@ -241,16 +266,20 @@ export type EndToEndContext = {
   cheatCodes: CheatCodes;
   /** The cheat codes for L1 */
   ethCheatCodes: EthCheatCodes;
-  /** The anvil test watcher. */
-  watcher: AnvilTestWatcher;
   /** Allows tweaking current system time, used by the epoch cache only. */
   dateProvider: TestDateProvider;
   /** Telemetry client */
   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;
+  /** Resolved value of the `deployExtraL1Contracts` setup hook, if one was provided. */
+  extraL1DeployResult: TDeployExtraL1ContractsReturnType;
   /** ACVM config (only set if running locally). */
   acvmConfig: Awaited<ReturnType<typeof getACVMConfig>>;
   /** BB config (only set if running locally). */
@@ -261,22 +290,75 @@ export type EndToEndContext = {
   teardown: () => Promise<void>;
 };
 
+/**
+ * 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.
+ */
+function assertContractArtifactsVersion() {
+  const expected = process.env.CONTRACT_ARTIFACTS_VERSION;
+  if (!expected) {
+    return;
+  }
+  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.`,
+    );
+  }
+}
+
 /**
  * Sets up the environment for the end-to-end tests.
  * @param numberOfAccounts - The number of new accounts to be created once the PXE is initiated.
  * @param opts - Options to pass to the node initialization and to the setup script.
  * @param pxeOpts - Options to pass to the PXE initialization.
  */
-export async function setup(
+export function setup<TDeployExtraL1ContractsReturnType = unknown>(
   numberOfAccounts = 1,
-  opts: SetupOptions = {},
+  opts: SetupOptions<TDeployExtraL1ContractsReturnType> = {},
   pxeOpts: Partial<PXEConfig> = {},
   chain: Chain = foundry,
-): Promise<EndToEndContext> {
+): Promise<EndToEndContext<TDeployExtraL1ContractsReturnType>> {
+  // Tag the top-level env spin-up with the prover mode (none → fake → real), the largest config-driven
+  // swing in setup cost, so the three factories are comparable on the span leaderboard. The internals
+  // (anvil / l1-deploy / sequencer-start / pxe / wallet:create) decompose this further.
+  const proverMode = opts.realProofs ? 'real' : opts.startProverNode ? 'fake' : 'none';
+  return testSpan(`setup:env:${proverMode}`, async () => {
+    const ctx = await setupInner(numberOfAccounts, opts, pxeOpts, chain);
+    if (process.env.EXIT_E2E_AFTER_SETUP) {
+      ctx.logger.info('EXIT_E2E_AFTER_SETUP is set; aborting before the test body runs');
+      throw new Error('EXIT_E2E_AFTER_SETUP');
+    }
+    return ctx;
+  });
+}
+
+async function setupInner<TDeployExtraL1ContractsReturnType = unknown>(
+  numberOfAccounts: number,
+  opts: SetupOptions<TDeployExtraL1ContractsReturnType>,
+  pxeOpts: Partial<PXEConfig>,
+  chain: Chain,
+): Promise<EndToEndContext<TDeployExtraL1ContractsReturnType>> {
+  assertContractArtifactsVersion();
+  const logger = getLogger();
   let anvil: Anvil | undefined;
   try {
     opts.aztecTargetCommitteeSize ??= 0;
-    opts.slasherFlavor ??= 'none';
+    opts.slasherEnabled ??= false;
+    // Mine the L1 setup txs (Multicall3 + rollup contract deployment) immediately instead of
+    // waiting on anvil's block interval — this is the dominant cost of e2e setup. Suites that
+    // assert on genesis-relative L1 timing can opt out by passing `automineL1Setup: false`.
+    opts.automineL1Setup ??= true;
+    logger.trace('Starting e2e test setup');
 
     const config: AztecNodeConfig & SetupOptions = { ...getConfigEnvVars(), ...opts };
     // use initialValidators for the node config
@@ -286,11 +368,11 @@ export async function setup(
     config.maxPendingTxCount = opts.maxPendingTxCount ?? TEST_MAX_PENDING_TX_POOL_COUNT;
     // For tests we only want proving enabled if specifically requested
     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';
 
-    const logger = getLogger();
+    config.minTxPoolAgeMs = opts.minTxPoolAgeMs ?? 0;
 
     // Create a temp directory for any services that need it and cleanup later
     const directoryToCleanup = path.join(tmpdir(), randomBytes(8).toString('hex'));
@@ -299,18 +381,25 @@ 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`);
       }
-      const res = await startAnvil({
-        l1BlockTime: opts.ethereumSlotDuration,
-        accounts: opts.anvilAccounts,
-        port: opts.anvilPort ?? (process.env.ANVIL_PORT ? parseInt(process.env.ANVIL_PORT) : undefined),
-      });
+      const res = await testSpan('setup:env:anvil', () =>
+        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];
     }
+    logger.trace('Started anvil and L1 RPC client');
 
     // Enable logging metrics to a local file named after the test suite
     if (isMetricsLoggingRequested()) {
@@ -318,8 +407,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) {
@@ -329,6 +416,7 @@ export async function setup(
     if (opts.l1StartTime) {
       await ethCheatCodes.warp(opts.l1StartTime, { resetBlockInterval: true });
     }
+    logger.trace('Initialized L1 cheat codes and applied state/time overrides');
 
     let publisherPrivKeyHex: `0x${string}` | undefined = undefined;
     let publisherHdAccount: HDAccount | PrivateKeyAccount | undefined = undefined;
@@ -337,11 +425,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`);
@@ -350,30 +438,36 @@ 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);
     }
+    logger.trace('Resolved L1 publisher account');
 
-    // Determine which addresses to fund in genesis
-    const initialFundedAccounts =
-      opts.initialFundedAccounts ??
-      (await generateSchnorrAccounts(opts.numberOfInitialFundedAccounts ?? Math.max(numberOfAccounts, 10)));
-    const addressesToFund = initialFundedAccounts.map(a => a.address);
+    // The accounts setup creates itself: `numberOfAccounts` initializerless accounts, generated here and
+    // funded at genesis so they are immediately usable.
+    const defaultAccounts = await generateSchnorrAccounts(numberOfAccounts);
+    // Extra accounts the test wants funded at genesis but will create/deploy itself.
+    const additionallyFundedAccounts = opts.additionallyFundedAccounts ?? [];
+    const addressesToFund = [...defaultAccounts, ...additionallyFundedAccounts].map(a => a.address);
 
     // Optionally fund the sponsored FPC
     if (opts.fundSponsoredFPC) {
       const sponsoredFPCAddress = await getSponsoredFPCAddress();
       addressesToFund.push(sponsoredFPCAddress);
     }
+    logger.trace('Generated test accounts to fund at genesis');
 
-    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,
     );
+    logger.trace('Computed genesis values');
 
     const wasAutomining = await ethCheatCodes.isAutoMining();
     const enableAutomine = opts.automineL1Setup && !wasAutomining && isAnvilTestChain(chain.id);
@@ -383,18 +477,21 @@ export async function setup(
 
     const l1Client = createExtendedL1Client(config.l1RpcUrls, publisherHdAccount!, chain);
 
+    // Warm both KZG trusted setups (ours + anvil's) in parallel
+    if (anvil && isAnvilTestChain(chain.id)) {
+      await warmBlobKzg(l1Client, logger);
+    }
+
     // Deploy Multicall3 if running locally
     await deployMulticall3(l1Client, logger);
 
     // Force viem to refresh its nonce cache to avoid "nonce too low" errors in subsequent transactions
     // This is necessary because deployMulticall3 sends multiple transactions and viem may cache a stale nonce
     await l1Client.getTransactionCount({ address: l1Client.account.address });
+    logger.trace('Deployed Multicall3');
 
-    const deployL1ContractsValues: DeployAztecL1ContractsReturnType = await deployAztecL1Contracts(
-      config.l1RpcUrls[0],
-      publisherPrivKeyHex!,
-      chain.id,
-      {
+    const deployL1ContractsValues: DeployAztecL1ContractsReturnType = await testSpan('setup:env:l1-deploy', () =>
+      deployAztecL1Contracts(config.l1RpcUrls[0], publisherPrivKeyHex!, chain.id, {
         ...getL1ContractsConfigEnvVars(),
         ...opts,
         ...opts.l1ContractsArgs,
@@ -404,76 +501,96 @@ export async function setup(
         initialValidators: opts.initialValidators,
         feeJuicePortalInitialBalance: fundingNeeded,
         realVerifier: false,
-      },
+      }),
     );
 
-    config.l1Contracts = deployL1ContractsValues.l1ContractAddresses;
+    Object.assign(config, deployL1ContractsValues.l1ContractAddresses);
     config.rollupVersion = deployL1ContractsValues.rollupVersion;
 
-    if (enableAutomine) {
-      await ethCheatCodes.setAutomine(false);
-      await ethCheatCodes.setIntervalMining(config.ethereumSlotDuration);
-      dateProvider.setTime((await ethCheatCodes.timestamp()) * 1000);
+    // 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 (opts.l2StartTime) {
-      await ethCheatCodes.warp(opts.l2StartTime, { resetBlockInterval: true });
+    // Deploy any test-specific L1 contracts while automine is still on and before the node starts,
+    // so they mine instantly rather than paying the L1 block interval once the sequencer is live.
+    let extraL1DeployResult: TDeployExtraL1ContractsReturnType = undefined as TDeployExtraL1ContractsReturnType;
+    if (opts.deployExtraL1Contracts) {
+      logger.trace('Running deployExtraL1Contracts hook');
+      extraL1DeployResult = await opts.deployExtraL1Contracts({
+        l1Client,
+        deployL1ContractsValues,
+        logger,
+      });
+      // The hook reused `l1Client` to send deploy txs, so refresh viem's nonce cache to avoid a
+      // stale cached nonce for later transactions on the publisher account.
+      await l1Client.getTransactionCount({ address: l1Client.account.address });
     }
 
-    const watcher = new AnvilTestWatcher(
-      new EthCheatCodesWithState(config.l1RpcUrls, dateProvider),
-      deployL1ContractsValues.l1ContractAddresses.rollupAddress,
-      deployL1ContractsValues.l1Client,
-      dateProvider,
-    );
-    if (!opts.disableAnvilTestWatcher) {
-      await watcher.start();
+    if (enableAutomine) {
+      await ethCheatCodes.startIntervalMiningWithFreshBlock(config.ethereumSlotDuration);
     }
 
-    // Use metricsPort-based telemetry if provided, otherwise use the regular telemetry client
-    const telemetryClient = opts.metricsPort
-      ? await getEndToEndTestTelemetryClient(opts.metricsPort)
-      : await getTelemetryClient(opts.telemetryConfig);
-
-    await setupSharedBlobStorage(config);
+    // In compose mode (no local anvil), sync dateProvider to L1 time since it may have drifted
+    // ahead of system time. When running with a local anvil, the dateProvider is kept in sync via
+    // the stdout listener.
+    if (!anvil) {
+      dateProvider.setTime((await ethCheatCodes.lastBlockTimestamp()) * 1000);
+    }
 
-    logger.verbose('Creating and synching an aztec node', config);
+    if (opts.l2StartTime) {
+      await ethCheatCodes.warp(opts.l2StartTime, { resetBlockInterval: true });
+    }
+    logger.trace('Deployed L1 rollup contracts');
+
+    // These boot steps are independent and write disjoint config keys, so run them concurrently:
+    // telemetry returns a client (no config write), shared blob storage writes blobFileStore* keys,
+    // and the ACVM/BB config resolvers write their own acvm*/bb* keys.
+    const [telemetryClient, , acvmConfig, bbConfig] = await Promise.all([
+      // Use metricsPort-based telemetry if provided, otherwise use the regular telemetry client
+      opts.metricsPort ? getEndToEndTestTelemetryClient(opts.metricsPort) : getTelemetryClient(opts.telemetryConfig),
+      setupSharedBlobStorage(config),
+      getACVMConfig(logger),
+      getBBConfig(logger),
+    ]);
+    logger.trace('Created telemetry client');
+    logger.trace('Set up shared blob storage');
 
-    const acvmConfig = await getACVMConfig(logger);
     if (acvmConfig) {
       config.acvmWorkingDirectory = acvmConfig.acvmWorkingDirectory;
       config.acvmBinaryPath = acvmConfig.acvmBinaryPath;
     }
+    logger.trace('Resolved ACVM config');
 
-    const bbConfig = await getBBConfig(logger);
     if (bbConfig) {
       config.bbBinaryPath = bbConfig.bbBinaryPath;
       config.bbWorkingDirectory = bbConfig.bbWorkingDirectory;
     }
+    logger.trace('Resolved Barretenberg config');
+
+    logger.verbose('Creating and synching an aztec node', config);
 
     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) };
     }
 
-    // Transactions built against the genesis state must be included in block 1, otherwise they are dropped.
-    // To avoid test failures from dropped transactions, we ensure progression beyond genesis before proceeding.
-    // For account deployments, we set minTxsPerBlock=1 and deploy accounts sequentially for guaranteed success.
-    // If no accounts need deployment, we await an empty block to confirm network progression.
-    const originalMinTxsPerBlock = config.minTxsPerBlock;
-    if (originalMinTxsPerBlock === undefined) {
-      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
-    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;
-
     config.p2pEnabled = opts.mockGossipSubNetwork || config.p2pEnabled;
     config.p2pIp = opts.p2pIp ?? config.p2pIp ?? '127.0.0.1';
 
@@ -483,57 +600,81 @@ export async function setup(
       }
     }
 
-    const aztecNodeService = await withLoggerBindings({ actor: 'node-0' }, () =>
-      AztecNodeService.createAndSync(
-        config,
-        { dateProvider, telemetry: telemetryClient, p2pClientDeps },
-        { prefilledPublicData },
+    // 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;
+    logger.trace('Prepared aztec node config');
+
+    const aztecNodeService = await testSpan('setup:env:sequencer-start', () =>
+      withLoggerBindings({ actor: 'node-0' }, () =>
+        createAztecNodeService(
+          initialNodeConfig,
+          { dateProvider, telemetry: telemetryClient, p2pClientDeps },
+          { genesis, dontStartSequencer: opts.skipInitialSequencer },
+        ),
       ),
     );
     const sequencerClient = aztecNodeService.getSequencer();
+    logger.trace('Created and synced aztec node');
 
-    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: !!mockGossipSubNetwork,
+
+      const p2pClientDeps: Partial<P2PClientDeps> = {
+        p2pServiceFactory: mockGossipSubNetwork && getMockPubSubP2PServiceFactory(mockGossipSubNetwork!),
+        rpcTxProviders: [aztecNodeService],
       };
-      proverNode = await createAndSyncProverNode(
-        proverNodePrivateKeyHex,
-        config,
-        proverNodeConfig,
-        aztecNodeService,
-        prefilledPublicData,
-        {
-          p2pClientDeps: mockGossipSubNetwork
-            ? { p2pServiceFactory: getMockPubSubP2PServiceFactory(mockGossipSubNetwork) }
-            : undefined,
-        },
-      );
+
+      ({ proverNode } = await testSpan('setup:env:prover-node', () =>
+        createAndSyncProverNode(
+          proverNodePrivateKeyHex,
+          config,
+          {
+            ...config.proverNodeConfig,
+            dataDirectory: proverNodeDataDirectory,
+          },
+          { dateProvider, p2pClientDeps, telemetry: telemetryClient },
+          { genesis },
+        ),
+      ));
+      logger.trace('Created prover node');
     }
 
+    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 testSpan('setup:env:pxe', () =>
+      TestWallet.create(aztecNodeService, pxeConfig, {
+        loggerActorLabel: 'pxe-0',
+        // In-process node implements the debug API, so register public function signatures for named traces.
+        nodeDebug: aztecNodeService,
+        ...opts.pxeCreationOptions,
+      }),
+    );
 
     if (opts.walletMinFeePadding !== undefined) {
       wallet.setMinFeePadding(opts.walletMinFeePadding);
     }
+    logger.trace('Created PXE and test wallet');
 
     const cheatCodes = await CheatCodes.create(config.l1RpcUrls, aztecNodeService, dateProvider);
+    logger.trace('Created cheat codes');
 
     if (
       (opts.aztecTargetCommitteeSize && opts.aztecTargetCommitteeSize > 0) ||
@@ -547,64 +688,48 @@ export async function setup(
       );
       await cheatCodes.rollup.setupEpoch();
       await cheatCodes.rollup.debugRollup();
+      logger.trace('Advanced chain to set up validator committee');
     }
 
     let accounts: AztecAddress[] = [];
 
-    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`,
-      );
-      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');
-      while ((await aztecNodeService.getBlockNumber()) === 0) {
-        await sleep(2000);
-      }
+    // Create the default accounts. They are initializerless, so this is a PXE-side operation (registration
+    // + a simulated store call) with no on-chain tx, independent of the sequencer.
+    if (numberOfAccounts > 0) {
+      logger.info(`Creating ${numberOfAccounts} initializerless test accounts`);
+      await testSpan('wallet:create', () => createFundedInitializerlessAccounts(wallet, defaultAccounts));
+      accounts = defaultAccounts.map(a => a.address);
     }
-    // If skipAccountDeployment is true, we don't deploy or wait - tests will handle account deployment later
+    logger.trace('Created funded test accounts');
 
-    // Now we restore the original minTxsPerBlock setting if we changed it.
-    if (sequencerClient && config.minTxsPerBlock !== originalMinTxsPerBlock) {
-      sequencerClient.getSequencer().updateConfig({ minTxsPerBlock: originalMinTxsPerBlock });
-    }
-
-    if (initialFundedAccounts.length < numberOfAccounts) {
-      throw new Error(
-        `Unable to deploy ${numberOfAccounts} accounts. Only ${initialFundedAccounts.length} accounts were funded.`,
-      );
-    }
-
-    const teardown = async () => {
-      try {
-        await tryStop(wallet, logger);
-        await tryStop(aztecNodeService, logger);
-        await tryStop(proverNode, logger);
+    const teardown = () =>
+      testSpan('teardown:env', async () => {
+        try {
+          await tryStop(wallet, logger);
+          await tryStop(aztecNodeService, logger);
+          await tryStop(proverNode, logger);
 
-        if (acvmConfig?.cleanup) {
-          await acvmConfig.cleanup();
-        }
+          if (acvmConfig?.cleanup) {
+            await acvmConfig.cleanup();
+          }
 
-        if (bbConfig?.cleanup) {
-          await bbConfig.cleanup();
-        }
+          if (bbConfig?.cleanup) {
+            await bbConfig.cleanup();
+          }
 
-        await tryStop(watcher, logger);
-        await tryStop(anvil, logger);
+          await tryStop(anvil, logger);
 
-        await tryRmDir(directoryToCleanup, logger);
-      } catch (err) {
-        logger.error(`Error during e2e test teardown`, err);
-      } finally {
-        try {
-          await telemetryClient.stop();
+          await tryRmDir(directoryToCleanup, logger);
         } catch (err) {
-          logger.error(`Error during telemetry client stop`, err);
+          logger.error(`Error during e2e test teardown`, err);
+        } finally {
+          try {
+            await telemetryClient.stop();
+          } catch (err) {
+            logger.error(`Error during telemetry client stop`, err);
+          }
         }
-      }
-    };
+      });
 
     return {
       anvil,
@@ -617,17 +742,19 @@ export async function setup(
       aztecNodeConfig: config,
       dateProvider,
       deployL1ContractsValues,
-      initialFundedAccounts,
+      additionallyFundedAccounts,
       logger,
       mockGossipSubNetwork,
-      prefilledPublicData,
+      genesis,
+      extraL1DeployResult,
       proverNode,
+      sequencerDelayer,
+      proverDelayer,
       sequencer: sequencerClient,
       teardown,
       telemetryClient,
       wallet,
       accounts,
-      watcher,
       acvmConfig,
       bbConfig,
       directoryToCleanup,
@@ -694,92 +821,58 @@ export async function registerSponsoredFPC(wallet: Wallet): Promise<void> {
   await wallet.registerContract(await getSponsoredFPCInstance(), SponsoredFPCContract.artifact);
 }
 
-export async function waitForProvenChain(node: AztecNode, targetBlock?: BlockNumber, timeoutSec = 60, intervalSec = 1) {
+export async function waitForProvenChain(
+  node: AztecNode,
+  targetBlock?: BlockNumber,
+  timeoutSec = 60,
+  intervalSec = 0.25,
+) {
   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 createAztecNodeService(
+      {
+        ...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>;
@@ -790,7 +883,9 @@ export function getBalancesFn(
 ): (...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: address })));
+    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;
@@ -826,96 +921,56 @@ export async function expectMappingDelta<K, V extends number | bigint>(
 }
 
 /**
- * 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.
+ * 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 ensureAccountContractsPublished(wallet: Wallet, accountsToDeploy: AztecAddress[]) {
-  const accountsAndAddresses = await Promise.all(
-    accountsToDeploy.map(async address => {
-      return {
-        address,
-        deployed: (await wallet.getContractMetadata(address)).isContractPublished,
-      };
-    }),
-  );
-  const instances = (
-    await Promise.all(
-      accountsAndAddresses
-        .filter(({ deployed }) => !deployed)
-        .map(({ address }) => wallet.getContractMetadata(address)),
-    )
-  ).map(contractMetadata => contractMetadata.instance);
-  const contractClass = await getContractClassFromArtifact(SchnorrAccountContractArtifact);
-  if (!(await wallet.getContractClassMetadata(contractClass.id)).isContractClassPubliclyRegistered) {
-    await (await publishContractClass(wallet, SchnorrAccountContractArtifact)).send({ from: accountsToDeploy[0] });
-  }
-  const requests = instances.map(instance => publishInstance(wallet, instance!));
-  const batch = new BatchCall(wallet, requests);
-  await batch.send({ from: accountsToDeploy[0] });
+export async function ensureAuthRegistryPublished(wallet: Wallet, from: AztecAddress) {
+  await testSpan('setup:auth-registry', async () => {
+    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);
+  });
 }
 
 /**
- * Helper function to deploy accounts.
- * Returns deployed account data that can be used by tests.
+ * 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 const deployAccounts =
-  (numberOfAccounts: number, logger: Logger) =>
-  async ({ wallet, initialFundedAccounts }: { wallet: TestWallet; initialFundedAccounts: InitialAccountData[] }) => {
-    if (initialFundedAccounts.length < numberOfAccounts) {
-      throw new Error(`Cannot deploy more than ${initialFundedAccounts.length} initial accounts.`);
-    }
-
-    logger.verbose('Deploying accounts funded with fee juice...');
-    const deployedAccounts = initialFundedAccounts.slice(0, numberOfAccounts);
-    // Serial due to https://github.com/AztecProtocol/aztec-packages/issues/12045
-    for (let i = 0; i < deployedAccounts.length; i++) {
-      const accountManager = await wallet.createSchnorrAccount(
-        deployedAccounts[i].secret,
-        deployedAccounts[i].salt,
-        deployedAccounts[i].signingKey,
-      );
-      const deployMethod = await accountManager.getDeployMethod();
-      await deployMethod.send({
-        from: AztecAddress.ZERO,
-        skipClassPublication: i !== 0, // Publish the contract class at most once.
-      });
-    }
-
-    return { deployedAccounts };
-  };
+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 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.
+ * 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 publicDeployAccounts(
-  wallet: Wallet,
-  accountsToDeploy: AztecAddress[],
-  waitUntilProven = false,
-  node?: AztecNode,
-) {
-  const instances = (await Promise.all(accountsToDeploy.map(account => wallet.getContractMetadata(account)))).map(
-    metadata => metadata.instance,
-  );
-
-  const contractClass = await getContractClassFromArtifact(SchnorrAccountContractArtifact);
-  const alreadyRegistered = (await wallet.getContractClassMetadata(contractClass.id)).isContractClassPubliclyRegistered;
-
-  const calls: ContractFunctionInteraction[] = await Promise.all([
-    ...(!alreadyRegistered ? [publishContractClass(wallet, SchnorrAccountContractArtifact)] : []),
-    ...instances.map(instance => publishInstance(wallet, instance!)),
-  ]);
-
-  const batch = new BatchCall(wallet, calls);
-
-  const txReceipt = await batch.send({ from: accountsToDeploy[0] });
-  if (waitUntilProven) {
-    if (!node) {
-      throw new Error('Need to provide an AztecNode to wait for proven.');
-    } else {
-      await waitForProven(node, txReceipt);
-    }
+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);
 }
 
 /**