@aztec/end-to-end 0.0.1-commit.b2a5d0dd1 → 0.0.1-commit.b3d3157a

package/src/legacy-jest-resolver.cjs

@@ -8,63 +8,36 @@
 // would couple this test to a moving aztec.js surface and break at import time on unrelated breaking changes; we want
 // to fail only on actual artifact-compat regressions.
 //
-// The cache is populated on demand by running `npm install` into .legacy-contracts/<version>/.
+// Cache population lives in install_legacy_contracts.cjs — invoked lazily here for local dev, and eagerly
+// by bootstrap.sh ci-compat-e2e before hermetic test containers (which run with --net=none) launch.
+//
+// Missing artifacts: legacy version directories are immutable, so an artifact missing from the cache means the
+// contract was added after the pinned release — there's nothing to compat-test. Rather than failing or silently
+// falling back to the workspace artifact (which would turn the compat run into a regular e2e run that always
+// passes), we log the miss and exit the process cleanly with code 0. The test never runs, but the per-test CI
+// log captures the explanatory line so the reason is auditable. This keeps the change scoped to this resolver,
+// avoiding a new exit-code contract in the shared ci3 test runner.
 //
 // Activated by env var; passthrough otherwise.
 /* eslint-disable @typescript-eslint/no-require-imports */
 
 const path = require('path');
 const fs = require('fs');
-const { execSync } = require('child_process');
+const { installLegacyContracts, REDIRECTED, cacheRoot } = require('./install_legacy_contracts.cjs');
 
 const version = process.env.CONTRACT_ARTIFACTS_VERSION;
-const REDIRECTED = ['@aztec/noir-contracts.js', '@aztec/noir-test-contracts.js', '@aztec/accounts'];
-
-// Jest sets rootDir to <e2e>/src; this file lives there too.
-const e2eRoot = path.resolve(__dirname, '..');
-const cacheRoot = version ? path.join(e2eRoot, '.legacy-contracts', version) : null;
+const cacheDir = version ? cacheRoot(version) : null;
 
 function pkgJsonPath(name) {
-  return path.join(cacheRoot, 'node_modules', name, 'package.json');
-}
-
-function ensureCache() {
-  const missing = REDIRECTED.some(p => !fs.existsSync(pkgJsonPath(p)));
-  if (!missing) {
-    return;
-  }
-  fs.mkdirSync(cacheRoot, { recursive: true });
-  // Seed a standalone package.json so `npm install --prefix` treats cacheRoot as its own project. Without this, npm
-  // walks up and finds the yarn-project workspace root, which breaks on `workspace:` protocol deps and risks
-  // clobbering the monorepo's node_modules.
-  const seed = path.join(cacheRoot, 'package.json');
-  if (!fs.existsSync(seed)) {
-    fs.writeFileSync(seed, JSON.stringify({ name: 'legacy-contracts-cache', private: true }));
-  }
-
-  const specs = REDIRECTED.map(p => `${p}@${version}`).join(' ');
-  process.stderr.write(`[legacy-contracts] installing ${specs} into ${cacheRoot}\n`);
-  // --prefix: install into cacheRoot instead of cwd, so the cache is isolated from the monorepo.
-  // --no-save: don't write the installed packages back to the seeded package.json.
-  // --ignore-scripts: skip lifecycle scripts (preinstall/postinstall) of the legacy packages and their transitive
-  //   deps; we only want the files on disk, not to run any build steps.
-  // --legacy-peer-deps: tolerate peer-dependency mismatches between the pinned legacy @aztec/* graph and whatever
-  //   current versions npm would otherwise try to reconcile.
-  execSync(`npm install --prefix "${cacheRoot}" --no-save --ignore-scripts --legacy-peer-deps ${specs}`, {
-    stdio: 'inherit',
-  });
-
-  // Verify versions on disk match the requested version.
-  for (const p of REDIRECTED) {
-    const onDisk = JSON.parse(fs.readFileSync(pkgJsonPath(p), 'utf8')).version;
-    if (onDisk !== version) {
-      throw new Error(`[legacy-contracts] ${p} on disk is ${onDisk}, expected ${version}`);
-    }
-  }
+  return path.join(cacheDir, 'node_modules', name, 'package.json');
 }
 
+// Kept in a separate module (not inlined) because bootstrap.sh ci-compat-e2e also calls it directly
+// via `node .../install_legacy_contracts.cjs <version>` to pre-populate the cache on the host before
+// hermetic --net=none test containers launch. Inlining here would force us to duplicate the logic
+// in bash or re-run jest just to trigger the install.
 if (version) {
-  ensureCache();
+  installLegacyContracts(version);
 }
 
 let bannerPrinted = false;
@@ -102,7 +75,7 @@ function legacyArtifactPath(resolved) {
       continue;
     }
     const basename = resolved.slice(idx + marker.length);
-    return path.join(cacheRoot, 'node_modules', pkg, 'artifacts', basename);
+    return path.join(cacheDir, 'node_modules', pkg, 'artifacts', basename);
   }
   return null;
 }
@@ -122,10 +95,14 @@ module.exports = function legacyResolver(request, options) {
     return resolved;
   }
   if (!fs.existsSync(legacy)) {
-    throw new Error(
-      `[legacy-contracts] artifact ${path.basename(legacy)} not present in legacy cache @${version}; ` +
-        `the contract may have been added after that release. Pin a newer CONTRACT_ARTIFACTS_VERSION or skip this test.`,
+    // Contract was added after this historical release, there is nothing to compat-test for it. Exit the process
+    // cleanly with code 0 so the test runner reports the run as passed.
+    fs.writeSync(
+      2,
+      `[legacy-contracts][jest] artifact ${path.basename(legacy)} not in legacy cache @${version}; ` +
+        `assumed added after this release. No compat coverage applicable for this version, treating as passed.\n`,
     );
+    process.exit(0);
   }
   if (!seen.has(resolved)) {
     seen.add(resolved);

package/src/shared/cross_chain_test_harness.ts

@@ -13,11 +13,11 @@ import type { AztecNode } from '@aztec/aztec.js/node';
 import type { SiblingPath } from '@aztec/aztec.js/trees';
 import type { TxReceipt } from '@aztec/aztec.js/tx';
 import type { Wallet } from '@aztec/aztec.js/wallet';
+import { OutboxContract } from '@aztec/ethereum/contracts';
 import { deployL1Contract } from '@aztec/ethereum/deploy-l1-contract';
 import type { L1ContractAddresses } 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 { TestERC20Abi, TokenPortalAbi, TokenPortalBytecode } from '@aztec/l1-artifacts';
 import { TokenContract } from '@aztec/noir-contracts.js/Token';
 import { TokenBridgeContract } from '@aztec/noir-contracts.js/TokenBridge';
@@ -25,6 +25,7 @@ import { TokenBridgeContract } from '@aztec/noir-contracts.js/TokenBridge';
 import { type Hex, getContract } from 'viem';
 
 import { mintTokensToPrivate } from '../fixtures/token_utils.js';
+import { waitForL1ToL2MessageSeen } from './wait_for_l1_to_l2_message.js';
 
 /**
  * Deploy L1 token and portal, initialize portal, deploy a non native l2 token contract, its L2 bridge contract and attach is to the portal.
@@ -166,6 +167,7 @@ export class CrossChainTestHarness {
 
   private readonly l1TokenManager: L1TokenManager;
   private readonly l1TokenPortalManager: L1TokenPortalManager;
+  public readonly outboxContract: OutboxContract;
 
   constructor(
     /** Aztec node instance. */
@@ -206,6 +208,7 @@ export class CrossChainTestHarness {
       this.logger,
     );
     this.l1TokenManager = this.l1TokenPortalManager.getTokenManager();
+    this.outboxContract = new OutboxContract(this.l1Client, this.l1ContractAddresses.outboxAddress);
   }
 
   async mintTokensOnL1(amount: bigint) {
@@ -319,10 +322,18 @@ export class CrossChainTestHarness {
   withdrawFundsFromBridgeOnL1(
     amount: bigint,
     epochNumber: EpochNumber,
+    numCheckpointsInEpoch: number,
     messageIndex: bigint,
     siblingPath: SiblingPath<number>,
   ) {
-    return this.l1TokenPortalManager.withdrawFunds(amount, this.ethAccount, epochNumber, messageIndex, siblingPath);
+    return this.l1TokenPortalManager.withdrawFunds(
+      amount,
+      this.ethAccount,
+      epochNumber,
+      numCheckpointsInEpoch,
+      messageIndex,
+      siblingPath,
+    );
   }
 
   async transferToPrivateOnL2(shieldAmount: bigint) {
@@ -346,8 +357,7 @@ export class CrossChainTestHarness {
    */
   async makeMessageConsumable(msgHash: Fr | Hex) {
     const frMsgHash = typeof msgHash === 'string' ? Fr.fromHexString(msgHash) : msgHash;
-    // We poll isL1ToL2MessageSynced endpoint until the message is available
-    await retryUntil(async () => await this.aztecNode.isL1ToL2MessageSynced(frMsgHash), 'message sync', 10);
+    await waitForL1ToL2MessageSeen(this.aztecNode, frMsgHash, { timeoutSeconds: 10 });
 
     await this.mintTokensPublicOnL2(0n);
     await this.mintTokensPublicOnL2(0n);

package/src/shared/gas_portal_test_harness.ts

@@ -8,7 +8,12 @@ import type { ExtendedViemWalletClient } from '@aztec/ethereum/types';
 import { retryUntil } from '@aztec/foundation/retry';
 import { FeeJuiceContract } from '@aztec/noir-contracts.js/FeeJuice';
 import { ProtocolContractAddress } from '@aztec/protocol-contracts';
-import type { AztecNodeAdmin } from '@aztec/stdlib/interfaces/client';
+import type { AztecNodeAdmin, AztecNodeDebug } from '@aztec/stdlib/interfaces/client';
+
+import { waitForL1ToL2MessageSeen } from './wait_for_l1_to_l2_message.js';
+
+/** Aztec node that may expose the debug mining API in local e2e setups. */
+type MiningAztecNode = AztecNode & Partial<AztecNodeDebug>;
 
 export interface IGasBridgingTestHarness {
   getL1FeeJuiceBalance(address: EthAddress): Promise<bigint>;
@@ -19,7 +24,7 @@ export interface IGasBridgingTestHarness {
 }
 
 export interface FeeJuicePortalTestingHarnessFactoryConfig {
-  aztecNode: AztecNode;
+  aztecNode: MiningAztecNode;
   aztecNodeAdmin?: AztecNodeAdmin;
   l1Client: ExtendedViemWalletClient;
   wallet: Wallet;
@@ -75,7 +80,7 @@ export class GasBridgingTestHarness implements IGasBridgingTestHarness {
 
   constructor(
     /** Aztec node */
-    public aztecNode: AztecNode,
+    public aztecNode: MiningAztecNode,
     /** Aztec node admin interface */
     public aztecNodeAdmin: AztecNodeAdmin | undefined,
     /** Wallet. */
@@ -144,8 +149,7 @@ export class GasBridgingTestHarness implements IGasBridgingTestHarness {
     await this.mintTokensOnL1();
     const claim = await this.sendTokensToPortalPublic(bridgeAmount, owner);
 
-    const isSynced = async () => await this.aztecNode.isL1ToL2MessageSynced(Fr.fromHexString(claim.messageHash));
-    await retryUntil(isSynced, `message ${claim.messageHash} sync`, 24, 1);
+    await waitForL1ToL2MessageSeen(this.aztecNode, Fr.fromHexString(claim.messageHash), { timeoutSeconds: 24 });
 
     // Progress by 2 L2 blocks so that the l1ToL2Message added above will be available to use on L2.
     await this.advanceL2Block();
@@ -163,6 +167,11 @@ export class GasBridgingTestHarness implements IGasBridgingTestHarness {
   }
 
   private async advanceL2Block() {
+    if (this.aztecNode.mineBlock) {
+      await this.aztecNode.mineBlock();
+      return;
+    }
+
     const initialBlockNumber = await this.aztecNode.getBlockNumber();
 
     let minTxsPerBlock = undefined;
@@ -171,10 +180,12 @@ export class GasBridgingTestHarness implements IGasBridgingTestHarness {
       await this.aztecNodeAdmin.setConfig({ minTxsPerBlock: 0 }); // Set to 0 to ensure we can advance the block
     }
 
-    await retryUntil(async () => (await this.aztecNode.getBlockNumber()) >= initialBlockNumber + 1);
-
-    if (this.aztecNodeAdmin && minTxsPerBlock !== undefined) {
-      await this.aztecNodeAdmin.setConfig({ minTxsPerBlock });
+    try {
+      await retryUntil(async () => (await this.aztecNode.getBlockNumber()) >= initialBlockNumber + 1);
+    } finally {
+      if (this.aztecNodeAdmin && minTxsPerBlock !== undefined) {
+        await this.aztecNodeAdmin.setConfig({ minTxsPerBlock });
+      }
     }
   }
 }

package/src/shared/uniswap_l1_l2.ts

@@ -13,15 +13,19 @@ import type { ExtendedViemWalletClient } from '@aztec/ethereum/types';
 import { extractEvent } from '@aztec/ethereum/utils';
 import { EpochNumber } from '@aztec/foundation/branded-types';
 import { sha256ToField } from '@aztec/foundation/crypto/sha256';
+import { retryUntil } from '@aztec/foundation/retry';
 import { InboxAbi, UniswapPortalAbi, UniswapPortalBytecode } from '@aztec/l1-artifacts';
 import { UniswapContract } from '@aztec/noir-contracts.js/Uniswap';
 import { computeL2ToL1MessageHash } from '@aztec/stdlib/hash';
-import { computeL2ToL1MembershipWitness } from '@aztec/stdlib/messaging';
 
 import { jest } from '@jest/globals';
 import { type GetContractReturnType, getContract, parseEther, toFunctionSelector } from 'viem';
 
-import { type EndToEndContext, ensureAccountContractsPublished } from '../fixtures/utils.js';
+import {
+  type EndToEndContext,
+  ensureAccountContractsPublished,
+  ensureAuthRegistryPublished,
+} from '../fixtures/utils.js';
 import type { TestWallet } from '../test-wallet/test_wallet.js';
 import { CrossChainTestHarness } from './cross_chain_test_harness.js';
 
@@ -32,7 +36,7 @@ import { CrossChainTestHarness } from './cross_chain_test_harness.js';
 // anvil --fork-url https://mainnet.infura.io/v3/9928b52099854248b3a096be07a6b23c --fork-block-number 17514288 --chain-id 31337
 // For CI, this is configured in `run_tests.sh` and `docker-compose-images.yml`
 
-const TIMEOUT = 360_000;
+const TIMEOUT = 15 * 60 * 1000;
 
 export const uniswapL1L2TestSuite = (
   setup: () => Promise<EndToEndContext>,
@@ -98,6 +102,7 @@ export const uniswapL1L2TestSuite = (
       ownerEthAddress = EthAddress.fromString((await l1Client.getAddresses())[0]);
 
       await ensureAccountContractsPublished(wallet, [ownerAddress, sponsorAddress]);
+      await ensureAuthRegistryPublished(wallet, ownerAddress);
 
       logger.info('Deploying DAI Portal, initializing and deploying l2 contract...');
       daiCrossChainHarness = await CrossChainTestHarness.new(
@@ -250,14 +255,13 @@ export const uniswapL1L2TestSuite = (
       // ensure that uniswap contract didn't eat the funds.
       await wethCrossChainHarness.expectPublicBalanceOnL2(uniswapL2Contract.address, 0n);
 
-      // Since the outbox is only consumable when the epoch is proven, we need to advance to the next epoch.
-      const swapResult = (await computeL2ToL1MembershipWitness(
-        aztecNode,
-        swapPrivateLeaf,
-        l2UniswapInteractionReceipt.txHash,
-      ))!;
-      const { epochNumber: epoch } = swapResult;
-      await cheatCodes.rollup.advanceToEpoch(EpochNumber(epoch + 1));
+      // Since the outbox is only consumable when the epoch is proven, we need to advance to the next epoch
+      // before we can ask the witness helper for a covering root.
+      const minedReceipt = await aztecNode.getTxReceipt(l2UniswapInteractionReceipt.txHash);
+      if (minedReceipt.epochNumber === undefined) {
+        throw new Error('L2 Uniswap interaction tx is not yet in an epoch');
+      }
+      await cheatCodes.rollup.advanceToEpoch(EpochNumber(minedReceipt.epochNumber + 1));
       await waitForProven(aztecNode, l2UniswapInteractionReceipt, { provenTimeout: 300 });
 
       // 5. Consume L2 to L1 message by calling uniswapPortal.swap_private()
@@ -265,11 +269,19 @@ export const uniswapL1L2TestSuite = (
       const daiL1BalanceOfPortalBeforeSwap = await daiCrossChainHarness.getL1BalanceOf(
         daiCrossChainHarness.tokenPortalAddress,
       );
-      const withdrawResult = (await computeL2ToL1MembershipWitness(
-        aztecNode,
-        withdrawLeaf,
-        l2UniswapInteractionReceipt.txHash,
-      ))!;
+      const swapResult = await retryUntil(
+        () => aztecNode.getL2ToL1MembershipWitness(minedReceipt.txHash, swapPrivateLeaf),
+        'swap private l2 to l1 witness',
+        60,
+        1,
+      );
+      const { epochNumber: epoch, numCheckpointsInEpoch } = swapResult;
+      const withdrawResult = await retryUntil(
+        () => aztecNode.getL2ToL1MembershipWitness(minedReceipt.txHash, withdrawLeaf),
+        'withdraw l2 to l1 witness',
+        60,
+        1,
+      );
 
       const swapPrivateL2MessageIndex = swapResult.leafIndex;
       const swapPrivateSiblingPath = swapResult.siblingPath;
@@ -279,6 +291,7 @@ export const uniswapL1L2TestSuite = (
 
       const withdrawMessageMetadata = {
         _epoch: BigInt(epoch),
+        _numCheckpointsInEpoch: BigInt(withdrawResult.numCheckpointsInEpoch),
         _leafIndex: BigInt(withdrawL2MessageIndex),
         _path: withdrawSiblingPath
           .toBufferArray()
@@ -287,6 +300,7 @@ export const uniswapL1L2TestSuite = (
 
       const swapPrivateMessageMetadata = {
         _epoch: BigInt(epoch),
+        _numCheckpointsInEpoch: BigInt(numCheckpointsInEpoch),
         _leafIndex: BigInt(swapPrivateL2MessageIndex),
         _path: swapPrivateSiblingPath
           .toBufferArray()
@@ -843,9 +857,31 @@ export const uniswapL1L2TestSuite = (
         chainId: new Fr(l1Client.chain.id),
       });
 
-      const swapResult = (await computeL2ToL1MembershipWitness(aztecNode, swapPrivateLeaf, withdrawReceipt.txHash))!;
-      const { epochNumber: epoch } = swapResult;
-      const withdrawResult = (await computeL2ToL1MembershipWitness(aztecNode, withdrawLeaf, withdrawReceipt.txHash))!;
+      // ensure that user's funds were burnt
+      await wethCrossChainHarness.expectPrivateBalanceOnL2(ownerAddress, wethL2BalanceBeforeSwap - wethAmountToBridge);
+
+      // Since the outbox is only consumable when the epoch is proven, we need to advance to the next epoch
+      // before we can ask the witness helper for a covering root.
+      const minedReceipt = await aztecNode.getTxReceipt(withdrawReceipt.txHash);
+      if (minedReceipt.epochNumber === undefined) {
+        throw new Error('Withdraw tx is not yet in an epoch');
+      }
+      await cheatCodes.rollup.advanceToEpoch(EpochNumber(minedReceipt.epochNumber + 1));
+      await waitForProven(aztecNode, withdrawReceipt, { provenTimeout: 300 });
+
+      const swapResult = await retryUntil(
+        () => aztecNode.getL2ToL1MembershipWitness(minedReceipt.txHash, swapPrivateLeaf),
+        'swap private l2 to l1 witness',
+        60,
+        1,
+      );
+      const { epochNumber: epoch, numCheckpointsInEpoch } = swapResult;
+      const withdrawResult = await retryUntil(
+        () => aztecNode.getL2ToL1MembershipWitness(minedReceipt.txHash, withdrawLeaf),
+        'withdraw l2 to l1 witness',
+        60,
+        1,
+      );
 
       const swapPrivateL2MessageIndex = swapResult.leafIndex;
       const swapPrivateSiblingPath = swapResult.siblingPath;
@@ -855,6 +891,7 @@ export const uniswapL1L2TestSuite = (
 
       const withdrawMessageMetadata = {
         _epoch: BigInt(epoch),
+        _numCheckpointsInEpoch: BigInt(withdrawResult.numCheckpointsInEpoch),
         _leafIndex: BigInt(withdrawL2MessageIndex),
         _path: withdrawSiblingPath
           .toBufferArray()
@@ -863,19 +900,13 @@ export const uniswapL1L2TestSuite = (
 
       const swapPrivateMessageMetadata = {
         _epoch: BigInt(epoch),
+        _numCheckpointsInEpoch: BigInt(numCheckpointsInEpoch),
         _leafIndex: BigInt(swapPrivateL2MessageIndex),
         _path: swapPrivateSiblingPath
           .toBufferArray()
           .map((buf: Buffer) => `0x${buf.toString('hex')}`) as readonly `0x${string}`[],
       };
 
-      // ensure that user's funds were burnt
-      await wethCrossChainHarness.expectPrivateBalanceOnL2(ownerAddress, wethL2BalanceBeforeSwap - wethAmountToBridge);
-
-      // Since the outbox is only consumable when the epoch is proven, we need to advance to the next epoch.
-      await cheatCodes.rollup.advanceToEpoch(EpochNumber(epoch + 1));
-      await waitForProven(aztecNode, withdrawReceipt, { provenTimeout: 300 });
-
       // On L1 call swap_public!
       logger.info('call swap_public on L1');
       const swapArgs = [
@@ -975,9 +1006,31 @@ export const uniswapL1L2TestSuite = (
         chainId: new Fr(l1Client.chain.id),
       });
 
-      const swapResult = (await computeL2ToL1MembershipWitness(aztecNode, swapPublicLeaf, withdrawReceipt.txHash))!;
-      const { epochNumber: epoch } = swapResult;
-      const withdrawResult = (await computeL2ToL1MembershipWitness(aztecNode, withdrawLeaf, withdrawReceipt.txHash))!;
+      // check weth balance of owner on L2 (we first bridged `wethAmountToBridge` into L2 and now withdrew it!)
+      await wethCrossChainHarness.expectPublicBalanceOnL2(ownerAddress, 0n);
+
+      // Since the outbox is only consumable when the epoch is proven, we need to advance to the next epoch
+      // before we can ask the witness helper for a covering root.
+      const minedReceipt = await aztecNode.getTxReceipt(withdrawReceipt.txHash);
+      if (minedReceipt.epochNumber === undefined) {
+        throw new Error('Withdraw tx is not yet in an epoch');
+      }
+      await cheatCodes.rollup.advanceToEpoch(EpochNumber(minedReceipt.epochNumber + 1));
+      await waitForProven(aztecNode, withdrawReceipt, { provenTimeout: 300 });
+
+      const swapResult = await retryUntil(
+        () => aztecNode.getL2ToL1MembershipWitness(minedReceipt.txHash, swapPublicLeaf),
+        'swap public l2 to l1 witness',
+        60,
+        1,
+      );
+      const { epochNumber: epoch, numCheckpointsInEpoch } = swapResult;
+      const withdrawResult = await retryUntil(
+        () => aztecNode.getL2ToL1MembershipWitness(minedReceipt.txHash, withdrawLeaf),
+        'withdraw l2 to l1 witness',
+        60,
+        1,
+      );
 
       const swapPublicL2MessageIndex = swapResult.leafIndex;
       const swapPublicSiblingPath = swapResult.siblingPath;
@@ -987,6 +1040,7 @@ export const uniswapL1L2TestSuite = (
 
       const withdrawMessageMetadata = {
         _epoch: BigInt(epoch),
+        _numCheckpointsInEpoch: BigInt(withdrawResult.numCheckpointsInEpoch),
         _leafIndex: BigInt(withdrawL2MessageIndex),
         _path: withdrawSiblingPath
           .toBufferArray()
@@ -995,19 +1049,13 @@ export const uniswapL1L2TestSuite = (
 
       const swapPublicMessageMetadata = {
         _epoch: BigInt(epoch),
+        _numCheckpointsInEpoch: BigInt(numCheckpointsInEpoch),
         _leafIndex: BigInt(swapPublicL2MessageIndex),
         _path: swapPublicSiblingPath
           .toBufferArray()
           .map((buf: Buffer) => `0x${buf.toString('hex')}`) as readonly `0x${string}`[],
       };
 
-      // check weth balance of owner on L2 (we first bridged `wethAmountToBridge` into L2 and now withdrew it!)
-      await wethCrossChainHarness.expectPublicBalanceOnL2(ownerAddress, 0n);
-
-      // Since the outbox is only consumable when the epoch is proven, we need to advance to the next epoch.
-      await cheatCodes.rollup.advanceToEpoch(EpochNumber(epoch + 1));
-      await waitForProven(aztecNode, withdrawReceipt, { provenTimeout: 300 });
-
       // Call swap_private on L1
       logger.info('Execute withdraw and swap on the uniswapPortal!');
 

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,
+    1,
+  );
+}

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,15 +93,25 @@ export class LendingSimulator {
     public stableCoin: TokenSimulator,
   ) {}
 
-  async prepare() {
+  prepare() {
     this.accumulator = BASE;
-    const slot = await this.rollup.getSlotAt(
-      BigInt(await this.cc.eth.lastBlockTimestamp()) + 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;
     }
@@ -108,16 +119,19 @@ export class LendingSimulator {
     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) {

package/src/spartan/setup_test_wallets.ts

@@ -6,6 +6,7 @@ import { L1FeeJuicePortalManager } from '@aztec/aztec.js/ethereum';
 import { FeeJuicePaymentMethodWithClaim } from '@aztec/aztec.js/fee';
 import { type FeePaymentMethod, SponsoredFeePaymentMethod } from '@aztec/aztec.js/fee';
 import { Fr } from '@aztec/aztec.js/fields';
+import { waitForL1ToL2MessageReady } from '@aztec/aztec.js/messaging';
 import { type AztecNode, createAztecNodeClient, waitForTx } from '@aztec/aztec.js/node';
 import type { Wallet } from '@aztec/aztec.js/wallet';
 import { createEthereumChain } from '@aztec/ethereum/chain';
@@ -14,6 +15,7 @@ import type { Logger } from '@aztec/foundation/log';
 import { makeBackoff, retry, retryUntil } from '@aztec/foundation/retry';
 import { TokenContract } from '@aztec/noir-contracts.js/Token';
 import type { AztecNodeAdmin } from '@aztec/stdlib/interfaces/client';
+import { TxStatus } from '@aztec/stdlib/tx';
 import { registerInitialLocalNetworkAccountsInWallet } from '@aztec/wallets/testing';
 
 import { getACVMConfig } from '../fixtures/get_acvm_config.js';
@@ -332,9 +334,7 @@ async function bridgeL1FeeJuice(
   const portal = await L1FeeJuicePortalManager.new(aztecNode, l1Client, log);
   const claim = await portal.bridgeTokensPublic(recipient, amount, true /* mint */);
 
-  const isSynced = async () =>
-    (await aztecNode.getL1ToL2MessageCheckpoint(Fr.fromHexString(claim.messageHash))) !== undefined;
-  await retryUntil(isSynced, `message ${claim.messageHash} sync`, 24, 0.5);
+  await waitForL1ToL2MessageReady(aztecNode, Fr.fromHexString(claim.messageHash), { timeoutSeconds: 24 });
 
   log.info(`Created a claim for ${amount} L1 fee juice to ${recipient}.`, claim);
   return claim;
@@ -427,7 +427,9 @@ export async function performTransfers({
 
     const provenTxs = await Promise.all(txs);
 
-    await Promise.all(provenTxs.map(t => t.send({ wait: { timeout: 600 } })));
+    // Wait only for the txs to be proposed, not checkpointed. This is enough to keep the chain
+    // loaded for the reorg scenario, and avoids each round blocking on the (slower) checkpoint lag.
+    await Promise.all(provenTxs.map(t => t.send({ wait: { timeout: 600, waitForStatus: TxStatus.PROPOSED } })));
 
     logger.info(`Completed round ${i + 1} / ${rounds}`);
   }