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

package/src/e2e_p2p/p2p_network.ts

@@ -431,6 +431,7 @@ export class P2PNetworkTest {
     timeoutSeconds = 30,
     checkIntervalSeconds = 0.1,
     topics: TopicType[] = [TopicType.tx],
+    minMeshPeerCount = 1,
   ) {
     const nodeCount = expectedNodeCount ?? nodes.length;
     const minPeerCount = nodeCount - 1;
@@ -457,11 +458,13 @@ export class P2PNetworkTest {
 
     this.logger.warn('All nodes connected to P2P mesh');
 
-    // Wait for GossipSub mesh to form for all specified topics.
-    // We only require at least 1 mesh peer per node because GossipSub
-    // stops grafting once it reaches Dlo peers and won't fill the mesh to all available peers.
+    // Wait for the GossipSub mesh to form for all specified topics. By default we only require at
+    // least 1 mesh peer per node, since GossipSub stops grafting once it reaches Dlo peers and won't
+    // fill the mesh to every available peer. Callers that need a proposal to reach the whole
+    // committee within a slot (e.g. quorum-from-genesis tests) raise `minMeshPeerCount` so the mesh
+    // is fully formed — a single mesh peer can leave some committee members unreached at first.
     for (const topic of topics) {
-      this.logger.warn(`Waiting for GossipSub mesh to form for ${topic} topic...`);
+      this.logger.warn(`Waiting for GossipSub mesh (>= ${minMeshPeerCount} peers per node) for ${topic} topic...`);
       await Promise.all(
         nodes.map(async (node, index) => {
           const p2p = node.getP2P();
@@ -469,15 +472,15 @@ export class P2PNetworkTest {
             async () => {
               const meshPeers = await p2p.getGossipMeshPeerCount(topic);
               this.logger.debug(`Node ${index} has ${meshPeers} gossip mesh peers for ${topic} topic`);
-              return meshPeers >= 1 ? true : undefined;
+              return meshPeers >= minMeshPeerCount ? true : undefined;
             },
-            `Node ${index} to have gossip mesh peers for ${topic} topic`,
+            `Node ${index} to have >= ${minMeshPeerCount} gossip mesh peers for ${topic} topic`,
             timeoutSeconds,
             checkIntervalSeconds,
           );
         }),
       );
-      this.logger.warn(`All nodes have gossip mesh peers for ${topic} topic`);
+      this.logger.warn(`All nodes have >= ${minMeshPeerCount} gossip mesh peers for ${topic} topic`);
     }
   }
 

package/src/e2e_p2p/shared.ts

@@ -147,6 +147,65 @@ export async function awaitCommitteeExists({
   return committee!.map(c => c.toString() as `0x${string}`);
 }
 
+/**
+ * Scans L2 slots forward from `minLeadSlots` ahead of the current slot, returning the first slot in
+ * which `targetProposer` is the proposer.
+ *
+ * Scanning starts at `currentSlot + minLeadSlots` and only ever moves forward, so every returned slot
+ * is at least `minLeadSlots` ahead — a caller can safely warp to `targetSlot - minLeadSlots` for a
+ * settle buffer without risking a backwards warp. Stepping by a single slot examines both epoch
+ * parities, which matters because the per-slot proposer is a different RANDAO-shuffled committee
+ * member: searching only a fixed offset within each epoch can leave a 1-of-N target unexamined when
+ * the epoch is short. A candidate in an epoch whose committee isn't sampled yet makes the proposer
+ * lookup revert with EpochNotStable; this warps one epoch forward and continues, keeping the
+ * candidate at least `minLeadSlots` ahead of the new current slot. Throws after `maxSlotsToScan`.
+ *
+ * Unlike {@link advanceToEpochBeforeProposer}, this does not stop an epoch early — callers that want
+ * to warp close to the target (rather than stage sequencers an epoch ahead) use this and warp the
+ * final `minLeadSlots` in themselves.
+ */
+export async function findUpcomingProposerSlot({
+  epochCache,
+  cheatCodes,
+  targetProposer,
+  logger,
+  minLeadSlots,
+  maxSlotsToScan = 100,
+}: {
+  epochCache: EpochCacheInterface;
+  cheatCodes: RollupCheatCodes;
+  targetProposer: EthAddress;
+  logger: Logger;
+  minLeadSlots: number;
+  maxSlotsToScan?: number;
+}): Promise<SlotNumber> {
+  let candidate = Number(await cheatCodes.getSlot()) + minLeadSlots;
+
+  for (let scanned = 0; scanned < maxSlotsToScan; scanned++) {
+    let proposer: EthAddress | undefined;
+    try {
+      proposer = await epochCache.getProposerAttesterAddressInSlot(SlotNumber(candidate));
+    } catch (err) {
+      if (!(err instanceof Error) || !err.message.includes('EpochNotStable')) {
+        throw err;
+      }
+      await cheatCodes.advanceToNextEpoch();
+      const newCurrentSlot = Number(await cheatCodes.getSlot());
+      // Keep the lead after the warp: never return a slot we could no longer warp ahead of.
+      candidate = Math.max(candidate, newCurrentSlot + minLeadSlots);
+      continue;
+    }
+
+    if (proposer && proposer.equals(targetProposer)) {
+      logger.warn(`Found target proposer ${targetProposer} at slot ${candidate}`);
+      return SlotNumber(candidate);
+    }
+    candidate++;
+  }
+
+  throw new Error(`Target proposer ${targetProposer} not found within ${maxSlotsToScan} slots`);
+}
+
 /**
  * Advance epochs until we find one where the target proposer is selected for a slot at least
  * `warmupSlots` into the epoch, then stop one epoch before it. This leaves time for the caller to

package/src/fixtures/e2e_prover_test.ts

@@ -1,5 +1,5 @@
 import { type InitialAccountData, generateSchnorrAccounts } from '@aztec/accounts/testing';
-import { AztecNodeService } from '@aztec/aztec-node';
+import { AztecNodeService, createAztecNodeService } from '@aztec/aztec-node';
 import { AztecAddress, EthAddress } from '@aztec/aztec.js/addresses';
 import { type Logger, createLogger } from '@aztec/aztec.js/log';
 import type { AztecNode } from '@aztec/aztec.js/node';
@@ -177,6 +177,7 @@ export class FullProverTest {
     this.logger.verbose(`Main setup completed, initializing full prover PXE, Node, and Prover Node`);
     const { wallet: provenWallet, teardown: provenTeardown } = await setupPXEAndGetWallet(
       this.aztecNode,
+      this.context.aztecNode,
       { proverEnabled: this.realProofs },
       undefined,
       'pxe-proven',
@@ -225,7 +226,7 @@ export class FullProverTest {
       this.context.genesis!.genesisTimestamp,
     );
 
-    const proverNodeConfig: Parameters<typeof AztecNodeService.createAndSync>[0] = {
+    const proverNodeConfig: Parameters<typeof createAztecNodeService>[0] = {
       ...config,
       enableProverNode: true,
       disableValidator: true,
@@ -250,7 +251,7 @@ export class FullProverTest {
       validatorPrivateKeys: new SecretValue([]),
     };
 
-    this.proverAztecNode = await AztecNodeService.createAndSync(
+    this.proverAztecNode = await createAztecNodeService(
       proverNodeConfig,
       { dateProvider: this.context.dateProvider, p2pClientDeps: { rpcTxProviders: [this.aztecNode] } },
       { genesis },

package/src/fixtures/fixtures.ts

@@ -109,6 +109,14 @@ export const TEST_PEER_CHECK_INTERVAL_MS = 1000;
 export const TEST_MAX_PENDING_TX_POOL_COUNT = 10_000; // Number of max pending TXs ~ 1.56GB
 
 export const MNEMONIC = 'test test test test test test test test test test test junk';
+
+// Mnemonic account index for tests that issue direct L1 writes (e.g. bridging fee juice) while a
+// sequencer is running. The deployer/sequencer publisher uses index 0, the prover index 2, and
+// validators index 3+. Test-side viem writes and the publisher's l1-tx-utils track nonces
+// independently, so sharing an account causes "replacement transaction underpriced" races; index 1
+// is otherwise unused, so issuing those writes from it keeps them off the publisher's nonce stream.
+export const L1_DIRECT_WRITE_ACCOUNT_INDEX = 1;
+
 export const privateKey = Buffer.from('ac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80', 'hex');
 export const privateKey2 = Buffer.from('59c6995e998f97a5a0044966f0945389dc9e86dae88c7a8412f4603b6b78690d', 'hex');
 

package/src/fixtures/setup.ts

@@ -1,5 +1,5 @@
 import { type InitialAccountData, generateSchnorrAccounts } from '@aztec/accounts/testing';
-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 type { ContractMethod } from '@aztec/aztec.js/contracts';
 import { publishContractClass, publishInstance } from '@aztec/aztec.js/deployment';
@@ -109,6 +109,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').
@@ -116,6 +118,7 @@ export async function setupSharedBlobStorage(config: { dataDirectory?: string }
  */
 export async function setupPXEAndGetWallet(
   aztecNode: AztecNode,
+  nodeDebug: AztecNodeDebug | undefined,
   opts: Partial<PXEConfig> = {},
   logger = getLogger(),
   actor?: string,
@@ -136,7 +139,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,
@@ -294,6 +300,17 @@ function assertContractArtifactsVersion() {
   }
 }
 
+/**
+ * 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: 'setup' | 'teardown', ms: number) {
+  const collector = (globalThis as { __e2eTimings?: { current: string | null; fnSpans: unknown[] } }).__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.
@@ -305,6 +322,20 @@ export async function setup(
   opts: SetupOptions = {},
   pxeOpts: Partial<PXEConfig> = {},
   chain: Chain = foundry,
+): Promise<EndToEndContext> {
+  const setupStart = performance.now();
+  try {
+    return await setupInner(numberOfAccounts, opts, pxeOpts, chain);
+  } finally {
+    recordFnSpan('setup', performance.now() - setupStart);
+  }
+}
+
+async function setupInner(
+  numberOfAccounts: number,
+  opts: SetupOptions,
+  pxeOpts: Partial<PXEConfig>,
+  chain: Chain,
 ): Promise<EndToEndContext> {
   assertContractArtifactsVersion();
   let anvil: Anvil | undefined;
@@ -556,7 +587,7 @@ export async function setup(
       : config;
 
     const aztecNodeService = await withLoggerBindings({ actor: 'node-0' }, () =>
-      AztecNodeService.createAndSync(
+      createAztecNodeService(
         initialNodeConfig,
         { dateProvider, telemetry: telemetryClient, p2pClientDeps },
         { genesis, dontStartSequencer: opts.skipInitialSequencer },
@@ -598,6 +629,8 @@ export async function setup(
     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,
     });
 
@@ -605,12 +638,7 @@ export async function setup(
       wallet.setMinFeePadding(opts.walletMinFeePadding);
     }
 
-    const cheatCodes = await CheatCodes.create(
-      config.l1RpcUrls,
-      aztecNodeService,
-      dateProvider,
-      aztecNodeService.getAutomineSequencer(),
-    );
+    const cheatCodes = await CheatCodes.create(config.l1RpcUrls, aztecNodeService, dateProvider);
 
     if (
       (opts.aztecTargetCommitteeSize && opts.aztecTargetCommitteeSize > 0) ||
@@ -664,6 +692,7 @@ export async function setup(
     }
 
     const teardown = async () => {
+      const teardownStart = performance.now();
       try {
         await tryStop(wallet, logger);
         await tryStop(aztecNodeService, logger);
@@ -688,6 +717,7 @@ export async function setup(
         } catch (err) {
           logger.error(`Error during telemetry client stop`, err);
         }
+        recordFnSpan('teardown', performance.now() - teardownStart);
       }
     };
 
@@ -807,7 +837,7 @@ export function createAndSyncProverNode(
   options: { genesis?: GenesisData; dontStart?: boolean },
 ): Promise<{ proverNode: AztecNodeService }> {
   return withLoggerBindings({ actor: 'prover-0' }, async () => {
-    const proverNode = await AztecNodeService.createAndSync(
+    const proverNode = await createAztecNodeService(
       {
         ...baseConfig,
         ...configOverrides,

package/src/fixtures/setup_p2p_test.ts

@@ -1,7 +1,7 @@
 /**
  * Test fixtures and utilities to set up and run a test using multiple validators
  */
-import { type AztecNodeConfig, AztecNodeService } from '@aztec/aztec-node';
+import { type AztecNodeConfig, AztecNodeService, createAztecNodeService } from '@aztec/aztec-node';
 import { range } from '@aztec/foundation/array';
 import { SecretValue } from '@aztec/foundation/config';
 import { withLoggerBindings } from '@aztec/foundation/log/server';
@@ -109,7 +109,7 @@ export async function createNode(
   return await withLoggerBindings({ actor: `validator-${actorIndex}` }, async () => {
     const validatorConfig = await createValidatorConfig(config, bootstrapNode, tcpPort, addressIndex, dataDirectory);
     const telemetry = await getEndToEndTestTelemetryClient(metricsPort);
-    return await AztecNodeService.createAndSync(
+    return await createAztecNodeService(
       validatorConfig,
       { telemetry, dateProvider },
       { genesis, dontStartSequencer: config.dontStartSequencer },
@@ -137,7 +137,7 @@ export async function createNonValidatorNode(
       sequencerPublisherPrivateKeys: [],
     };
     const telemetry = await getEndToEndTestTelemetryClient(metricsPort);
-    return await AztecNodeService.createAndSync(config, { telemetry, dateProvider }, { genesis });
+    return await createAztecNodeService(config, { telemetry, dateProvider }, { genesis });
   });
 }
 

package/src/fixtures/token_utils.ts

@@ -3,6 +3,15 @@ import { BatchCall } from '@aztec/aztec.js/contracts';
 import type { Logger } from '@aztec/aztec.js/log';
 import type { Wallet } from '@aztec/aztec.js/wallet';
 import { TokenContract } from '@aztec/noir-contracts.js/Token';
+import { TestTokenContract } from '@aztec/noir-test-contracts.js/TestToken';
+
+/**
+ * Either token flavour. Canonical `TokenContract` uses constrained message delivery (production / docs
+ * source of truth); `TestTokenContract` is its codegen'd unconstrained-delivery sibling, used by tests
+ * where a token is just a unit-of-account vehicle. The two share an identical ABI, so helpers that only
+ * read balances or mint accept either.
+ */
+export type AnyTokenContract = TokenContract | TestTokenContract;
 
 export async function deployToken(wallet: Wallet, admin: AztecAddress, initialAdminBalance: bigint, logger: Logger) {
   logger.info(`Deploying Token contract...`);
@@ -19,8 +28,34 @@ export async function deployToken(wallet: Wallet, admin: AztecAddress, initialAd
   return { contract, instance };
 }
 
+/**
+ * Deploys the unconstrained-delivery `TestTokenContract`. Use this in tests where the token is a
+ * unit-of-account vehicle rather than the subject, so they don't pay constrained delivery's first-send
+ * handshake cost (which distorts step/log counts that benches assert on). Use {@link deployToken} when a
+ * test exercises canonical Token semantics or note discovery.
+ */
+export async function deployTestToken(
+  wallet: Wallet,
+  admin: AztecAddress,
+  initialAdminBalance: bigint,
+  logger: Logger,
+) {
+  logger.info(`Deploying TestToken contract...`);
+  const { contract, instance } = await TestTokenContract.deploy(wallet, admin, 'TokenName', 'TokenSymbol', 18).send({
+    from: admin,
+  });
+
+  if (initialAdminBalance > 0n) {
+    await mintTokensToPrivate(contract, admin, admin, initialAdminBalance);
+  }
+
+  logger.info('L2 contract deployed');
+
+  return { contract, instance };
+}
+
 export async function mintTokensToPrivate(
-  token: TokenContract,
+  token: AnyTokenContract,
   minter: AztecAddress,
   recipient: AztecAddress,
   amount: bigint,
@@ -31,13 +66,13 @@ export async function mintTokensToPrivate(
 
 export async function expectTokenBalance(
   wallet: Wallet,
-  token: TokenContract,
+  token: AnyTokenContract,
   owner: AztecAddress,
   expectedBalance: bigint,
   logger: Logger,
 ) {
   // Then check the balance
-  const contractWithWallet = TokenContract.at(token.address, wallet);
+  const contractWithWallet = token.withWallet(wallet);
   const { result: balance } = await contractWithWallet.methods.balance_of_private(owner).simulate({ from: owner });
   logger.info(`Account ${owner} balance: ${balance}`);
   expect(balance).toBe(expectedBalance);
@@ -47,7 +82,7 @@ export async function mintNotes(
   wallet: Wallet,
   minter: AztecAddress,
   recipient: AztecAddress,
-  asset: TokenContract,
+  asset: AnyTokenContract,
   noteAmounts: bigint[],
 ): Promise<bigint> {
   // We can only mint 5 notes at a time, since that's the maximum number of calls our entrypoints allow

package/src/guides/up_quick_start.sh

@@ -38,6 +38,11 @@ fi
 
 TRANSFER_AMOUNT=42
 
+# Alice's bridged fee-juice claim is only consumable inboxLag (2) checkpoints after the L1->L2 message
+# is inserted. The token deploy and mint above produced two blocks; force one more here (a public mint
+# from test0, which leaves the alice/bob private balances untouched) so the claim is available below.
+aztec-wallet send mint_to_public -ca last --args accounts:test0 1 -f test0
+
 aztec-wallet send transfer_in_private -ca last --args accounts:alice accounts:bob $TRANSFER_AMOUNT 0 -f alice --payment method=fee_juice,claim
 
 # Test end result

package/src/shared/timing_env.mjs

@@ -0,0 +1,259 @@
+import { appendFileSync, writeFileSync } from 'node:fs';
+import { basename } from 'node:path';
+
+import CustomEnvironment from '../../../foundation/src/jest/env.mjs';
+
+// Per-test e2e timing environment. Gated entirely on the TEST_TIMING_FILE env var: when unset, this
+// behaves exactly like the base CustomEnvironment (it only delegates). When set, it records, per test
+// worker process, the time spent in jest before/after hooks and the test body, and merges in the
+// function-level time captured by setup.ts/teardown.ts via a collector shared on `this.global`.
+//
+// Output is one JSONL file per worker process (the env runs once per worker). Each line carries a
+// `type` discriminator and is one of:
+//   - `type: 'test'` (`name` set): beforeEach hooks, the it() body, afterEach hooks for one test; or
+//   - `type: 'suite'` (`name: null`): the suite-scoped beforeAll/afterAll hooks for the whole file.
+export default class TimingEnvironment extends CustomEnvironment {
+  constructor(config, context) {
+    super(config, context);
+
+    this.timingFile = process.env.TEST_TIMING_FILE;
+    if (!this.timingFile) {
+      return;
+    }
+
+    this.suite = basename(context?.testPath ?? config?.testPath ?? 'unknown').replace(/\.test\.[cm]?[jt]s$/, '');
+    this.meta = {
+      commit: process.env.COMMIT_HASH ?? null,
+      branch: process.env.TARGET_BRANCH ?? process.env.REF_NAME ?? null,
+      runId: process.env.RUN_ID ?? null,
+    };
+
+    // Shared collector. setup.ts (running in the sandbox realm) reads `globalThis.__e2eTimings`; this
+    // env (host realm) reads `this.global.__e2eTimings` — they are the same object. `current` is the
+    // full name of the test currently running (null during beforeAll/afterAll), used to tag fn spans.
+    this.collector = { current: null, fnSpans: [] };
+    this.global.__e2eTimings = this.collector;
+
+    // Records to flush as JSONL on teardown. One per test plus one suite-scoped record.
+    this.records = [];
+    this.recordsByName = new Map();
+    // The suite-scoped record (beforeAll/afterAll); bodyMs/totalMs are computed at flush time.
+    this.suiteRecord = { name: null, status: 'passed', beforeHooksMs: 0, afterHooksMs: 0 };
+    // Start times keyed by hook type (beforeAll/beforeEach/afterAll/afterEach).
+    this.hookStarts = {};
+    this.testStarts = new Map();
+    // Guards against double-flushing (we flush on both the teardown event and the teardown method).
+    this.flushed = false;
+  }
+
+  // Flush on the teardown method too: the jest lifecycle always calls this, whereas the 'teardown'
+  // event is not reliably delivered when a test run is interrupted. Whichever fires first wins.
+  async teardown() {
+    this.finalizeAndFlush();
+    await super.teardown();
+  }
+
+  async handleTestEvent(event, state) {
+    // Run the base env first so its unhandledRejection patching for after-hooks stays intact.
+    await super.handleTestEvent(event, state);
+
+    if (!this.timingFile) {
+      return;
+    }
+
+    const now = Date.now();
+    switch (event.name) {
+      case 'hook_start': {
+        this.hookStarts[event.hook.type] = now;
+        break;
+      }
+      case 'hook_success':
+      case 'hook_failure': {
+        const start = this.hookStarts[event.hook.type];
+        if (start === undefined) {
+          break;
+        }
+        delete this.hookStarts[event.hook.type];
+        const ms = now - start;
+        if (event.hook.type === 'beforeEach') {
+          this.addToCurrent('beforeHooksMs', ms);
+        } else if (event.hook.type === 'afterEach') {
+          this.addToCurrent('afterHooksMs', ms);
+        } else if (event.hook.type === 'beforeAll') {
+          this.suiteRecord.beforeHooksMs += ms;
+        } else if (event.hook.type === 'afterAll') {
+          this.suiteRecord.afterHooksMs += ms;
+        }
+        break;
+      }
+      case 'test_start': {
+        const name = this.fullTestName(event.test);
+        const record = {
+          type: 'test',
+          name,
+          status: 'passed',
+          setupFnMs: 0,
+          beforeHooksMs: 0,
+          bodyMs: 0,
+          teardownFnMs: 0,
+          afterHooksMs: 0,
+          totalMs: 0,
+          startedAt: new Date(now).toISOString(),
+        };
+        this.records.push(record);
+        this.recordsByName.set(name, record);
+        this.testStarts.set(name, now);
+        this.collector.current = name;
+        break;
+      }
+      case 'test_fn_start': {
+        this.testStarts.set(`fn:${this.fullTestName(event.test)}`, now);
+        break;
+      }
+      case 'test_fn_success':
+      case 'test_fn_failure': {
+        const name = this.fullTestName(event.test);
+        const start = this.testStarts.get(`fn:${name}`);
+        const record = this.recordsByName.get(name);
+        if (record && start !== undefined) {
+          record.bodyMs = now - start;
+        }
+        if (record && event.name === 'test_fn_failure') {
+          record.status = 'failed';
+        }
+        break;
+      }
+      case 'test_done': {
+        const name = this.fullTestName(event.test);
+        const record = this.recordsByName.get(name);
+        const start = this.testStarts.get(name);
+        if (record && start !== undefined) {
+          record.totalMs = now - start;
+        }
+        if (record && event.test?.errors?.length) {
+          record.status = 'failed';
+        }
+        this.mergeFnSpans(name, record);
+        this.collector.current = null;
+        break;
+      }
+      case 'teardown': {
+        this.finalizeAndFlush();
+        break;
+      }
+      default:
+        break;
+    }
+  }
+
+  /** The record for the test currently running, if any. */
+  currentRecord() {
+    return this.collector.current ? this.recordsByName.get(this.collector.current) : undefined;
+  }
+
+  /** Adds `ms` to a hook bucket on the current per-test record, or the suite record during beforeAll/afterAll. */
+  addToCurrent(field, ms) {
+    const record = this.currentRecord();
+    if (record) {
+      record[field] += ms;
+    }
+  }
+
+  /** Builds the full test name by walking up the describe blocks, matching jest's currentTestName. */
+  fullTestName(test) {
+    if (!test) {
+      return null;
+    }
+    const parts = [];
+    let node = test;
+    while (node && node.name && node.name !== 'ROOT_DESCRIBE_BLOCK') {
+      parts.unshift(node.name);
+      node = node.parent;
+    }
+    return parts.join(' ');
+  }
+
+  /** Moves fn spans tagged with `name` into the matching record's setup/teardown buckets. */
+  mergeFnSpans(name, record) {
+    if (!record) {
+      return;
+    }
+    const remaining = [];
+    for (const span of this.collector.fnSpans) {
+      if (span.name === name) {
+        if (span.kind === 'setup') {
+          record.setupFnMs += span.ms;
+        } else if (span.kind === 'teardown') {
+          record.teardownFnMs += span.ms;
+        }
+      } else {
+        remaining.push(span);
+      }
+    }
+    this.collector.fnSpans = remaining;
+  }
+
+  /** Finalizes the suite-scoped record (untagged fn spans + beforeAll/afterAll) and writes all JSONL. */
+  finalizeAndFlush() {
+    if (this.flushed || !this.timingFile) {
+      return;
+    }
+    this.flushed = true;
+    const suite = {
+      setupFnMs: 0,
+      beforeHooksMs: this.suiteRecord.beforeHooksMs,
+      teardownFnMs: 0,
+      afterHooksMs: this.suiteRecord.afterHooksMs,
+    };
+    for (const span of this.collector.fnSpans) {
+      if (span.name === null || span.name === undefined) {
+        if (span.kind === 'setup') {
+          suite.setupFnMs += span.ms;
+        } else if (span.kind === 'teardown') {
+          suite.teardownFnMs += span.ms;
+        }
+      }
+    }
+    this.collector.fnSpans = [];
+
+    const lines = [];
+    for (const record of this.records) {
+      lines.push(this.toLine({ ...record }));
+    }
+    lines.push(
+      this.toLine({
+        type: 'suite',
+        name: null,
+        status: 'passed',
+        setupFnMs: suite.setupFnMs,
+        beforeHooksMs: suite.beforeHooksMs,
+        teardownFnMs: suite.teardownFnMs,
+        afterHooksMs: suite.afterHooksMs,
+        totalMs: suite.beforeHooksMs + suite.afterHooksMs,
+      }),
+    );
+
+    const payload = lines.join('\n') + '\n';
+    try {
+      // One file per worker process, but a worker may run several suites: append so we keep them all.
+      appendFileSync(this.timingFile, payload);
+    } catch {
+      try {
+        writeFileSync(this.timingFile, payload);
+      } catch {
+        // Timing is best-effort; never fail a test because we couldn't write the file.
+      }
+    }
+  }
+
+  /** Flattens metadata onto a record and serializes to a single JSON line. */
+  toLine(record) {
+    const obj = { suite: this.suite, ...record, ...this.meta };
+    for (const key of Object.keys(obj)) {
+      if (key.endsWith('Ms') && typeof obj[key] === 'number') {
+        obj[key] = Math.round(obj[key]);
+      }
+    }
+    return JSON.stringify(obj);
+  }
+}

package/src/simulators/lending_simulator.ts

@@ -208,7 +208,7 @@ export class LendingSimulator {
     expect(interestAccumulator).toEqual(this.accumulator);
     expect(asset['last_updated_ts']).toEqual(BigInt(this.time));
 
-    for (const key of [this.account.address, AztecAddress.fromField(await this.account.key())]) {
+    for (const key of [this.account.address, AztecAddress.fromFieldUnsafe(await this.account.key())]) {
       const { result: privatePos } = await this.lendingContract.methods
         .get_position(key)
         .simulate({ from: this.account.address });