@aztec/end-to-end 0.0.1-commit.d431d1c → 0.0.1-commit.d58ff9d0

package/dest/fixtures/setup.js

@@ -1,15 +1,10 @@
-import { SchnorrAccountContractArtifact } from '@aztec/accounts/schnorr';
-import { generateSchnorrAccounts, getInitialTestAccountsData } from '@aztec/accounts/testing';
-import { createArchiver } from '@aztec/archiver';
-import { AztecNodeService, getConfigEnvVars } from '@aztec/aztec-node';
-import { AztecAddress, EthAddress } from '@aztec/aztec.js/addresses';
-import { BatchCall, getContractClassFromArtifact, waitForProven } from '@aztec/aztec.js/contracts';
+import { generateSchnorrAccounts } from '@aztec/accounts/testing';
+import { createAztecNodeService, getConfigEnvVars } from '@aztec/aztec-node';
+import { EthAddress } from '@aztec/aztec.js/addresses';
 import { publishContractClass, publishInstance } from '@aztec/aztec.js/deployment';
 import { Fr } from '@aztec/aztec.js/fields';
 import { createLogger } from '@aztec/aztec.js/log';
-import { createAztecNodeClient, waitForNode } from '@aztec/aztec.js/node';
-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';
@@ -17,40 +12,42 @@ import { getL1ContractsConfigEnvVars } from '@aztec/ethereum/config';
 import { NULL_KEY } from '@aztec/ethereum/constants';
 import { deployMulticall3 } from '@aztec/ethereum/contracts';
 import { deployAztecL1Contracts } from '@aztec/ethereum/deploy-aztec-l1-contracts';
-import { DelayedTxUtils, EthCheatCodes, EthCheatCodesWithState, createDelayedL1TxUtilsFromViemWallet, startAnvil } from '@aztec/ethereum/test';
+import { EthCheatCodesWithState, startAnvil, warmBlobKzg } from '@aztec/ethereum/test';
 import { 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 { withLogNameSuffix } from '@aztec/foundation/log';
+import { withLoggerBindings } from '@aztec/foundation/log/server';
 import { retryUntil } from '@aztec/foundation/retry';
-import { sleep } from '@aztec/foundation/sleep';
-import { DateProvider, TestDateProvider } from '@aztec/foundation/timer';
+import { TestDateProvider } from '@aztec/foundation/timer';
 import { SponsoredFPCContract } from '@aztec/noir-contracts.js/SponsoredFPC';
 import { getVKTreeRoot } from '@aztec/noir-protocol-circuits-types/vk-tree';
 import { MockGossipSubNetwork, getMockPubSubP2PServiceFactory } from '@aztec/p2p/test-helpers';
 import { protocolContractsHash } from '@aztec/protocol-contracts';
-import { createProverNode } from '@aztec/prover-node';
 import { getPXEConfig } from '@aztec/pxe/server';
+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 { getContractInstanceFromInstantiationParams } from '@aztec/stdlib/contract';
 import { tryStop } from '@aztec/stdlib/interfaces/server';
 import { getConfigEnvVars as getTelemetryConfig, initTelemetryClient } from '@aztec/telemetry-client';
 import { BenchmarkTelemetryClient } from '@aztec/telemetry-client/bench';
-import { TestWallet, deployFundedSchnorrAccounts } from '@aztec/test-wallet/server';
+import { createFundedInitializerlessAccounts } from '@aztec/wallets/testing';
 import { getGenesisValues } from '@aztec/world-state/testing';
 import fs from 'fs/promises';
 import { tmpdir } from 'os';
 import path from 'path';
 import { generatePrivateKey, mnemonicToAccount, privateKeyToAccount } from 'viem/accounts';
 import { 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';
 import { isMetricsLoggingRequested, setupMetricsLogger } from './logging.js';
+import { testSpan } from './timing.js';
 import { getEndToEndTestTelemetryClient } from './with_telemetry_utils.js';
 export { startAnvil };
-const { AZTEC_NODE_URL = '' } = process.env;
-const getAztecUrl = ()=>AZTEC_NODE_URL;
 let telemetry = undefined;
 async function getTelemetryClient(partialConfig = {}) {
     if (!telemetry) {
@@ -84,11 +81,13 @@ export const getPrivateKeyFromIndex = (index)=>{
 /**
  * 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 useLogSuffix - Whether to add a randomly generated suffix to the PXE debug logs.
+ * @param actor - Actor label to include in log output (e.g., 'pxe-test').
  * @returns A test wallet, logger and teardown function.
- */ export async function setupPXEAndGetWallet(aztecNode, opts = {}, logger = getLogger(), useLogSuffix = false) {
+ */ export async function setupPXEAndGetWallet(aztecNode, nodeDebug, opts = {}, logger = getLogger(), actor) {
     const PXEConfig = {
         ...getPXEConfig(),
         ...opts
@@ -102,7 +101,8 @@ export const getPrivateKeyFromIndex = (index)=>{
     }
     const teardown = configuredDataDirectory ? ()=>Promise.resolve() : ()=>tryRmDir(PXEConfig.dataDirectory);
     const wallet = await TestWallet.create(aztecNode, PXEConfig, {
-        useLogSuffix
+        loggerActorLabel: actor,
+        nodeDebug
     });
     return {
         wallet,
@@ -111,71 +111,55 @@ export const getPrivateKeyFromIndex = (index)=>{
     };
 }
 /**
- * Function to setup the test against a remote deployment. It is assumed that L1 contract are already deployed
- */ async function setupWithRemoteEnvironment(account, config, logger, numberOfAccounts) {
-    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 = {
-        l1ContractAddresses,
-        l1Client,
-        rollupVersion
-    };
-    const ethCheatCodes = new EthCheatCodes(config.l1RpcUrls, new DateProvider());
-    const wallet = await TestWallet.create(aztecNode);
-    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}.`);
+ * 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.`);
     }
-    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
-    };
 }
 /**
  * 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(numberOfAccounts = 1, opts = {}, pxeOpts = {}, chain = foundry) {
+ */ export function setup(numberOfAccounts = 1, opts = {}, pxeOpts = {}, chain = foundry) {
+    // 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(numberOfAccounts, opts, pxeOpts, chain) {
+    assertContractArtifactsVersion();
+    const logger = getLogger();
     let anvil;
     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 = {
             ...getConfigEnvVars(),
             ...opts
@@ -186,10 +170,10 @@ export const getPrivateKeyFromIndex = (index)=>{
         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'));
         await fs.mkdir(directoryToCleanup, {
@@ -198,30 +182,30 @@ export const getPrivateKeyFromIndex = (index)=>{
         if (!config.dataDirectory) {
             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
-            });
+            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()) {
             const filename = path.join('log', getJobName() + '.jsonl');
             logger.info(`Logging metrics to ${filename}`);
             setupMetricsLogger(filename);
         }
-        const dateProvider = new TestDateProvider();
         const ethCheatCodes = new EthCheatCodesWithState(config.l1RpcUrls, dateProvider);
         if (opts.stateLoad) {
             await ethCheatCodes.loadChainState(opts.stateLoad);
@@ -231,13 +215,14 @@ export const getPrivateKeyFromIndex = (index)=>{
                 resetBlockInterval: true
             });
         }
+        logger.trace('Initialized L1 cheat codes and applied state/time overrides');
         let publisherPrivKeyHex = undefined;
         let publisherHdAccount = undefined;
         if (opts.l1PublisherKey && opts.l1PublisherKey.getValue() && opts.l1PublisherKey.getValue() != NULL_KEY) {
             publisherPrivKeyHex = opts.l1PublisherKey.getValue();
             publisherHdAccount = privateKeyToAccount(publisherPrivKeyHex);
-        } else if (config.publisherPrivateKeys && config.publisherPrivateKeys.length > 0 && config.publisherPrivateKeys[0].getValue() != NULL_KEY) {
-            publisherPrivKeyHex = config.publisherPrivateKeys[0].getValue();
+        } else if (config.sequencerPublisherPrivateKeys && config.sequencerPublisherPrivateKeys.length > 0 && config.sequencerPublisherPrivateKeys[0].getValue() != NULL_KEY) {
+            publisherPrivKeyHex = config.sequencerPublisherPrivateKeys[0].getValue();
             publisherHdAccount = privateKeyToAccount(publisherPrivKeyHex);
         } else if (!MNEMONIC) {
             throw new Error(`Mnemonic not provided and no publisher private key`);
@@ -248,32 +233,42 @@ export const getPrivateKeyFromIndex = (index)=>{
             const publisherPrivKeyRaw = publisherHdAccount.getHdKey().privateKey;
             const publisherPrivKey = publisherPrivKeyRaw === null ? null : Buffer.from(publisherPrivKeyRaw);
             publisherPrivKeyHex = `0x${publisherPrivKey.toString('hex')}`;
-            config.publisherPrivateKeys = [
+            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 ?? await generateSchnorrAccounts(opts.numberOfInitialFundedAccounts ?? Math.max(numberOfAccounts, 10));
-        const addressesToFund = initialFundedAccounts.map((a)=>a.address);
+        logger.trace('Resolved L1 publisher account');
+        // 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);
         }
-        const { genesisArchiveRoot, prefilledPublicData, fundingNeeded } = await getGenesisValues(addressesToFund, opts.initialAccountFeeJuice, opts.genesisPublicData);
+        logger.trace('Generated test accounts to fund at genesis');
+        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);
         if (enableAutomine) {
             await ethCheatCodes.setAutomine(true);
         }
         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
@@ -281,68 +276,99 @@ export const getPrivateKeyFromIndex = (index)=>{
         await l1Client.getTransactionCount({
             address: l1Client.account.address
         });
-        const deployL1ContractsValues = await deployAztecL1Contracts(config.l1RpcUrls[0], publisherPrivKeyHex, chain.id, {
-            ...getL1ContractsConfigEnvVars(),
-            ...opts,
-            ...opts.l1ContractsArgs,
-            vkTreeRoot: getVKTreeRoot(),
-            protocolContractsHash,
-            genesisArchiveRoot,
-            initialValidators: opts.initialValidators,
-            feeJuicePortalInitialBalance: fundingNeeded,
-            realVerifier: false
-        });
-        config.l1Contracts = deployL1ContractsValues.l1ContractAddresses;
+        logger.trace('Deployed Multicall3');
+        const deployL1ContractsValues = await testSpan('setup:env:l1-deploy', ()=>deployAztecL1Contracts(config.l1RpcUrls[0], publisherPrivKeyHex, chain.id, {
+                ...getL1ContractsConfigEnvVars(),
+                ...opts,
+                ...opts.l1ContractsArgs,
+                vkTreeRoot: getVKTreeRoot(),
+                protocolContractsHash,
+                genesisArchiveRoot,
+                initialValidators: opts.initialValidators,
+                feeJuicePortalInitialBalance: fundingNeeded,
+                realVerifier: false
+            }));
+        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[key] = value;
+                }
+            }
+        }
+        // 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 = undefined;
+        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
+            });
+        }
         if (enableAutomine) {
-            await ethCheatCodes.setAutomine(false);
-            await ethCheatCodes.setIntervalMining(config.ethereumSlotDuration);
-            dateProvider.setTime(await ethCheatCodes.timestamp() * 1000);
+            await ethCheatCodes.startIntervalMiningWithFreshBlock(config.ethereumSlotDuration);
+        }
+        // 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);
         }
         if (opts.l2StartTime) {
             await ethCheatCodes.warp(opts.l2StartTime, {
                 resetBlockInterval: true
             });
         }
-        const watcher = new AnvilTestWatcher(new EthCheatCodesWithState(config.l1RpcUrls, dateProvider), deployL1ContractsValues.l1ContractAddresses.rollupAddress, deployL1ContractsValues.l1Client, dateProvider);
-        if (!opts.disableAnvilTestWatcher) {
-            await watcher.start();
-        }
-        // 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);
-        logger.verbose('Creating and synching an aztec node', config);
-        const acvmConfig = await getACVMConfig(logger);
+        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');
         if (acvmConfig) {
             config.acvmWorkingDirectory = acvmConfig.acvmWorkingDirectory;
             config.acvmBinaryPath = acvmConfig.acvmBinaryPath;
         }
-        const bbConfig = await getBBConfig(logger);
+        logger.trace('Resolved ACVM config');
         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;
         let p2pClientDeps = 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';
         if (!config.disableValidator) {
@@ -352,32 +378,56 @@ export const getPrivateKeyFromIndex = (index)=>{
                 ]);
             }
         }
-        const aztecNodeService = await AztecNodeService.createAndSync(config, {
-            dateProvider,
-            telemetry: telemetryClient,
-            p2pClientDeps,
-            logger: createLogger('node:MAIN-aztec-node')
-        }, {
-            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: []
+            }
+        } : 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();
-        if (sequencerClient) {
-            const publisher = sequencerClient.sequencer.publisher;
-            publisher.l1TxUtils = DelayedTxUtils.fromL1TxUtils(publisher.l1TxUtils, config.ethereumSlotDuration, l1Client);
-        }
+        logger.trace('Created and synced aztec node');
         let proverNode = undefined;
         if (opts.startProverNode) {
             logger.verbose('Creating and syncing a simulated prover node...');
             const proverNodePrivateKey = getPrivateKeyFromIndex(2);
             const proverNodePrivateKeyHex = `0x${proverNodePrivateKey.toString('hex')}`;
             const proverNodeDataDirectory = path.join(directoryToCleanup, randomBytes(8).toString('hex'));
-            const proverNodeConfig = {
-                ...config.proverNodeConfig,
-                dataDirectory: proverNodeDataDirectory,
-                p2pEnabled: false
+            const p2pClientDeps = {
+                p2pServiceFactory: mockGossipSubNetwork && getMockPubSubP2PServiceFactory(mockGossipSubNetwork),
+                rpcTxProviders: [
+                    aztecNodeService
+                ]
             };
-            proverNode = await createAndSyncProverNode(proverNodePrivateKeyHex, config, proverNodeConfig, aztecNodeService, prefilledPublicData);
+            ({ 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(),
@@ -386,60 +436,57 @@ export const getPrivateKeyFromIndex = (index)=>{
         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);
+        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 || opts.initialValidators && opts.initialValidators.length > 0) {
             // We need to advance such that the committee is set up.
             await cheatCodes.rollup.advanceToEpoch(EpochNumber.fromBigInt(BigInt(await cheatCodes.rollup.getEpoch()) + BigInt(config.lagInEpochsForValidatorSet + 1)));
             await cheatCodes.rollup.setupEpoch();
             await cheatCodes.rollup.debugRollup();
+            logger.trace('Advanced chain to set up validator committee');
         }
         let accounts = [];
-        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, aztecNodeService, 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);
-            }
-        }
-        // If skipAccountDeployment is true, we don't deploy or wait - tests will handle account deployment later
-        // Now we restore the original minTxsPerBlock setting if we changed it.
-        if (sequencerClient && config.minTxsPerBlock !== originalMinTxsPerBlock) {
-            sequencerClient.getSequencer().updateConfig({
-                minTxsPerBlock: originalMinTxsPerBlock
-            });
+        // 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 (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);
-                if (acvmConfig?.cleanup) {
-                    await acvmConfig.cleanup();
-                }
-                if (bbConfig?.cleanup) {
-                    await bbConfig.cleanup();
-                }
-                await tryStop(watcher, logger);
-                await tryStop(anvil, logger);
-                await tryRmDir(directoryToCleanup, logger);
-            } catch (err) {
-                logger.error(`Error during e2e test teardown`, err);
-            } finally{
+        logger.trace('Created funded test accounts');
+        const teardown = ()=>testSpan('teardown:env', async ()=>{
                 try {
-                    await telemetryClient?.stop();
+                    await tryStop(wallet, logger);
+                    await tryStop(aztecNodeService, logger);
+                    await tryStop(proverNode, logger);
+                    if (acvmConfig?.cleanup) {
+                        await acvmConfig.cleanup();
+                    }
+                    if (bbConfig?.cleanup) {
+                        await bbConfig.cleanup();
+                    }
+                    await tryStop(anvil, logger);
+                    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,
             aztecNode: aztecNodeService,
@@ -451,17 +498,19 @@ export const getPrivateKeyFromIndex = (index)=>{
             aztecNodeConfig: config,
             dateProvider,
             deployL1ContractsValues,
-            initialFundedAccounts,
+            additionallyFundedAccounts,
             logger,
             mockGossipSubNetwork,
-            prefilledPublicData,
+            genesis,
+            extraL1DeployResult,
             proverNode,
+            sequencerDelayer,
+            proverDelayer,
             sequencer: sequencerClient,
             teardown,
             telemetryClient,
             wallet,
             accounts,
-            watcher,
             acvmConfig,
             bbConfig,
             directoryToCleanup
@@ -512,79 +561,45 @@ export const getPrivateKeyFromIndex = (index)=>{
  */ export async function registerSponsoredFPC(wallet) {
     await wallet.registerContract(await getSponsoredFPCInstance(), SponsoredFPCContract.artifact);
 }
-export async function waitForProvenChain(node, targetBlock, timeoutSec = 60, intervalSec = 1) {
+export async function waitForProvenChain(node, targetBlock, timeoutSec = 60, intervalSec = 0.25) {
     targetBlock ??= await node.getBlockNumber();
-    await retryUntil(async ()=>await node.getProvenBlockNumber() >= targetBlock, 'proven chain status', timeoutSec, intervalSec);
+    await retryUntil(async ()=>await node.getBlockNumber('proven') >= targetBlock, 'proven chain status', timeoutSec, intervalSec);
 }
-export function createAndSyncProverNode(proverNodePrivateKey, aztecNodeConfig, proverNodeConfig, aztecNode, prefilledPublicData = [], proverNodeDeps = {}) {
-    return withLogNameSuffix('prover-node', 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 = {
-            ...aztecNodeConfig,
-            txCollectionNodeRpcUrls: [],
-            realProofs: false,
-            proverAgentCount: 2,
-            publisherPrivateKeys: [
+/**
+ * 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, baseConfig, configOverrides, deps, options) {
+    return withLoggerBindings({
+        actor: 'prover-0'
+    }, async ()=>{
+        const proverNode = await createAztecNodeService({
+            ...baseConfig,
+            ...configOverrides,
+            p2pPort: 0,
+            enableProverNode: true,
+            disableValidator: true,
+            proverPublisherPrivateKeys: [
                 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 createProverNode(proverConfig, {
-            ...proverNodeDeps,
-            aztecNodeTxProvider,
-            archiver: archiver,
-            l1TxUtils
-        }, {
-            prefilledPublicData
+            ]
+        }, deps, {
+            genesis: options.genesis,
+            dontStartProverNode: options.dontStart
         });
-        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;
+        getLogger().info(`Created and synced prover node`);
+        return {
+            proverNode
+        };
     });
 }
-function createDelayedL1TxUtils(aztecNodeConfig, privateKey, logName, 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;
-}
-export function getBalancesFn(symbol, method, from, logger) {
+export function getBalancesFn(symbol, method, logger) {
     const balances = async (...addressLikes)=>{
         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;
@@ -603,74 +618,63 @@ export async function expectMappingDelta(initialValues, fn, inputs, expectedDiff
     expect(diffs).toEqual(expectedDiffs);
 }
 /**
- * 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.
- */ export async function ensureAccountContractsPublished(wallet, accountsToDeploy) {
-    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);
+ * 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, from) {
+    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);
+    });
+}
+/**
+ * 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, from) {
+    const { instance, contractClass } = await getStandardPublicChecks();
     if (!(await wallet.getContractClassMetadata(contractClass.id)).isContractClassPubliclyRegistered) {
-        await (await publishContractClass(wallet, SchnorrAccountContractArtifact)).send({
-            from: accountsToDeploy[0]
-        }).wait();
+        await (await publishContractClass(wallet, PublicChecksArtifact)).send({
+            from
+        });
+    }
+    if (!(await wallet.getContractMetadata(instance.address)).isContractPublished) {
+        await publishInstance(wallet, instance).send({
+            from
+        });
     }
-    const requests = instances.map((instance)=>publishInstance(wallet, instance));
-    const batch = new BatchCall(wallet, requests);
-    await batch.send({
-        from: accountsToDeploy[0]
-    }).wait();
+    await wallet.registerContract(instance, PublicChecksArtifact);
 }
 /**
- * Helper function to deploy accounts.
- * Returns deployed account data that can be used by tests.
- */ export const deployAccounts = (numberOfAccounts, logger)=>async ({ wallet, initialFundedAccounts })=>{
-        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
-            }).wait();
-        }
-        return {
-            deployedAccounts
-        };
-    };
-/**
- * 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.
- */ export async function publicDeployAccounts(wallet, accountsToDeploy, waitUntilProven = false, node) {
-    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 = 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]
-    }).wait();
-    if (waitUntilProven) {
-        if (!node) {
-            throw new Error('Need to provide an AztecNode to wait for proven.');
-        } else {
-            await waitForProven(node, txReceipt);
-        }
+ * 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, from) {
+    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);
 }
 /**
  * Destroys the current context.