@aztec/end-to-end 5.0.0-rc.2 → 5.0.1

package/dest/fixtures/setup.js

@@ -12,14 +12,13 @@ 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 { EthCheatCodesWithState, 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 { withLoggerBindings } from '@aztec/foundation/log/server';
 import { retryUntil } from '@aztec/foundation/retry';
-import { sleep } from '@aztec/foundation/sleep';
 import { TestDateProvider } from '@aztec/foundation/timer';
 import { SponsoredFPCContract } from '@aztec/noir-contracts.js/SponsoredFPC';
 import { getVKTreeRoot } from '@aztec/noir-protocol-circuits-types/vk-tree';
@@ -46,6 +45,8 @@ 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 { getStandardContractGenesisNullifiers } from './standard_contracts_genesis.js';
+import { testSpan } from './timing.js';
 import { getEndToEndTestTelemetryClient } from './with_telemetry_utils.js';
 export { startAnvil };
 let telemetry = undefined;
@@ -129,38 +130,37 @@ export const getPrivateKeyFromIndex = (index)=>{
         throw new Error(`Artifact version mismatch: expected ${expected} but got ${aztecVersion}. ` + `The legacy artifact resolver may not have swapped in the correct version.`);
     }
 }
-/**
- * Records a function-level timing span into the shared collector installed by the e2e timing
- * environment. No-op unless TEST_TIMING_FILE is set (the env only installs the collector then). The
- * span is tagged with the name of the currently running test so the env can attribute it to the
- * right line; `null` during beforeAll/afterAll lands it on the suite-scoped line.
- */ function recordFnSpan(kind, ms) {
-    const collector = globalThis.__e2eTimings;
-    collector?.fnSpans.push({
-        name: collector.current,
-        kind,
-        ms
-    });
-}
 /**
  * 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) {
-    const setupStart = performance.now();
-    try {
-        return await setupInner(numberOfAccounts, opts, pxeOpts, chain);
-    } finally{
-        recordFnSpan('setup', performance.now() - setupStart);
-    }
+ */ 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.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
@@ -175,7 +175,6 @@ async function setupInner(numberOfAccounts, opts, pxeOpts, chain) {
         config.enableDelayer = true;
         config.listenAddress = '127.0.0.1';
         config.minTxPoolAgeMs = opts.minTxPoolAgeMs ?? 0;
-        const logger = getLogger();
         // Create a temp directory for any services that need it and cleanup later
         const directoryToCleanup = path.join(tmpdir(), randomBytes(8).toString('hex'));
         await fs.mkdir(directoryToCleanup, {
@@ -189,18 +188,19 @@ async function setupInner(numberOfAccounts, opts, pxeOpts, chain) {
             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),
-                slotsInAnEpoch: opts.anvilSlotsInAnEpoch,
-                dateProvider
-            });
+            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');
@@ -216,6 +216,7 @@ async function setupInner(numberOfAccounts, opts, pxeOpts, chain) {
                 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) {
@@ -240,6 +241,7 @@ async function setupInner(numberOfAccounts, opts, pxeOpts, chain) {
         if (config.coinbase === undefined) {
             config.coinbase = EthAddress.fromString(publisherHdAccount.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);
@@ -254,14 +256,31 @@ async function setupInner(numberOfAccounts, opts, pxeOpts, chain) {
             const sponsoredFPCAddress = await getSponsoredFPCAddress();
             addressesToFund.push(sponsoredFPCAddress);
         }
+        // Fund any extra addresses whose value depends on the just-generated accounts (e.g. an FPC admin'd
+        // by a default account), so a test can genesis-fund them instead of bridging fee juice during setup.
+        if (opts.computeExtraGenesisFundedAddresses) {
+            addressesToFund.push(...await opts.computeExtraGenesisFundedAddresses(defaultAccounts));
+        }
+        logger.trace('Generated test accounts to fund at genesis');
+        // Preload the standard contracts (AuthRegistry, PublicChecks, HandshakeRegistry) so their `ensure*Published` setup
+        // helpers short-circuit their publish txs. The archiver flag seeds the bytecode/instance into every spawned node's
+        // contract store; the genesis nullifiers make the AVM's deployment-nullifier check pass when they are called. Both
+        // must go together (flag alone would recreate the publish-collision bug), so the flag lives here beside the seeding.
+        config.testPreloadStandardContracts = true;
+        const standardContractNullifiers = await getStandardContractGenesisNullifiers();
         const genesisTimestamp = BigInt(Math.floor(Date.now() / 1000));
-        const { genesisArchiveRoot, genesis, fundingNeeded } = await getGenesisValues(addressesToFund, opts.initialAccountFeeJuice, opts.genesisPublicData, genesisTimestamp);
+        const { genesisArchiveRoot, genesis, fundingNeeded } = await getGenesisValues(addressesToFund, opts.initialAccountFeeJuice, opts.genesisPublicData, genesisTimestamp, standardContractNullifiers);
+        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
@@ -269,17 +288,18 @@ async function setupInner(numberOfAccounts, opts, pxeOpts, chain) {
         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
-        });
+        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
@@ -299,9 +319,24 @@ async function setupInner(numberOfAccounts, opts, pxeOpts, chain) {
                 }
             }
         }
+        // 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);
+            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
@@ -314,20 +349,30 @@ async function setupInner(numberOfAccounts, opts, pxeOpts, chain) {
                 resetBlockInterval: true
             });
         }
-        // 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) {
@@ -336,25 +381,6 @@ async function setupInner(numberOfAccounts, opts, pxeOpts, chain) {
                 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.
-        const originalMinTxsPerBlock = config.minTxsPerBlock;
-        if (originalMinTxsPerBlock === undefined) {
-            throw new Error('minTxsPerBlock is undefined in e2e test setup');
-        }
-        const originalBuildCheckpointIfEmpty = config.buildCheckpointIfEmpty ?? false;
-        // Allow an empty checkpoint so the empty block can be built; leave untouched when not advancing.
-        const advancePastGenesis = (opts.advancePastGenesis ?? true) && !opts.skipInitialSequencer;
-        config.minTxsPerBlock = advancePastGenesis ? 0 : originalMinTxsPerBlock;
-        // Pipelining is always on: the proposer builds during slot N-1 for slot N. A tx submitted at slot N
-        // start arrives after that build, so forcing minTxsPerBlock=1 would stall the chain on alternating
-        // slots -- hence empty checkpoints are allowed (minTxsPerBlock=0) while advancing past genesis.
-        // Automine is unaffected: its runBuild clamps mempool builds to Math.max(minTxsPerBlock ?? 1, 1) and
-        // still requires minValidTxs: 1.
-        const shouldTemporarilyBuildEmptyCheckpoints = advancePastGenesis && config.useAutomineSequencer !== true;
-        if (shouldTemporarilyBuildEmptyCheckpoints) {
-            config.buildCheckpointIfEmpty = true;
-        }
         config.p2pEnabled = opts.mockGossipSubNetwork || config.p2pEnabled;
         config.p2pIp = opts.p2pIp ?? config.p2pIp ?? '127.0.0.1';
         if (!config.disableValidator) {
@@ -375,17 +401,19 @@ async function setupInner(numberOfAccounts, opts, pxeOpts, chain) {
                 bootstrapNodes: []
             }
         } : config;
-        const aztecNodeService = await withLoggerBindings({
-            actor: 'node-0'
-        }, ()=>createAztecNodeService(initialNodeConfig, {
-                dateProvider,
-                telemetry: telemetryClient,
-                p2pClientDeps
-            }, {
-                genesis,
-                dontStartSequencer: opts.skipInitialSequencer
-            }));
+        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');
         let proverNode = undefined;
         if (opts.startProverNode) {
             logger.verbose('Creating and syncing a simulated prover node...');
@@ -398,16 +426,17 @@ async function setupInner(numberOfAccounts, opts, pxeOpts, chain) {
                     aztecNodeService
                 ]
             };
-            ({ proverNode } = await createAndSyncProverNode(proverNodePrivateKeyHex, config, {
-                ...config.proverNodeConfig,
-                dataDirectory: proverNodeDataDirectory
-            }, {
-                dateProvider,
-                p2pClientDeps,
-                telemetry: telemetryClient
-            }, {
-                genesis
-            }));
+            ({ 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();
@@ -419,84 +448,57 @@ async function setupInner(numberOfAccounts, opts, pxeOpts, chain) {
         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',
-            // In-process node implements the debug API, so register public function signatures for named traces.
-            nodeDebug: aztecNodeService,
-            ...opts.pxeCreationOptions
-        });
+        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 = [];
         // 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 createFundedInitializerlessAccounts(wallet, defaultAccounts);
+            await testSpan('wallet:create', ()=>createFundedInitializerlessAccounts(wallet, defaultAccounts));
             accounts = defaultAccounts.map((a)=>a.address);
         }
-        // Advancing past genesis needs a running sequencer to build the empty block; advancePastGenesis is
-        // already false when skipInitialSequencer is set.
-        if (advancePastGenesis) {
-            logger.info('Mining an empty block to progress past genesis');
-            const automine = aztecNodeService.getAutomineSequencer();
-            if (automine) {
-                await automine.buildEmptyBlock();
-            }
-            while(await aztecNodeService.getBlockNumber() === 0){
-                await sleep(2000);
-            }
-        } else if (opts.skipInitialSequencer) {
-            logger.info('Sequencer not started on initial node, skipping block progression');
-        }
-        // Now we restore the original minTxsPerBlock setting if we changed it.
-        if (sequencerClient) {
-            const sequencer = sequencerClient.getSequencer();
-            if (config.minTxsPerBlock !== originalMinTxsPerBlock) {
-                sequencer.updateConfig({
-                    minTxsPerBlock: originalMinTxsPerBlock
-                });
-            }
-            if (shouldTemporarilyBuildEmptyCheckpoints) {
-                sequencer.updateConfig({
-                    buildCheckpointIfEmpty: originalBuildCheckpointIfEmpty
-                });
-                config.buildCheckpointIfEmpty = originalBuildCheckpointIfEmpty;
-            }
-        }
-        const teardown = async ()=>{
-            const teardownStart = performance.now();
-            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(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);
+                    }
                 }
-                recordFnSpan('teardown', performance.now() - teardownStart);
-            }
-        };
+            });
         return {
             anvil,
             aztecNode: aztecNodeService,
@@ -512,6 +514,7 @@ async function setupInner(numberOfAccounts, opts, pxeOpts, chain) {
             logger,
             mockGossipSubNetwork,
             genesis,
+            extraL1DeployResult,
             proverNode,
             sequencerDelayer,
             proverDelayer,
@@ -570,7 +573,7 @@ async function setupInner(numberOfAccounts, opts, pxeOpts, chain) {
  */ 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.getBlockNumber('proven') >= targetBlock, 'proven chain status', timeoutSec, intervalSec);
 }
@@ -633,18 +636,20 @@ export async function expectMappingDelta(initialValues, fn, inputs, expectedDiff
  * 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) {
-    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);
+    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

package/dest/fixtures/standard_contracts_genesis.d.ts

@@ -0,0 +1,16 @@
+import type { Fr } from '@aztec/foundation/curves/bn254';
+/**
+ * Computes the genesis nullifiers that pre-publish the standard contracts (AuthRegistry, PublicChecks,
+ * HandshakeRegistry) in e2e environments, mirroring the nullifiers their on-chain publish txs would emit. Per contract:
+ * - `siloNullifier(ContractClassRegistry, classId)` — the class-registration nullifier that `ContractClassRegistry.publish` pushes.
+ * - `siloNullifier(ContractInstanceRegistry, instanceAddress)` — the instance-deployment nullifier that
+ *   `ContractInstanceRegistry.publish_for_public_execution` pushes, using the contract's real derived address (standard
+ *   contracts are deployed at artifact-derived addresses, not magic protocol addresses).
+ *
+ * Seed these into the genesis nullifier tree (as the 5th `getGenesisValues` arg) alongside the archiver's
+ * `testPreloadStandardContracts` preload: the store preload makes the `ensure*Published` guards short-circuit, and these
+ * nullifiers make the AVM's deployment-nullifier check pass when the contracts are called. Every e2e node genesis that
+ * feeds an L1 `genesisArchiveRoot` must seed the same set, or the world-state root diverges from the deployed rollup.
+ */
+export declare function getStandardContractGenesisNullifiers(): Promise<Fr[]>;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3RhbmRhcmRfY29udHJhY3RzX2dlbmVzaXMuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9maXh0dXJlcy9zdGFuZGFyZF9jb250cmFjdHNfZ2VuZXNpcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssRUFBRSxFQUFFLEVBQUUsTUFBTSxnQ0FBZ0MsQ0FBQztBQUt6RDs7Ozs7Ozs7Ozs7O0dBWUc7QUFDSCx3QkFBc0Isb0NBQW9DLElBQUksT0FBTyxDQUFDLEVBQUUsRUFBRSxDQUFDLENBUzFFIn0=

package/dest/fixtures/standard_contracts_genesis.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"standard_contracts_genesis.d.ts","sourceRoot":"","sources":["../../src/fixtures/standard_contracts_genesis.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,gCAAgC,CAAC;AAKzD;;;;;;;;;;;;GAYG;AACH,wBAAsB,oCAAoC,IAAI,OAAO,CAAC,EAAE,EAAE,CAAC,CAS1E"}

package/dest/fixtures/standard_contracts_genesis.js

@@ -0,0 +1,25 @@
+import { ProtocolContractAddress } from '@aztec/protocol-contracts';
+import { getPublishableStandardContracts } from '@aztec/standard-contracts';
+import { siloNullifier } from '@aztec/stdlib/hash';
+/**
+ * Computes the genesis nullifiers that pre-publish the standard contracts (AuthRegistry, PublicChecks,
+ * HandshakeRegistry) in e2e environments, mirroring the nullifiers their on-chain publish txs would emit. Per contract:
+ * - `siloNullifier(ContractClassRegistry, classId)` — the class-registration nullifier that `ContractClassRegistry.publish` pushes.
+ * - `siloNullifier(ContractInstanceRegistry, instanceAddress)` — the instance-deployment nullifier that
+ *   `ContractInstanceRegistry.publish_for_public_execution` pushes, using the contract's real derived address (standard
+ *   contracts are deployed at artifact-derived addresses, not magic protocol addresses).
+ *
+ * Seed these into the genesis nullifier tree (as the 5th `getGenesisValues` arg) alongside the archiver's
+ * `testPreloadStandardContracts` preload: the store preload makes the `ensure*Published` guards short-circuit, and these
+ * nullifiers make the AVM's deployment-nullifier check pass when the contracts are called. Every e2e node genesis that
+ * feeds an L1 `genesisArchiveRoot` must seed the same set, or the world-state root diverges from the deployed rollup.
+ */ export async function getStandardContractGenesisNullifiers() {
+    const classRegistry = ProtocolContractAddress.ContractClassRegistry;
+    const instanceRegistry = ProtocolContractAddress.ContractInstanceRegistry;
+    const nullifiers = [];
+    for (const { contractClass, address } of (await getPublishableStandardContracts())){
+        nullifiers.push(await siloNullifier(classRegistry, contractClass.id));
+        nullifiers.push(await siloNullifier(instanceRegistry, address.toField()));
+    }
+    return nullifiers;
+}

package/dest/fixtures/timing.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Runs `fn` with every {@link testSpan} inside its async call tree attributed to `owner` instead of the
+ * currently running test. Use a non-test sentinel owner (e.g. `other:mempool-feeder`) to keep a
+ * background producer's spans out of the per-test view.
+ */
+export declare function withTestSpanOwner<T>(owner: string, fn: () => Promise<T>): Promise<T>;
+/** One recorded span occurrence on the process-wide `performance.now()` clock. */
+export type TimingSpan = {
+    /** Full name of the test running when the span started, or `null` if inside a beforeAll/afterAll hook. */
+    owner: string | null;
+    /** Stable `category:label` tag, aggregated across occurrences (e.g. `wait:checkpoint`, `setup:node`). */
+    name: string;
+    /** `performance.now()` at span start. */
+    start: number;
+    /** `performance.now()` at span end. */
+    end: number;
+};
+/**
+ * The collector shared by the timing environment on `globalThis.__e2eTimings`. `current` is the full
+ * name of the test currently running (`null` during beforeAll/afterAll); the environment sets it. The
+ * `spans` array accumulates every recorded span until the environment folds it into the per-test /
+ * per-suite JSONL line at flush.
+ */
+export type SpanCollector = {
+    /** Full name of the running test, or `null` during a beforeAll/afterAll hook. */
+    current: string | null;
+    /** All recorded spans, drained by the timing environment at flush time. */
+    spans: TimingSpan[];
+};
+/**
+ * Times `fn` and records a span tagged `name`, attributed to the test (or suite) running when it
+ * started. The span is recorded even when `fn` throws. Pure passthrough: when no collector is
+ * installed (i.e. `TEST_TIMING_FILE` is unset) this calls `fn()` directly with zero overhead.
+ *
+ * Use stable `category:label` tags and prefer wrapping at the leaf wait/setup/tx level — labels are
+ * forever aggregation keys, and leaf-level tagging keeps spans additive. See `SPEEDUP_FOLLOWUPS` and
+ * the A-1179 design doc for the tag taxonomy.
+ */
+export declare function testSpan<T>(name: string, fn: () => Promise<T>): Promise<T>;
+/** Synchronous variant of {@link testSpan} for non-async helpers. Same zero-cost guarantee when unset. */
+export declare function testSpanSync<T>(name: string, fn: () => T): T;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGltaW5nLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvZml4dHVyZXMvdGltaW5nLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQXNCQTs7OztHQUlHO0FBQ0gsd0JBQWdCLGlCQUFpQixDQUFDLENBQUMsRUFBRSxLQUFLLEVBQUUsTUFBTSxFQUFFLEVBQUUsRUFBRSxNQUFNLE9BQU8sQ0FBQyxDQUFDLENBQUMsR0FBRyxPQUFPLENBQUMsQ0FBQyxDQUFDLENBRXBGO0FBRUQsa0ZBQWtGO0FBQ2xGLE1BQU0sTUFBTSxVQUFVLEdBQUc7SUFDdkIsMEdBQTBHO0lBQzFHLEtBQUssRUFBRSxNQUFNLEdBQUcsSUFBSSxDQUFDO0lBQ3JCLHlHQUF5RztJQUN6RyxJQUFJLEVBQUUsTUFBTSxDQUFDO0lBQ2IseUNBQXlDO0lBQ3pDLEtBQUssRUFBRSxNQUFNLENBQUM7SUFDZCx1Q0FBdUM7SUFDdkMsR0FBRyxFQUFFLE1BQU0sQ0FBQztDQUNiLENBQUM7QUFFRjs7Ozs7R0FLRztBQUNILE1BQU0sTUFBTSxhQUFhLEdBQUc7SUFDMUIsaUZBQWlGO0lBQ2pGLE9BQU8sRUFBRSxNQUFNLEdBQUcsSUFBSSxDQUFDO0lBQ3ZCLDJFQUEyRTtJQUMzRSxLQUFLLEVBQUUsVUFBVSxFQUFFLENBQUM7Q0FDckIsQ0FBQztBQU1GOzs7Ozs7OztHQVFHO0FBQ0gsd0JBQXNCLFFBQVEsQ0FBQyxDQUFDLEVBQUUsSUFBSSxFQUFFLE1BQU0sRUFBRSxFQUFFLEVBQUUsTUFBTSxPQUFPLENBQUMsQ0FBQyxDQUFDLEdBQUcsT0FBTyxDQUFDLENBQUMsQ0FBQyxDQVloRjtBQUVELDBHQUEwRztBQUMxRyx3QkFBZ0IsWUFBWSxDQUFDLENBQUMsRUFBRSxJQUFJLEVBQUUsTUFBTSxFQUFFLEVBQUUsRUFBRSxNQUFNLENBQUMsR0FBRyxDQUFDLENBWTVEIn0=

package/dest/fixtures/timing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"timing.d.ts","sourceRoot":"","sources":["../../src/fixtures/timing.ts"],"names":[],"mappings":"AAsBA;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAEpF;AAED,kFAAkF;AAClF,MAAM,MAAM,UAAU,GAAG;IACvB,0GAA0G;IAC1G,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,yGAAyG;IACzG,IAAI,EAAE,MAAM,CAAC;IACb,yCAAyC;IACzC,KAAK,EAAE,MAAM,CAAC;IACd,uCAAuC;IACvC,GAAG,EAAE,MAAM,CAAC;CACb,CAAC;AAEF;;;;;GAKG;AACH,MAAM,MAAM,aAAa,GAAG;IAC1B,iFAAiF;IACjF,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,2EAA2E;IAC3E,KAAK,EAAE,UAAU,EAAE,CAAC;CACrB,CAAC;AAMF;;;;;;;;GAQG;AACH,wBAAsB,QAAQ,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAYhF;AAED,0GAA0G;AAC1G,wBAAgB,YAAY,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,CAAC,GAAG,CAAC,CAY5D"}