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

package/dest/shared/timing_env.js

@@ -3,13 +3,23 @@ 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`.
+// worker process, the time spent in jest before/after hooks and the test body, and folds in the named
+// spans recorded via the `testSpan()` wrapper (fixtures/timing.ts) through 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.
+//
+// Each line also gains a `spans` map: per `category:label` tag the test/suite touched, the collector
+// records `{ count, totalMs, busyMs, maxMs }`. `busyMs` is the duration of the union of the spans'
+// `[start, end)` intervals on the shared `performance.now()` clock, so concurrent spans (Promise.all
+// fan-out) do not inflate it the way `totalMs` does. The legacy `setupFnMs`/`teardownFnMs` fields are
+// kept for back-compat, derived from the `setup:env`/`teardown:env` spans.
+//
+// When `TEST_TIMING_SPANS=1`, the collector additionally retains every raw span occurrence and emits
+// one `type:"span"` line per occurrence (owner, name, ms) for deep dives, at the cost of a larger file.
 export default class TimingEnvironment extends CustomEnvironment {
     constructor(config, context){
         super(config, context);
@@ -23,12 +33,18 @@ export default class TimingEnvironment extends CustomEnvironment {
             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.
+        // Opt-in per-occurrence emission for deep dives (off by default keeps the JSONL one line per test).
+        this.emitSpanLines = process.env.TEST_TIMING_SPANS === '1';
+        // Shared collector. The instrumented helpers (running in the sandbox realm) read
+        // `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 attribute each span to a test or to the suite-scoped line. `spans`
+        // accumulates every recorded span until flush. The `start`/`end` timestamps come from the sandbox
+        // realm's `performance.now()`; Node's perf clock is process-wide (one monotonic origin across all
+        // realms), so merging the intervals here for `busyMs` is valid.
         this.collector = {
             current: null,
-            fnSpans: []
+            spans: []
         };
         this.global.__e2eTimings = this.collector;
         // Records to flush as JSONL on teardown. One per test plus one suite-scoped record.
@@ -46,6 +62,8 @@ export default class TimingEnvironment extends CustomEnvironment {
         this.testStarts = new Map();
         // Guards against double-flushing (we flush on both the teardown event and the teardown method).
         this.flushed = false;
+        // Raw per-occurrence spans retained only when TEST_TIMING_SPANS=1, emitted as `type:"span"` lines.
+        this.rawSpans = [];
     }
     // 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.
@@ -137,7 +155,6 @@ export default class TimingEnvironment extends CustomEnvironment {
                     if (record && event.test?.errors?.length) {
                         record.status = 'failed';
                     }
-                    this.mergeFnSpans(name, record);
                     this.collector.current = null;
                     break;
                 }
@@ -171,45 +188,21 @@ export default class TimingEnvironment extends CustomEnvironment {
         }
         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;
+    /** Folds the collected spans into the per-test / suite records via {@link foldSpansInto}, then drains the collector. */ foldSpans() {
+        const rawSpans = foldSpansInto(this.collector.spans, {
+            recordsByName: this.recordsByName,
+            suiteRecord: this.suiteRecord,
+            emitSpanLines: this.emitSpanLines
+        });
+        this.rawSpans.push(...rawSpans);
+        this.collector.spans = [];
     }
-    /** Finalizes the suite-scoped record (untagged fn spans + beforeAll/afterAll) and writes all JSONL. */ finalizeAndFlush() {
+    /** Folds spans into records, finalizes the suite-scoped record, 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 = [];
+        this.foldSpans();
         const lines = [];
         for (const record of this.records){
             lines.push(this.toLine({
@@ -220,12 +213,21 @@ export default class TimingEnvironment extends CustomEnvironment {
             type: 'suite',
             name: null,
             status: 'passed',
-            setupFnMs: suite.setupFnMs,
-            beforeHooksMs: suite.beforeHooksMs,
-            teardownFnMs: suite.teardownFnMs,
-            afterHooksMs: suite.afterHooksMs,
-            totalMs: suite.beforeHooksMs + suite.afterHooksMs
+            setupFnMs: this.suiteRecord.setupFnMs ?? 0,
+            beforeHooksMs: this.suiteRecord.beforeHooksMs,
+            teardownFnMs: this.suiteRecord.teardownFnMs ?? 0,
+            afterHooksMs: this.suiteRecord.afterHooksMs,
+            totalMs: this.suiteRecord.beforeHooksMs + this.suiteRecord.afterHooksMs,
+            spans: this.suiteRecord.spans
         }));
+        for (const raw of this.rawSpans){
+            lines.push(this.toLine({
+                type: 'span',
+                name: raw.owner,
+                span: raw.name,
+                ms: raw.ms
+            }));
+        }
         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.
@@ -238,7 +240,7 @@ export default class TimingEnvironment extends CustomEnvironment {
             }
         }
     }
-    /** Flattens metadata onto a record and serializes to a single JSON line. */ toLine(record) {
+    /** Flattens metadata onto a record and serializes to a single JSON line, rounding all Ms fields. */ toLine(record) {
         const obj = {
             suite: this.suite,
             ...record,
@@ -249,6 +251,115 @@ export default class TimingEnvironment extends CustomEnvironment {
                 obj[key] = Math.round(obj[key]);
             }
         }
+        // Round the nested span aggregates' Ms fields too (totalMs/busyMs/maxMs per tag).
+        if (obj.spans && typeof obj.spans === 'object') {
+            for (const agg of Object.values(obj.spans)){
+                for (const key of Object.keys(agg)){
+                    if (key.endsWith('Ms') && typeof agg[key] === 'number') {
+                        agg[key] = Math.round(agg[key]);
+                    }
+                }
+            }
+        }
         return JSON.stringify(obj);
     }
 }
+/**
+ * Aggregates a list of `{ start, end }` spans of one tag into `{ count, totalMs, busyMs, maxMs }`.
+ * `totalMs` is the naive sum of per-occurrence durations (correct for serial repeats); `busyMs` is
+ * the duration of the union of the `[start, end)` intervals (concurrency-correct — N concurrent
+ * spans collapse to their wall-clock span instead of summing to ~N×); `maxMs` is the longest single
+ * occurrence. All durations are on the shared process-wide `performance.now()` clock. Does not mutate
+ * the input array.
+ */ export function aggregateSpans(spans) {
+    let totalMs = 0;
+    let maxMs = 0;
+    for (const span of spans){
+        const ms = span.end - span.start;
+        totalMs += ms;
+        if (ms > maxMs) {
+            maxMs = ms;
+        }
+    }
+    // busyMs: sort by start and merge overlapping intervals, summing the merged lengths.
+    const sorted = [
+        ...spans
+    ].sort((a, b)=>a.start - b.start);
+    let busyMs = 0;
+    let mergeStart = null;
+    let mergeEnd = null;
+    for (const span of sorted){
+        if (mergeStart === null) {
+            mergeStart = span.start;
+            mergeEnd = span.end;
+        } else if (span.start <= mergeEnd) {
+            if (span.end > mergeEnd) {
+                mergeEnd = span.end;
+            }
+        } else {
+            busyMs += mergeEnd - mergeStart;
+            mergeStart = span.start;
+            mergeEnd = span.end;
+        }
+    }
+    if (mergeStart !== null) {
+        busyMs += mergeEnd - mergeStart;
+    }
+    return {
+        count: spans.length,
+        totalMs,
+        busyMs,
+        maxMs
+    };
+}
+/**
+ * Groups `spans` by owner, then by tag, and attaches a `spans` map of aggregates to the matching
+ * per-test record (looked up in `recordsByName`) or, for `null`-owner spans, to `suiteRecord`. Also
+ * derives the back-compat `setupFnMs` / `teardownFnMs` fields from the `setup:env:<mode>` /
+ * `teardown:env` aggregates (additive over any pre-existing value). Spans whose owner matches no
+ * record (e.g. the pinned `other:mempool-feeder` owner) are dropped. Returns the raw per-occurrence
+ * list (`{ owner, name, ms }`), which is empty unless `emitSpanLines` is set.
+ */ export function foldSpansInto(spans, { recordsByName, suiteRecord, emitSpanLines = false }) {
+    const rawSpans = [];
+    // Group by owner (null owner → suite record), then by tag.
+    const byOwner = new Map();
+    for (const span of spans){
+        const owner = span.owner ?? null;
+        let byName = byOwner.get(owner);
+        if (!byName) {
+            byName = new Map();
+            byOwner.set(owner, byName);
+        }
+        let list = byName.get(span.name);
+        if (!list) {
+            list = [];
+            byName.set(span.name, list);
+        }
+        list.push(span);
+        if (emitSpanLines) {
+            rawSpans.push({
+                owner,
+                name: span.name,
+                ms: span.end - span.start
+            });
+        }
+    }
+    for (const [owner, byName] of byOwner){
+        const record = owner === null ? suiteRecord : recordsByName.get(owner);
+        if (!record) {
+            continue;
+        }
+        const aggregates = {};
+        for (const [name, list] of byName){
+            aggregates[name] = aggregateSpans(list);
+        }
+        record.spans = aggregates;
+        // Back-compat: the legacy fn-span buckets are derived from the top-level env setup/teardown tags.
+        // The top-level setup is tagged `setup:env:<proverMode>` (the mode is a closed set, distinct from
+        // the `:anvil`/`:l1-deploy`/... sub-phase tags), so sum those three exact tags.
+        const setupFnMs = (aggregates['setup:env:none']?.totalMs ?? 0) + (aggregates['setup:env:fake']?.totalMs ?? 0) + (aggregates['setup:env:real']?.totalMs ?? 0);
+        record.setupFnMs = setupFnMs + (record.setupFnMs ?? 0);
+        record.teardownFnMs = (aggregates['teardown:env']?.totalMs ?? 0) + (record.teardownFnMs ?? 0);
+    }
+    return rawSpans;
+}

package/dest/shared/wait_for_l1_to_l2_message.js

@@ -6,5 +6,5 @@ import { retryUntil } from '@aztec/foundation/retry';
  * the message has been picked up from L1. Use this in tests that explicitly produce L2
  * blocks afterwards to make the message consumable.
  */ export function waitForL1ToL2MessageSeen(node, l1ToL2MessageHash, opts) {
-    return retryUntil(async ()=>await node.getL1ToL2MessageCheckpoint(l1ToL2MessageHash) !== undefined, `L1 to L2 message ${l1ToL2MessageHash.toString()} seen`, opts.timeoutSeconds, 1);
+    return retryUntil(async ()=>await node.getL1ToL2MessageCheckpoint(l1ToL2MessageHash) !== undefined, `L1 to L2 message ${l1ToL2MessageHash.toString()} seen`, opts.timeoutSeconds, 0.25);
 }

package/dest/single-node/cross-chain/cross_chain_messaging_test.d.ts

@@ -0,0 +1,75 @@
+import type { AztecNodeConfig } from '@aztec/aztec-node';
+import { AztecAddress, EthAddress } from '@aztec/aztec.js/addresses';
+import type { AztecNode } from '@aztec/aztec.js/node';
+import type { TxReceipt } from '@aztec/aztec.js/tx';
+import { CheatCodes, EpochTestSettler } from '@aztec/aztec/testing';
+import { InboxContract, OutboxContract } from '@aztec/ethereum/contracts';
+import type { DeployAztecL1ContractsArgs, DeployAztecL1ContractsReturnType } from '@aztec/ethereum/deploy-aztec-l1-contracts';
+import type { ExtendedViemWalletClient } from '@aztec/ethereum/types';
+import { EpochNumber } from '@aztec/foundation/branded-types';
+import { TokenContract } from '@aztec/noir-contracts.js/Token';
+import { TokenBridgeContract } from '@aztec/noir-contracts.js/TokenBridge';
+import type { PXEConfig } from '@aztec/pxe/server';
+import type { AztecNodeAdmin } from '@aztec/stdlib/interfaces/client';
+import { type SetupOptions } from '../../fixtures/setup.js';
+import { CrossChainTestHarness } from '../../shared/cross_chain_test_harness.js';
+import type { TestWallet } from '../../test-wallet/test_wallet.js';
+import { SingleNodeTestContext, type SingleNodeTestOpts } from '../single_node_test_context.js';
+/** Optional configuration for {@link CrossChainMessagingTest}. */
+export type CrossChainMessagingTestOpts = {
+    /** Mnemonic account index for the harness L1 client (token portal, inbox, minting). Defaults to the first account. */
+    l1HarnessAccountIndex?: number;
+    /** Whether to deploy the L1/L2 token bridge. Set to false for suites that only pass arbitrary messages. Defaults to true. */
+    deployTokenBridge?: boolean;
+};
+/**
+ * The cross-chain-messaging harness over the single-node topology: extends {@link SingleNodeTestContext}
+ * so it reuses the base node tracking / chain monitor / teardown machinery, but builds its environment
+ * with the bespoke cross-chain opts below (optional prover node, sponsored-FPC funding, a generous
+ * prover tx-gathering window for the epoch warps) rather than the base's default node config, and owns
+ * the {@link CrossChainTestHarness} domain object plus the L1 inbox/outbox handles.
+ */
+export declare class CrossChainMessagingTest extends SingleNodeTestContext {
+    private requireEpochProven;
+    private setupOptions;
+    private deployL1ContractsArgs;
+    private pxeOpts;
+    private l1HarnessAccountIndex?;
+    private deployTokenBridge;
+    /** L1 token portal + ERC20 deployed before the node started (under automine) by the setup hook. */
+    private preDeployedCrossChainL1?;
+    private testName;
+    aztecNode: AztecNode;
+    aztecNodeConfig: AztecNodeConfig;
+    aztecNodeAdmin: AztecNodeAdmin;
+    wallet: TestWallet;
+    ownerAddress: AztecAddress;
+    user1Address: AztecAddress;
+    user2Address: AztecAddress;
+    crossChainTestHarness: CrossChainTestHarness;
+    ethAccount: EthAddress;
+    /** L1 client used for cross-chain L1 interactions (token portal, inbox), tied to `l1HarnessAccountIndex`. */
+    harnessL1Client: ExtendedViemWalletClient;
+    l2Token: TokenContract;
+    l2Bridge: TokenBridgeContract;
+    inbox: InboxContract;
+    outbox: OutboxContract;
+    cheatCodes: CheatCodes;
+    /**
+     * Background loop that marks each completed epoch as proven on L1. Started in `applyBaseSetup`
+     * when the test runs without a real prover node, because the e2e fixture uses L1 interval mining
+     * and nothing marks blocks proven automatically. Without this, L1's `aztecProofSubmissionEpochs`
+     * window expires mid-test and triggers a chain prune that drops in-flight wallet txs. Tests that
+     * intentionally pause proving (e.g. inbox drift tests) can stop it via
+     * `await t.epochTestSettler?.stop()`.
+     */
+    epochTestSettler?: EpochTestSettler;
+    deployL1ContractsValues: DeployAztecL1ContractsReturnType;
+    constructor(testName: string, opts?: SetupOptions, deployL1ContractsArgs?: Partial<DeployAztecL1ContractsArgs>, pxeOpts?: Partial<PXEConfig>, crossChainOpts?: CrossChainMessagingTestOpts);
+    setup(opts?: SingleNodeTestOpts, pxeOpts?: Partial<PXEConfig>): Promise<void>;
+    advanceToEpochProven(l2TxReceipt: TxReceipt): Promise<EpochNumber>;
+    catchUpProvenChain(): Promise<void>;
+    teardown(): Promise<void>;
+    applyBaseSetup(): Promise<void>;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dest/single-node/cross-chain/cross_chain_messaging_test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cross_chain_messaging_test.d.ts","sourceRoot":"","sources":["../../../src/single-node/cross-chain/cross_chain_messaging_test.ts"],"names":[],"mappings":"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"}

package/dest/{e2e_cross_chain_messaging → single-node/cross-chain}/cross_chain_messaging_test.js

@@ -9,34 +9,42 @@ import { pickL1ContractAddresses } from '@aztec/ethereum/l1-contract-addresses';
 import { EpochNumber } from '@aztec/foundation/branded-types';
 import { retryUntil } from '@aztec/foundation/retry';
 import { sleep } from '@aztec/foundation/sleep';
-import { TestERC20Abi, TestERC20Bytecode } from '@aztec/l1-artifacts';
+import { TestERC20Abi, TestERC20Bytecode, TokenPortalAbi, TokenPortalBytecode } from '@aztec/l1-artifacts';
 import { TokenContract } from '@aztec/noir-contracts.js/Token';
 import { TokenBridgeContract } from '@aztec/noir-contracts.js/TokenBridge';
 import { getEpochAtSlot } from '@aztec/stdlib/epoch-helpers';
-import { MNEMONIC } from '../fixtures/fixtures.js';
-import { ensureAuthRegistryPublished, setup, teardown } from '../fixtures/setup.js';
-import { CrossChainTestHarness } from '../shared/cross_chain_test_harness.js';
-export class CrossChainMessagingTest {
+import { mnemonicToAccount } from 'viem/accounts';
+import { MNEMONIC } from '../../fixtures/fixtures.js';
+import { ensureAuthRegistryPublished, setup } from '../../fixtures/setup.js';
+import { CrossChainTestHarness } from '../../shared/cross_chain_test_harness.js';
+import { SingleNodeTestContext } from '../single_node_test_context.js';
+/**
+ * The cross-chain-messaging harness over the single-node topology: extends {@link SingleNodeTestContext}
+ * so it reuses the base node tracking / chain monitor / teardown machinery, but builds its environment
+ * with the bespoke cross-chain opts below (optional prover node, sponsored-FPC funding, a generous
+ * prover tx-gathering window for the epoch warps) rather than the base's default node config, and owns
+ * the {@link CrossChainTestHarness} domain object plus the L1 inbox/outbox handles.
+ */ export class CrossChainMessagingTest extends SingleNodeTestContext {
     requireEpochProven;
     setupOptions;
     deployL1ContractsArgs;
     pxeOpts;
     l1HarnessAccountIndex;
-    logger;
-    context;
+    deployTokenBridge;
+    /** L1 token portal + ERC20 deployed before the node started (under automine) by the setup hook. */ preDeployedCrossChainL1;
+    testName;
     aztecNode;
     aztecNodeConfig;
     aztecNodeAdmin;
-    l1Client;
     wallet;
     ownerAddress;
     user1Address;
     user2Address;
     crossChainTestHarness;
     ethAccount;
+    /** L1 client used for cross-chain L1 interactions (token portal, inbox), tied to `l1HarnessAccountIndex`. */ harnessL1Client;
     l2Token;
     l2Bridge;
-    rollup;
     inbox;
     outbox;
     cheatCodes;
@@ -49,7 +57,9 @@ export class CrossChainMessagingTest {
    * `await t.epochTestSettler?.stop()`.
    */ epochTestSettler;
     deployL1ContractsValues;
-    constructor(testName, opts = {}, deployL1ContractsArgs = {}, pxeOpts = {}, l1HarnessAccountIndex){
+    constructor(testName, opts = {}, deployL1ContractsArgs = {}, pxeOpts = {}, crossChainOpts = {}){
+        super();
+        this.testName = testName;
         this.logger = createLogger(`e2e:e2e_cross_chain_messaging:${testName}`);
         this.setupOptions = opts;
         this.deployL1ContractsArgs = {
@@ -57,14 +67,15 @@ export class CrossChainMessagingTest {
             ...deployL1ContractsArgs
         };
         this.pxeOpts = pxeOpts;
-        this.l1HarnessAccountIndex = l1HarnessAccountIndex;
+        this.l1HarnessAccountIndex = crossChainOpts.l1HarnessAccountIndex;
+        this.deployTokenBridge = crossChainOpts.deployTokenBridge ?? true;
         this.requireEpochProven = opts.startProverNode ?? false;
     }
     async setup(opts = {}, pxeOpts = {}) {
         this.logger.info('Setting up cross chain messaging test');
         // Recompute requireEpochProven from the merged options so per-call startProverNode is honored.
         this.requireEpochProven = opts.startProverNode ?? this.setupOptions.startProverNode ?? false;
-        this.context = await setup(3, {
+        const context = await setup(3, {
             ...this.setupOptions,
             ...opts,
             fundSponsoredFPC: true,
@@ -80,11 +91,39 @@ export class CrossChainMessagingTest {
                 ...this.setupOptions.proverNodeConfig,
                 ...opts.proverNodeConfig,
                 txGatheringTimeoutMs: opts.proverNodeConfig?.txGatheringTimeoutMs ?? 10 * 60 * 1000
-            }
+            },
+            // Deploy the cross-chain token portal + ERC20 before the node starts, while anvil is still
+            // automining, instead of paying the L1 block interval for them once the sequencer is live.
+            deployExtraL1Contracts: this.deployTokenBridge ? async ({ l1Client, logger })=>{
+                // The harness mints the underlying ERC20 from `l1HarnessAccountIndex` and `TestERC20.mint`
+                // is onlyMinter, so its owner/initial-minter must be that account even though setup's
+                // publisher client sends the deploy tx.
+                const harnessAddress = mnemonicToAccount(MNEMONIC, {
+                    addressIndex: this.l1HarnessAccountIndex ?? 0
+                }).address;
+                const { address: underlyingERC20Address } = await deployL1Contract(l1Client, TestERC20Abi, TestERC20Bytecode, [
+                    'Underlying',
+                    'UND',
+                    harnessAddress
+                ]);
+                // The TokenPortal's initialize is permissionless, so it can be deployed by the publisher.
+                const { address: tokenPortalAddress } = await deployL1Contract(l1Client, TokenPortalAbi, TokenPortalBytecode);
+                this.preDeployedCrossChainL1 = {
+                    underlyingERC20Address,
+                    tokenPortalAddress
+                };
+                logger.verbose(`Pre-deployed cross-chain L1 ERC20 ${underlyingERC20Address} and portal ${tokenPortalAddress}`);
+                return this.preDeployedCrossChainL1;
+            } : undefined
         }, {
             ...this.pxeOpts,
             ...pxeOpts
         });
+        // Reuse the base context machinery (rollup, epoch cache, chain monitor, node tracking, teardown)
+        // over the environment built above. Restore the CrossChainMessagingTest-named logger afterwards,
+        // since hydrateFromContext repoints `this.logger` at the context logger.
+        await this.hydrateFromContext(context);
+        this.logger = createLogger(`e2e:e2e_cross_chain_messaging:${this.testName}`);
         await this.applyBaseSetup();
     }
     async advanceToEpochProven(l2TxReceipt) {
@@ -111,7 +150,7 @@ export class CrossChainMessagingTest {
     }
     async teardown() {
         await this.epochTestSettler?.stop();
-        await teardown(this.context);
+        await super.teardown();
     }
     async applyBaseSetup() {
         // Set up base context fields
@@ -136,13 +175,28 @@ export class CrossChainMessagingTest {
         this.logger.info('Applying e2e_cross_chain_messaging setup');
         await ensureAuthRegistryPublished(this.wallet, this.ownerAddress);
         const harnessL1Client = createExtendedL1Client(this.aztecNodeConfig.l1RpcUrls, MNEMONIC, undefined, undefined, this.l1HarnessAccountIndex);
-        const underlyingERC20Address = await deployL1Contract(harnessL1Client, TestERC20Abi, TestERC20Bytecode, [
-            'Underlying',
-            'UND',
-            harnessL1Client.account.address
-        ]).then(({ address })=>address);
+        this.harnessL1Client = harnessL1Client;
+        this.ethAccount = EthAddress.fromString((await harnessL1Client.getAddresses())[0]);
+        // L1 contract handles every cross-chain test needs, independent of the token bridge.
+        const l1Client = createExtendedL1Client(this.aztecNodeConfig.l1RpcUrls, MNEMONIC);
+        this.l1Client = l1Client;
+        const l1Contracts = pickL1ContractAddresses(this.aztecNodeConfig);
+        this.rollup = new RollupContract(l1Client, l1Contracts.rollupAddress.toString());
+        this.inbox = new InboxContract(l1Client, l1Contracts.inboxAddress.toString());
+        this.outbox = new OutboxContract(l1Client, l1Contracts.outboxAddress.toString());
+        // Tests that only pass arbitrary L1<->L2 messages (not token bridging) never touch the L2 token,
+        // bridge, or portal. Skip the token+portal+bridge deploy (an L1 ERC20, an L1 portal, and two L2
+        // contract deploys plus their init txs) entirely for them.
+        if (!this.deployTokenBridge) {
+            this.logger.info('Skipping token bridge deploy; test only needs L1 handles and ethAccount');
+            return;
+        }
+        // The ERC20 and token portal were deployed before the node started (under automine) by the
+        // `deployExtraL1Contracts` setup hook above; the harness reuses them and only deploys the L2 token,
+        // L2 bridge, and the portal init that need the running node.
+        const { underlyingERC20Address, tokenPortalAddress: predeployedTokenPortalAddress } = this.preDeployedCrossChainL1;
         this.logger.verbose(`Setting up cross chain harness...`);
-        this.crossChainTestHarness = await CrossChainTestHarness.new(this.aztecNode, harnessL1Client, this.wallet, this.ownerAddress, this.logger, underlyingERC20Address);
+        this.crossChainTestHarness = await CrossChainTestHarness.new(this.aztecNode, harnessL1Client, this.wallet, this.ownerAddress, this.logger, underlyingERC20Address, predeployedTokenPortalAddress);
         this.logger.verbose(`L2 token deployed to: ${this.crossChainTestHarness.l2Token.address}`);
         const crossChainContext = this.crossChainTestHarness.toCrossChainContext();
         this.l2Token = TokenContract.at(crossChainContext.l2Token, this.wallet);
@@ -150,12 +204,6 @@ export class CrossChainMessagingTest {
         // There is an issue with the reviver so we are getting strings sometimes. Working around it here.
         this.ethAccount = EthAddress.fromString(crossChainContext.ethAccount.toString());
         const tokenPortalAddress = EthAddress.fromString(crossChainContext.tokenPortal.toString());
-        const l1Client = createExtendedL1Client(this.aztecNodeConfig.l1RpcUrls, MNEMONIC);
-        this.l1Client = l1Client;
-        const l1Contracts = pickL1ContractAddresses(this.aztecNodeConfig);
-        this.rollup = new RollupContract(l1Client, l1Contracts.rollupAddress.toString());
-        this.inbox = new InboxContract(l1Client, l1Contracts.inboxAddress.toString());
-        this.outbox = new OutboxContract(l1Client, l1Contracts.outboxAddress.toString());
         this.crossChainTestHarness = new CrossChainTestHarness(this.aztecNode, this.logger, this.l2Token, this.l2Bridge, this.ethAccount, tokenPortalAddress, crossChainContext.underlying, harnessL1Client, pickL1ContractAddresses(this.aztecNodeConfig), this.wallet, this.ownerAddress);
     }
 }

package/dest/single-node/cross-chain/message_test_helpers.d.ts

@@ -0,0 +1,38 @@
+import type { AztecAddress } from '@aztec/aztec.js/addresses';
+import type { Fr } from '@aztec/aztec.js/fields';
+import type { Logger } from '@aztec/aztec.js/log';
+import type { AztecNode } from '@aztec/aztec.js/node';
+import type { Wallet } from '@aztec/aztec.js/wallet';
+import type { BlockNumber, CheckpointNumber } from '@aztec/foundation/branded-types';
+import { sendL1ToL2Message } from '../../fixtures/l1_to_l2_messaging.js';
+import type { CrossChainMessagingTest } from './cross_chain_messaging_test.js';
+/** Scope from which an L1→L2 message is consumed on L2. */
+export type L1ToL2MessageScope = 'private' | 'public';
+/** Dependencies the L1→L2 message helpers close over. */
+export interface L1ToL2MessageHelperDeps {
+    t: CrossChainMessagingTest;
+    aztecNode: AztecNode;
+    wallet: Wallet;
+    user1Address: AztecAddress;
+    log: Logger;
+    /** Marks the current pending tip proven on L1, subject to the caller's proving policy. */
+    markAsProven: () => Promise<void>;
+}
+/** Helpers for driving L1→L2 messages through the inbox, shared across the L1→L2 messaging suites. */
+export interface L1ToL2MessageHelpers {
+    sendMessageToL2(message: {
+        recipient: AztecAddress;
+        content: Fr;
+        secretHash: Fr;
+    }): ReturnType<typeof sendL1ToL2Message>;
+    advanceBlock(): Promise<BlockNumber>;
+    waitForMessageFetched(msgHash: Fr): Promise<CheckpointNumber>;
+    waitForMessageReady(msgHash: Fr, scope: L1ToL2MessageScope, onNotReady?: (blockNumber: BlockNumber) => Promise<void>): Promise<void>;
+}
+/**
+ * Builds the L1→L2 message helpers over a running {@link CrossChainMessagingTest}. The `markAsProven`
+ * dependency lets each suite plug in its own proving policy: suites that never pause proving pass an
+ * unconditional mark, while the inbox-drift suite gates it behind a flag it toggles mid-test.
+ */
+export declare function createL1ToL2MessageHelpers(deps: L1ToL2MessageHelperDeps): L1ToL2MessageHelpers;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWVzc2FnZV90ZXN0X2hlbHBlcnMuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9zaW5nbGUtbm9kZS9jcm9zcy1jaGFpbi9tZXNzYWdlX3Rlc3RfaGVscGVycy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssRUFBRSxZQUFZLEVBQUUsTUFBTSwyQkFBMkIsQ0FBQztBQUM5RCxPQUFPLEtBQUssRUFBRSxFQUFFLEVBQUUsTUFBTSx3QkFBd0IsQ0FBQztBQUNqRCxPQUFPLEtBQUssRUFBRSxNQUFNLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQztBQUVsRCxPQUFPLEtBQUssRUFBRSxTQUFTLEVBQUUsTUFBTSxzQkFBc0IsQ0FBQztBQUN0RCxPQUFPLEtBQUssRUFBRSxNQUFNLEVBQUUsTUFBTSx3QkFBd0IsQ0FBQztBQUNyRCxPQUFPLEtBQUssRUFBRSxXQUFXLEVBQUUsZ0JBQWdCLEVBQUUsTUFBTSxpQ0FBaUMsQ0FBQztBQUlyRixPQUFPLEVBQUUsaUJBQWlCLEVBQUUsTUFBTSxzQ0FBc0MsQ0FBQztBQUN6RSxPQUFPLEtBQUssRUFBRSx1QkFBdUIsRUFBRSxNQUFNLGlDQUFpQyxDQUFDO0FBRS9FLDZEQUEyRDtBQUMzRCxNQUFNLE1BQU0sa0JBQWtCLEdBQUcsU0FBUyxHQUFHLFFBQVEsQ0FBQztBQUV0RCwyREFBeUQ7QUFDekQsTUFBTSxXQUFXLHVCQUF1QjtJQUN0QyxDQUFDLEVBQUUsdUJBQXVCLENBQUM7SUFDM0IsU0FBUyxFQUFFLFNBQVMsQ0FBQztJQUNyQixNQUFNLEVBQUUsTUFBTSxDQUFDO0lBQ2YsWUFBWSxFQUFFLFlBQVksQ0FBQztJQUMzQixHQUFHLEVBQUUsTUFBTSxDQUFDO0lBQ1osMEZBQTBGO0lBQzFGLFlBQVksRUFBRSxNQUFNLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0FBQztDQUNuQztBQUVELDBHQUFzRztBQUN0RyxNQUFNLFdBQVcsb0JBQW9CO0lBQ25DLGVBQWUsQ0FBQyxPQUFPLEVBQUU7UUFDdkIsU0FBUyxFQUFFLFlBQVksQ0FBQztRQUN4QixPQUFPLEVBQUUsRUFBRSxDQUFDO1FBQ1osVUFBVSxFQUFFLEVBQUUsQ0FBQztLQUNoQixHQUFHLFVBQVUsQ0FBQyxPQUFPLGlCQUFpQixDQUFDLENBQUM7SUFDekMsWUFBWSxJQUFJLE9BQU8sQ0FBQyxXQUFXLENBQUMsQ0FBQztJQUNyQyxxQkFBcUIsQ0FBQyxPQUFPLEVBQUUsRUFBRSxHQUFHLE9BQU8sQ0FBQyxnQkFBZ0IsQ0FBQyxDQUFDO0lBQzlELG1CQUFtQixDQUNqQixPQUFPLEVBQUUsRUFBRSxFQUNYLEtBQUssRUFBRSxrQkFBa0IsRUFDekIsVUFBVSxDQUFDLEVBQUUsQ0FBQyxXQUFXLEVBQUUsV0FBVyxLQUFLLE9BQU8sQ0FBQyxJQUFJLENBQUMsR0FDdkQsT0FBTyxDQUFDLElBQUksQ0FBQyxDQUFDO0NBQ2xCO0FBRUQ7Ozs7R0FJRztBQUNILHdCQUFnQiwwQkFBMEIsQ0FBQyxJQUFJLEVBQUUsdUJBQXVCLEdBQUcsb0JBQW9CLENBNEU5RiJ9

package/dest/single-node/cross-chain/message_test_helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"message_test_helpers.d.ts","sourceRoot":"","sources":["../../../src/single-node/cross-chain/message_test_helpers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAC9D,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,wBAAwB,CAAC;AACjD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAElD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AACtD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,KAAK,EAAE,WAAW,EAAE,gBAAgB,EAAE,MAAM,iCAAiC,CAAC;AAIrF,OAAO,EAAE,iBAAiB,EAAE,MAAM,sCAAsC,CAAC;AACzE,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,iCAAiC,CAAC;AAE/E,6DAA2D;AAC3D,MAAM,MAAM,kBAAkB,GAAG,SAAS,GAAG,QAAQ,CAAC;AAEtD,2DAAyD;AACzD,MAAM,WAAW,uBAAuB;IACtC,CAAC,EAAE,uBAAuB,CAAC;IAC3B,SAAS,EAAE,SAAS,CAAC;IACrB,MAAM,EAAE,MAAM,CAAC;IACf,YAAY,EAAE,YAAY,CAAC;IAC3B,GAAG,EAAE,MAAM,CAAC;IACZ,0FAA0F;IAC1F,YAAY,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CACnC;AAED,0GAAsG;AACtG,MAAM,WAAW,oBAAoB;IACnC,eAAe,CAAC,OAAO,EAAE;QACvB,SAAS,EAAE,YAAY,CAAC;QACxB,OAAO,EAAE,EAAE,CAAC;QACZ,UAAU,EAAE,EAAE,CAAC;KAChB,GAAG,UAAU,CAAC,OAAO,iBAAiB,CAAC,CAAC;IACzC,YAAY,IAAI,OAAO,CAAC,WAAW,CAAC,CAAC;IACrC,qBAAqB,CAAC,OAAO,EAAE,EAAE,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAAC;IAC9D,mBAAmB,CACjB,OAAO,EAAE,EAAE,EACX,KAAK,EAAE,kBAAkB,EACzB,UAAU,CAAC,EAAE,CAAC,WAAW,EAAE,WAAW,KAAK,OAAO,CAAC,IAAI,CAAC,GACvD,OAAO,CAAC,IAAI,CAAC,CAAC;CAClB;AAED;;;;GAIG;AACH,wBAAgB,0BAA0B,CAAC,IAAI,EAAE,uBAAuB,GAAG,oBAAoB,CA4E9F"}