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

package/dest/shared/timing_env.js

@@ -0,0 +1,365 @@
+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 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);
+        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
+        };
+        // 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,
+            spans: []
+        };
+        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;
+        // 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.
+    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.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(' ');
+    }
+    /** 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 = [];
+    }
+    /** Folds spans into records, finalizes the suite-scoped record, and writes all JSONL. */ finalizeAndFlush() {
+        if (this.flushed || !this.timingFile) {
+            return;
+        }
+        this.flushed = true;
+        this.foldSpans();
+        const lines = [];
+        for (const record of this.records){
+            lines.push(this.toLine({
+                ...record
+            }));
+        }
+        lines.push(this.toLine({
+            type: 'suite',
+            name: null,
+            status: 'passed',
+            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.
+            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, rounding all Ms fields. */ 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]);
+            }
+        }
+        // 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/simulators/lending_simulator.js

@@ -172,7 +172,7 @@ const computeMultiplier = (rate, dt)=>{
         expect(asset['last_updated_ts']).toEqual(BigInt(this.time));
         for (const key of [
             this.account.address,
-            AztecAddress.fromField(await this.account.key())
+            AztecAddress.fromFieldUnsafe(await this.account.key())
         ]){
             const { result: privatePos } = await this.lendingContract.methods.get_position(key).simulate({
                 from: this.account.address

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,33 +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;
-    logger;
-    context;
+    l1HarnessAccountIndex;
+    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;
@@ -48,7 +57,9 @@ export class CrossChainMessagingTest {
    * `await t.epochTestSettler?.stop()`.
    */ epochTestSettler;
     deployL1ContractsValues;
-    constructor(testName, opts = {}, deployL1ContractsArgs = {}, pxeOpts = {}){
+    constructor(testName, opts = {}, deployL1ContractsArgs = {}, pxeOpts = {}, crossChainOpts = {}){
+        super();
+        this.testName = testName;
         this.logger = createLogger(`e2e:e2e_cross_chain_messaging:${testName}`);
         this.setupOptions = opts;
         this.deployL1ContractsArgs = {
@@ -56,13 +67,15 @@ export class CrossChainMessagingTest {
             ...deployL1ContractsArgs
         };
         this.pxeOpts = pxeOpts;
+        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,
@@ -78,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) {
@@ -109,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
@@ -133,14 +174,29 @@ export class CrossChainMessagingTest {
         // Set up cross chain messaging
         this.logger.info('Applying e2e_cross_chain_messaging setup');
         await ensureAuthRegistryPublished(this.wallet, this.ownerAddress);
-        this.l1Client = createExtendedL1Client(this.aztecNodeConfig.l1RpcUrls, MNEMONIC);
-        const underlyingERC20Address = await deployL1Contract(this.l1Client, TestERC20Abi, TestERC20Bytecode, [
-            'Underlying',
-            'UND',
-            this.l1Client.account.address
-        ]).then(({ address })=>address);
+        const harnessL1Client = createExtendedL1Client(this.aztecNodeConfig.l1RpcUrls, MNEMONIC, undefined, undefined, this.l1HarnessAccountIndex);
+        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, this.l1Client, 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);
@@ -148,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, l1Client, pickL1ContractAddresses(this.aztecNodeConfig), this.wallet, this.ownerAddress);
+        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);
     }
 }