@aztec/end-to-end 0.0.1-commit.a072138 → 0.0.1-commit.a4600f49

package/src/shared/wait_for_l1_to_l2_message.ts

@@ -0,0 +1,23 @@
+import type { Fr } from '@aztec/aztec.js/fields';
+import type { AztecNode } from '@aztec/aztec.js/node';
+import { retryUntil } from '@aztec/foundation/retry';
+
+/**
+ * Waits until the archiver has seen the L1 to L2 message and indexed it. Unlike
+ * {@link waitForL1ToL2MessageReady} from `@aztec/aztec.js/messaging`, this does not
+ * require the L2 chain to have advanced to the message's checkpoint — it only confirms
+ * 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: Pick<AztecNode, 'getL1ToL2MessageCheckpoint'>,
+  l1ToL2MessageHash: Fr,
+  opts: { timeoutSeconds: number },
+) {
+  return retryUntil(
+    async () => (await node.getL1ToL2MessageCheckpoint(l1ToL2MessageHash)) !== undefined,
+    `L1 to L2 message ${l1ToL2MessageHash.toString()} seen`,
+    opts.timeoutSeconds,
+    0.25,
+  );
+}

package/src/simulators/lending_simulator.ts

@@ -7,6 +7,7 @@ import { SlotNumber } from '@aztec/foundation/branded-types';
 import { poseidon2Hash } from '@aztec/foundation/crypto/poseidon';
 import type { TestDateProvider } from '@aztec/foundation/timer';
 import type { LendingContract } from '@aztec/noir-contracts.js/Lending';
+import type { AztecNode, AztecNodeDebug } from '@aztec/stdlib/interfaces/client';
 
 import type { TokenSimulator } from './token_simulator.js';
 
@@ -92,30 +93,45 @@ export class LendingSimulator {
     public stableCoin: TokenSimulator,
   ) {}
 
-  async prepare() {
+  prepare() {
     this.accumulator = BASE;
-    const slot = await this.rollup.getSlotAt(BigInt(await this.cc.eth.timestamp()) + BigInt(this.ethereumSlotDuration));
-    this.time = Number(await this.rollup.getTimestampForSlot(slot));
+    this.time = 0;
   }
 
-  async progressSlots(diff: number, dateProvider?: TestDateProvider) {
+  /**
+   * Advances the simulator's accumulator and clock to match a block timestamp observed on chain.
+   * Call this BEFORE applying any accumulator-sensitive mutation (borrow/repay) so the mutation
+   * sees the same accumulator as the contract did during execution.
+   */
+  observeBlockTimestamp(ts: number) {
+    const diff = ts - this.time;
+    if (diff > 0) {
+      this.accumulator = muldivDown(this.accumulator, computeMultiplier(this.rate, BigInt(diff)), BASE);
+    }
+    this.time = ts;
+  }
+
+  async progressSlots(diff: number, _dateProvider?: TestDateProvider, node?: AztecNode & AztecNodeDebug) {
     if (diff <= 1) {
       return;
     }
 
-    const slot = await this.rollup.getSlotAt(BigInt(await this.cc.eth.timestamp()));
+    const slot = await this.rollup.getSlotAt(BigInt(await this.cc.eth.lastBlockTimestamp()));
     const targetSlot = SlotNumber(slot + diff);
     const ts = Number(await this.rollup.getTimestampForSlot(targetSlot));
-    const timeDiff = ts - this.time;
-    this.time = ts;
 
-    // Mine ethereum blocks such that the next block will be in a new slot
-    await this.cc.eth.warp(this.time - this.ethereumSlotDuration);
-    if (dateProvider) {
-      dateProvider.setTime(this.time * 1000);
+    // Queue-aware warp under AutomineSequencer: atomic warp + mineBlock that advances L2 time to the
+    // target slot. The cheat code routes through the AutomineSequencer queue when one is installed,
+    // and otherwise falls back to a manual warp + mineBlock loop.
+    if (node) {
+      await this.cc.warpL2TimeAtLeastTo(node, ts);
+    } else {
+      await this.cc.eth.warp(ts - this.ethereumSlotDuration);
     }
+
+    // Mark the latest checkpoint as proven so the rollup does not reorg pending checkpoints when
+    // time jumps far enough forward to cross an unproven epoch boundary.
     await this.cc.rollup.markAsProven(await this.rollup.getCheckpointNumber());
-    this.accumulator = muldivDown(this.accumulator, computeMultiplier(this.rate, BigInt(timeDiff)), BASE);
   }
 
   depositPrivate(from: AztecAddress, onBehalfOf: Fr, amount: bigint) {
@@ -186,14 +202,16 @@ export class LendingSimulator {
 
     expect(this.borrowed).toEqual(this.stableCoin.totalSupply - this.mintedOutside);
 
-    const asset = await this.lendingContract.methods.get_asset(0).simulate({ from: this.account.address });
+    const { result: asset } = await this.lendingContract.methods.get_asset(0).simulate({ from: this.account.address });
 
     const interestAccumulator = asset['interest_accumulator'];
     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())]) {
-      const privatePos = await this.lendingContract.methods.get_position(key).simulate({ from: this.account.address });
+    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 });
       expect(new Fr(privatePos['collateral'])).toEqual(this.collateral[key.toString()] ?? Fr.ZERO);
       expect(new Fr(privatePos['static_debt'])).toEqual(this.staticDebt[key.toString()] ?? Fr.ZERO);
       expect(privatePos['debt']).toEqual(

package/src/simulators/token_simulator.ts

@@ -109,7 +109,9 @@ export class TokenSimulator {
       await Promise.all(
         chunk(calls, 5).map(batch => new BatchCall(this.defaultWallet, batch).simulate({ from: this.defaultAddress })),
       )
-    ).flat();
+    )
+      .flatMap(r => r.result)
+      .map(r => r.result);
     expect(results[0]).toEqual(this.totalSupply);
 
     // Check that all our balances match
@@ -119,39 +121,13 @@ export class TokenSimulator {
   }
 
   async checkPrivate() {
-    // Private calls
-    const defaultLookups = [];
-    const nonDefaultLookups = [];
-
     for (const address of this.accounts) {
-      if (this.lookupProvider.has(address.toString())) {
-        nonDefaultLookups.push(address);
-      } else {
-        defaultLookups.push(address);
-      }
-    }
-
-    const defaultCalls = defaultLookups.map(address => this.token.methods.balance_of_private(address));
-    const results = (
-      await Promise.all(
-        chunk(defaultCalls, 4).map(batch =>
-          new BatchCall(this.defaultWallet, batch).simulate({ from: this.defaultAddress }),
-        ),
-      )
-    ).flat();
-    for (let i = 0; i < defaultLookups.length; i++) {
-      expect(results[i]).toEqual(this.balanceOfPrivate(defaultLookups[i]));
-    }
-
-    // We are just running individual calls for the non-default lookups
-    // @todo We should also batch these
-    for (const address of nonDefaultLookups) {
       const wallet = this.lookupProvider.get(address.toString());
       const asset = wallet ? this.token.withWallet(wallet) : this.token;
 
-      const actualPrivateBalance = await asset.methods
-        .balance_of_private({ address })
-        .simulate({ from: this.defaultAddress });
+      const { result: actualPrivateBalance } = await asset.methods
+        .balance_of_private(address)
+        .simulate({ from: address });
       expect(actualPrivateBalance).toEqual(this.balanceOfPrivate(address));
     }
   }

package/src/single-node/README.md

@@ -0,0 +1,60 @@
+# `single-node` e2e test category
+
+Single-node tests run one Aztec node with the production sequencer (and, where a test needs proving,
+a prover node). They cover behavior that only requires a single sequencer and no multi-validator
+committee: block building, sequencer config and governance signalling, world-state sync, the
+proving/epoch lifecycle, partial proofs, L1-reorg handling, and pending-chain recovery.
+
+## Base class
+
+All tests use `SingleNodeTestContext` (`single_node_test_context.ts`), which owns:
+
+- The environment: an in-process anvil plus the L1 contract deploy.
+- Node spawning: `createNonValidatorNode` and `createProverNode` (the latter wires the mock-gossip
+  `p2pServiceFactory`, which is harmless with a single node).
+- The `ChainMonitor`.
+- The epoch / checkpoint / proof-window / reorg waiters and assertion helpers (`waitUntilEpochStarts`,
+  `waitUntilProvenCheckpointNumber`, `waitForNodeToSync`, `verifyHistoricBlock`, …).
+
+`MultiNodeTestContext` (in `../multi-node/`) extends this base with the N-validator topology, so the
+multi-node category inherits the same environment and waiters.
+
+## Setup factories
+
+`setup.ts` holds thin factories over `SingleNodeTestContext.setup`, named by the prover mode a test
+wants. Tests call the factory rather than the static method directly:
+
+- `setupWithProver(opts)` — a single sequencer plus the context's fake in-process prover node. This is
+  the default the proving / partial-proofs / l1-reorgs / recovery / misc suites use.
+- `setupBlockProducer(opts)` — a single production sequencer with **no prover node**, used by the
+  block-building / sequencer / sync suites. It raises `aztecProofSubmissionEpochs` to `1024` so unproven
+  blocks are not pruned without a prover, and points the PXE at `syncChainTip: 'proposed'` so tests can
+  assert on freshly proposed blocks. Both are overridable via `opts`.
+
+The `prover/` suite (real Barretenberg proofs) builds its environment through `FullProverTest`, which
+extends `SingleNodeTestContext` directly rather than going through a factory.
+
+## Organizing principle
+
+The top level groups tests by node topology and setup model; the second level names the primary
+behavior under test (the proving lifecycle, partial proofs, reorgs, recovery) rather than the shared
+setup. Each file has a single top-level `describe` named to match its path, and a co-located
+`setup.ts` holds any shared timeout/option wiring. A `.parallel` suffix marks files with more than one
+top-level `it`; CI splits each `it` into its own job.
+
+## Subfolders
+
+| Path | Contents |
+|---|---|
+| `block-building/` | Block assembly mechanics under the production sequencer with pipelining. `block_building` (multi-tx blocks, double-spend rejection, log ordering, regressions, and L1 reorgs), `debug_trace` (blocks proposed through a Forwarder proxy, including a failing-then-succeeding propose call), `multiple_blobs` (a block whose combined side effects span more than one EIP-4844 blob). |
+| `sequencer/` | Sequencer configuration, governance signalling, and publisher management on a single node. `gov_proposal.parallel` (a 16-validator committee proposes blocks while casting governance votes, and votes even when block building is disabled), `escape_hatch_vote_only` (governance signals advance while the escape hatch is closed), `reload_keystore` (the keystore is hot-reloaded to add a validator and pick up new coinbases), `slasher_config` (slasher config updated at runtime via the admin API), `multi_eoa` (publisher rotation when an L1 tx is withheld; exercises multi-EOA publisher failover), `publisher_funding_multi` (PublisherManager auto top-up of publisher EOAs when balances drop below threshold), `sequencer_config` (runtime `maxL2BlockGas`/`manaTarget` reconfiguration via a live Bot). |
+| `fees/` | Fee mechanics on a single node. `fee_asset_price_oracle` (on-chain fee-asset price-oracle convergence; starts its own Anvil instance with a MockStateView etched at the StateView address). The remaining files run on the `FeesTest` harness (`fees_test.ts`), which extends `SingleNodeTestContext` with the fee/gas domain setup (FPC funding, fee-juice bridging, banana token): `account_init` (fee payment during account-contract initialization), `failures.parallel` (fees still charged when txs revert in setup/app/teardown), `fee_juice_payments` (direct Fee Juice payment with and without initial funds), `fee_settings` (max-fee-per-gas handling, stale-fee-snapshot race, governance fee-config bump), `gas_estimation.parallel` (gas-estimation accuracy and FPC teardown gas prediction), `private_payments.parallel` (private fee payment via the BananaCoin FPC), `public_payments` (public fee payment via the BananaCoin FPC), `sponsored_payments` (sponsored fee payment via SponsoredFPC). |
+| `cross-chain/` | L1↔L2 messaging on a single node, on the `CrossChainMessagingTest` harness (`cross_chain_messaging_test.ts`), which extends `SingleNodeTestContext` and owns a `CrossChainTestHarness` plus the L1 inbox/outbox handles (it auto-proves via an `EpochTestSettler` when no prover node runs). `l1_to_l2.parallel` (L1→L2 message readiness, duplicate messages, and inbox drift after a rollup reorg), `l2_to_l1.parallel` (L2→L1 message inclusion across single/multi-message txs, subtree-root balancing, and a reorg-and-remine case), `token_bridge_private.parallel` (private L1→L2 deposit and L2→L1 withdrawal via the TokenBridge), `token_bridge_public.parallel` (public L1→L2 deposit and L2→L1 withdrawal, including mint-on-behalf), `token_bridge_failure_cases.parallel` (rejected withdrawals without approval and mismatched public/private claim attempts). |
+| `bot/` | Transaction bot implementations. `bot` (transfer bot, AMM bot, and cross-chain bot; exercises fee-juice portal deposits, L2→L1 messages, and bot contract reuse). |
+| `sync/` | World-state sync stress and reorg-replay harness. `synching` builds fixture block data (env-gated, slow) and replays it for sync benchmarks and prune/reorg scenarios; only the outer `it.each` runs in CI. |
+| `proving/` | Epoch and proof lifecycle. `world_state_pruning` (consecutive epochs prove and finalized blocks are purged from world state beyond the checkpoint-history window), `empty_blocks` (a proof is submitted even with no txs), `long_proving_time` (a prover delay spanning multiple epochs), `multi_proof` (multiple prover nodes prove one epoch), `optimistic.parallel` (checkpoint-driven proving across the happy path and several mid-epoch / last-slot / during-proving reorg cases), `proof_fails.parallel` (proof not accepted after epoch end; proving aborts when the next epoch ends), `cross_chain_public_message` (an epoch with a public tx that consumes an L1→L2 message in the block it lands, guarding against a sequencer/prover state-root mismatch), `upload_failed_proof` (a failed proving job's state is uploaded and re-run on a fresh instance). |
+| `prover/` | Real-proof exercises on the `FullProverTest` harness (real Barretenberg when `FAKE_PROOFS=0`, fake otherwise). `client` (client-side proof generation and `verifyProof` for private and public transfers, no on-chain submission) and `full` (the end-to-end pipeline: client proves, node builds blocks, prover node generates epoch proofs, L1 verifies them). |
+| `partial-proofs/` | Manually driven partial-proof submission. `single_root` (the prover node's `startProof` path on a single root) and `multi_root` (three partial-proof roots are staged and messages consume against any covering root, exercising the multi-root Outbox semantics). |
+| `l1-reorgs/` | Behavior under L1 reorgs, split by what reorgs. `blocks.parallel` (prune L2 blocks when a reorg drops a proof, hold when a replacement proof lands in the window, restore blocks when a proof reappears, prune pending-chain blocks, and see new blocks added by a reorg) and `messages.parallel` (L1→L2 messages updated by a reorg, and a missed message inserted by one). `setup.ts` holds the shared `FAST_REORG_TIMING` profile and delayer wiring. |
+| `recovery/` | Reorg and pending-chain recovery. `manual_rollback` (the `rollbackTo` admin API rolls back to an unfinalized block), `sync_after_reorg` (a fresh node syncs world state past an unpruned reorg window), `prune_when_cannot_build` (a solo sequencer prunes the pending chain via the fallback path when it cannot propose). |
+| `misc/` | Genuine single-node outliers. `missed_l1_slot` (the sequencer builds a block after missed L1 slots once the previous checkpoint is synced). |

package/src/single-node/cross-chain/cross_chain_messaging_test.ts

@@ -0,0 +1,302 @@
+import type { AztecNodeConfig } from '@aztec/aztec-node';
+import { AztecAddress, EthAddress } from '@aztec/aztec.js/addresses';
+import { waitForProven } from '@aztec/aztec.js/contracts';
+import { createLogger } from '@aztec/aztec.js/log';
+import type { AztecNode } from '@aztec/aztec.js/node';
+import type { TxReceipt } from '@aztec/aztec.js/tx';
+import { CheatCodes, EpochTestSettler } from '@aztec/aztec/testing';
+import { createExtendedL1Client } from '@aztec/ethereum/client';
+import { InboxContract, OutboxContract, RollupContract } from '@aztec/ethereum/contracts';
+import type {
+  DeployAztecL1ContractsArgs,
+  DeployAztecL1ContractsReturnType,
+} from '@aztec/ethereum/deploy-aztec-l1-contracts';
+import { deployL1Contract } from '@aztec/ethereum/deploy-l1-contract';
+import { pickL1ContractAddresses } from '@aztec/ethereum/l1-contract-addresses';
+import type { ExtendedViemWalletClient } from '@aztec/ethereum/types';
+import { EpochNumber } from '@aztec/foundation/branded-types';
+import { retryUntil } from '@aztec/foundation/retry';
+import { sleep } from '@aztec/foundation/sleep';
+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 type { PXEConfig } from '@aztec/pxe/server';
+import { getEpochAtSlot } from '@aztec/stdlib/epoch-helpers';
+import type { AztecNodeAdmin } from '@aztec/stdlib/interfaces/client';
+
+import { mnemonicToAccount } from 'viem/accounts';
+
+import { MNEMONIC } from '../../fixtures/fixtures.js';
+import { type SetupOptions, ensureAuthRegistryPublished, setup } 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 class CrossChainMessagingTest extends SingleNodeTestContext {
+  private requireEpochProven: boolean;
+  private setupOptions: SetupOptions;
+  private deployL1ContractsArgs: Partial<DeployAztecL1ContractsArgs>;
+  private pxeOpts: Partial<PXEConfig>;
+  private l1HarnessAccountIndex?: number;
+  private deployTokenBridge: boolean;
+  /** L1 token portal + ERC20 deployed before the node started (under automine) by the setup hook. */
+  private preDeployedCrossChainL1?: { underlyingERC20Address: EthAddress; tokenPortalAddress: EthAddress };
+  private testName: string;
+  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 = {},
+  ) {
+    super();
+    this.testName = testName;
+    this.logger = createLogger(`e2e:e2e_cross_chain_messaging:${testName}`);
+    this.setupOptions = opts;
+    this.deployL1ContractsArgs = {
+      initialValidators: [],
+      ...deployL1ContractsArgs,
+    };
+    this.pxeOpts = pxeOpts;
+    this.l1HarnessAccountIndex = crossChainOpts.l1HarnessAccountIndex;
+    this.deployTokenBridge = crossChainOpts.deployTokenBridge ?? true;
+    this.requireEpochProven = opts.startProverNode ?? false;
+  }
+
+  override async setup(opts: SingleNodeTestOpts = {}, pxeOpts: Partial<PXEConfig> = {}) {
+    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;
+    const context = await setup(
+      3,
+      {
+        ...this.setupOptions,
+        ...opts,
+        fundSponsoredFPC: true,
+        l1ContractsArgs: { ...this.deployL1ContractsArgs, ...opts.l1ContractsArgs },
+        // `advanceToEpochProven` warps anvil's L1 clock forward by up to a full epoch in one
+        // step. The prover-node tracks L1 time via `dateProvider.setTime(...)`, so any
+        // in-flight tx-gather sees its deadline jump into the past and short-circuits. Use
+        // a generous gather window so the deadline survives the warp.
+        proverNodeConfig: {
+          ...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: TxReceipt): Promise<EpochNumber> {
+    const block = await this.aztecNode.getBlock(l2TxReceipt.blockNumber!);
+    const cp = await retryUntil(
+      async () => (await this.aztecNode.getCheckpoints(block!.checkpointNumber, 1))[0],
+      `archiver indexes checkpoint ${block!.checkpointNumber}`,
+      120,
+      0.5,
+    );
+    const epochDuration = await this.rollup.getEpochDuration();
+    const epoch = getEpochAtSlot(cp.header.slotNumber, { epochDuration });
+    // Warp to the next epoch.
+    await this.cheatCodes.rollup.advanceToEpoch(EpochNumber(epoch + 1));
+    // Wait for the tx to be proven.
+    await waitForProven(this.aztecNode, l2TxReceipt, { provenTimeout: 300 });
+    // Return the epoch the tx is in.
+    return epoch;
+  }
+
+  async catchUpProvenChain() {
+    const bn = await this.aztecNode.getBlockNumber();
+    while ((await this.aztecNode.getBlockNumber('proven')) < bn) {
+      await sleep(1000);
+    }
+  }
+
+  override async teardown() {
+    await this.epochTestSettler?.stop();
+    await super.teardown();
+  }
+
+  async applyBaseSetup() {
+    // Set up base context fields
+    this.aztecNode = this.context.aztecNodeService;
+    this.wallet = this.context.wallet;
+    this.aztecNodeConfig = this.context.config;
+    this.cheatCodes = this.context.cheatCodes;
+    this.deployL1ContractsValues = this.context.deployL1ContractsValues;
+    this.aztecNodeAdmin = this.context.aztecNodeService;
+
+    if (!this.requireEpochProven) {
+      // When no real prover is running, the L1 proof window (aztecProofSubmissionEpochs) would
+      // otherwise expire mid-test and trigger a chain prune. The e2e fixture runs L1 on interval
+      // mining and nothing marks blocks proven automatically, so start an EpochTestSettler to mark
+      // each completed epoch as proven on L1.
+      this.epochTestSettler = new EpochTestSettler(
+        this.context.ethCheatCodes,
+        this.context.deployL1ContractsValues.l1ContractAddresses.rollupAddress,
+        this.context.aztecNodeService.getBlockSource(),
+        this.logger.createChild('epoch-settler'),
+        { pollingIntervalMs: 500 },
+      );
+      await this.epochTestSettler.start();
+    }
+
+    [this.ownerAddress, this.user1Address, this.user2Address] = this.context.accounts;
+
+    // Set up cross chain messaging
+    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,
+    );
+    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,
+      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);
+    this.l2Bridge = TokenBridgeContract.at(crossChainContext.l2Bridge, this.wallet);
+
+    // 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());
+
+    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/src/single-node/cross-chain/message_test_helpers.ts

@@ -0,0 +1,125 @@
+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 { isL1ToL2MessageReady } from '@aztec/aztec.js/messaging';
+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 { retryUntil } from '@aztec/foundation/retry';
+import { ExecutionPayload } from '@aztec/stdlib/tx';
+
+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 function createL1ToL2MessageHelpers(deps: L1ToL2MessageHelperDeps): L1ToL2MessageHelpers {
+  const { t, aztecNode, wallet, user1Address, log, markAsProven } = deps;
+
+  // Sends an L1→L2 message from the harness L1 account. This suite skips the token bridge, so the
+  // message context is built from the test's L1 handles rather than a CrossChainTestHarness.
+  const sendMessageToL2 = (message: { recipient: AztecAddress; content: Fr; secretHash: Fr }) =>
+    sendL1ToL2Message(message, {
+      l1Client: t.harnessL1Client,
+      l1ContractAddresses: t.deployL1ContractsValues.l1ContractAddresses,
+    });
+
+  // Sends a tx to L2 to advance the block number by 1
+  const advanceBlock = async () => {
+    const block = await aztecNode.getBlockNumber();
+    log.warn(`Sending noop tx at block ${block}`);
+    await wallet.sendTx(ExecutionPayload.empty(), { from: user1Address });
+    const newBlock = await aztecNode.getBlockNumber();
+    log.warn(`Advanced to block ${newBlock}`);
+    if (newBlock === block) {
+      throw new Error(`Failed to advance block ${block}`);
+    }
+    // Keep the proof window from expiring mid-test. No-op once a drift scenario disables proving.
+    await markAsProven();
+    return newBlock;
+  };
+
+  // Waits until the message is fetched by the archiver of the node and returns the msg target checkpoint.
+  // Advances a block on each retry because an L1->L2 message is only indexed once further L2 blocks build.
+  const waitForMessageFetched = async (msgHash: Fr) => {
+    log.warn(`Waiting until the message is fetched by the node`);
+    return await retryUntil(
+      async () => {
+        const checkpoint = await aztecNode.getL1ToL2MessageCheckpoint(msgHash);
+        if (checkpoint !== undefined) {
+          return checkpoint;
+        }
+        await advanceBlock();
+        return undefined;
+      },
+      'get msg checkpoint',
+      60,
+    );
+  };
+
+  // Waits until the message is ready to be consumed on L2 as it's been added to the world state
+  const waitForMessageReady = async (
+    msgHash: Fr,
+    scope: L1ToL2MessageScope,
+    onNotReady?: (blockNumber: BlockNumber) => Promise<void>,
+  ) => {
+    const msgCheckpoint = await waitForMessageFetched(msgHash);
+    log.warn(
+      `Waiting until L2 reaches the first block of msg checkpoint ${msgCheckpoint} (current is ${await aztecNode.getCheckpointNumber()})`,
+    );
+    await retryUntil(
+      async () => {
+        const [blockNumber, checkpointNumber] = await Promise.all([
+          aztecNode.getBlockNumber(),
+          aztecNode.getCheckpointNumber(),
+        ]);
+        const witness = await aztecNode.getL1ToL2MessageMembershipWitness('latest', msgHash);
+        const isReady = await isL1ToL2MessageReady(aztecNode, msgHash);
+        log.info(
+          `Block is ${blockNumber}, checkpoint is ${checkpointNumber}. Message checkpoint is ${msgCheckpoint}. Witness ${!!witness}. Ready ${isReady}.`,
+        );
+        if (!isReady) {
+          await (onNotReady ? onNotReady(blockNumber) : advanceBlock());
+        }
+        return isReady;
+      },
+      `wait for rollup to reach msg checkpoint ${msgCheckpoint}`,
+      240,
+    );
+  };
+
+  return { sendMessageToL2, advanceBlock, waitForMessageFetched, waitForMessageReady };
+}