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

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 };
+}

package/src/{e2e_fees → single-node/fees}/bridging_race.notest.ts

@@ -8,7 +8,7 @@ import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 import { jest } from '@jest/globals';
 import type { Hex } from 'viem';
 
-import type { TestWallet } from '../test-wallet/test_wallet.js';
+import type { TestWallet } from '../../test-wallet/test_wallet.js';
 import { FeesTest } from './fees_test.js';
 
 jest.setTimeout(300_000);
@@ -19,7 +19,7 @@ jest.setTimeout(300_000);
 // site in the codebase; keeping the file as reference for the original race scenario. Uses FeesTest
 // with prod sequencer (ethSlot=4s, aztecSlot=8s, inboxLag default, minTxsPerBlock=0) and
 // GasBridgingTestHarness for L1↔L2 fee-juice bridging. Single account, fake in-proc prover node.
-describe('e2e_fees bridging_race', () => {
+describe('single-node/fees/bridging_race', () => {
   const ETHEREUM_SLOT_DURATION = 4;
   const AZTEC_SLOT_DURATION = ETHEREUM_SLOT_DURATION * 2;
 
@@ -54,6 +54,14 @@ describe('e2e_fees bridging_race', () => {
     bobsAddress = bobsAccountManager.address;
   });
 
+  // Sleeps until 500ms before the current L2 slot ends, so the subsequent bridge lands right at the slot
+  // boundary (this is what reproduces the "message not in state" race the test guards against).
+  const sleepUntilNearSlotEnd = async () => {
+    const sleepTime = (Number(t.monitor.checkpointTimestamp) + AZTEC_SLOT_DURATION) * 1000 - Date.now() - 500;
+    logger.info(`Sleeping for ${sleepTime}ms until near end of L2 slot before sending L1 fee juice to L2 inbox`);
+    await sleep(sleepTime);
+  };
+
   // Reproduces a timing race where an L1→L2 fee-juice bridge message lands just before the end of an
   // L2 slot, causing the archiver to miss it. The fix was to wait for the archiver to see the message
   // before waiting for the required two-block confirmation. The sleep injected into approve() simulates
@@ -65,11 +73,7 @@ describe('e2e_fees bridging_race', () => {
     const origApprove = l1TokenManager.approve.bind(l1TokenManager);
     l1TokenManager.approve = async (amount: bigint, address: Hex, addressName = '') => {
       await origApprove(amount, address, addressName);
-      const sleepTime = (Number(t.chainMonitor.checkpointTimestamp) + AZTEC_SLOT_DURATION) * 1000 - Date.now() - 500;
-      logger.info(`Sleeping for ${sleepTime}ms until near end of L2 slot before sending L1 fee juice to L2 inbox`);
-      // REFACTOR: hand-rolled slot-boundary sleep; replace with a timing helper that derives the remaining
-      // slot time from the chain monitor's slot boundaries rather than computing it inline.
-      await sleep(sleepTime);
+      await sleepUntilNearSlotEnd();
     };
 
     // Waiting for the archiver to sync the message _before_ waiting for the mandatory 2 L2 blocks to pass fixed it

package/src/{e2e_fees → single-node/fees}/fees_test.ts

@@ -1,11 +1,12 @@
 import type { AztecAddress } from '@aztec/aztec.js/addresses';
-import { type Logger, createLogger } from '@aztec/aztec.js/log';
+import { BatchCall } from '@aztec/aztec.js/contracts';
+import { Fr } from '@aztec/aztec.js/fields';
+import { createLogger } from '@aztec/aztec.js/log';
 import type { AztecNode } from '@aztec/aztec.js/node';
 import { CheatCodes, getTokenAllowedSetupFunctions } from '@aztec/aztec/testing';
 import { createExtendedL1Client } from '@aztec/ethereum/client';
-import { RollupContract } from '@aztec/ethereum/contracts';
+import type { RollupContract } from '@aztec/ethereum/contracts';
 import type { DeployAztecL1ContractsArgs } from '@aztec/ethereum/deploy-aztec-l1-contracts';
-import { ChainMonitor } from '@aztec/ethereum/test';
 import { BlockNumber } from '@aztec/foundation/branded-types';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { sleep } from '@aztec/foundation/sleep';
@@ -18,39 +19,70 @@ import { TokenContract as BananaCoin } from '@aztec/noir-contracts.js/Token';
 import { CounterContract } from '@aztec/noir-test-contracts.js/Counter';
 import { ProtocolContractAddress } from '@aztec/protocol-contracts';
 import { getCanonicalFeeJuice } from '@aztec/protocol-contracts/fee-juice';
+import { getContractInstanceFromInstantiationParams } from '@aztec/stdlib/contract';
 import { Gas, GasSettings } from '@aztec/stdlib/gas';
 import type { AztecNodeAdmin } from '@aztec/stdlib/interfaces/client';
 
 import { getContract } from 'viem';
 
-import { L1_DIRECT_WRITE_ACCOUNT_INDEX, MNEMONIC, getPaddedMaxFeesPerGas } from '../fixtures/fixtures.js';
+import { L1_DIRECT_WRITE_ACCOUNT_INDEX, MNEMONIC, getPaddedMaxFeesPerGas } from '../../fixtures/fixtures.js';
+import { type SetupOptions, ensureAuthRegistryPublished, setup } from '../../fixtures/setup.js';
+import { testSpan } from '../../fixtures/timing.js';
+import { mintTokensToPrivate } from '../../fixtures/token_utils.js';
+import { type BalancesFn, getBalancesFn, setupSponsoredFPC } from '../../fixtures/utils.js';
 import {
-  type EndToEndContext,
-  type SetupOptions,
-  ensureAuthRegistryPublished,
-  setup,
-  teardown,
-} from '../fixtures/setup.js';
-import { mintTokensToPrivate } from '../fixtures/token_utils.js';
-import { type BalancesFn, getBalancesFn, setupSponsoredFPC } from '../fixtures/utils.js';
-import { FeeJuicePortalTestingHarnessFactory, type GasBridgingTestHarness } from '../shared/gas_portal_test_harness.js';
-import { TestWallet } from '../test-wallet/test_wallet.js';
+  FeeJuicePortalTestingHarnessFactory,
+  type GasBridgingTestHarness,
+} from '../../shared/gas_portal_test_harness.js';
+import { TestWallet } from '../../test-wallet/test_wallet.js';
+import { SingleNodeTestContext, type SingleNodeTestOpts } from '../single_node_test_context.js';
+
+// Fixed deploy salts so BananaCoin and its BananaFPC land at deterministic addresses given the FPC
+// admin. This lets the BananaFPC's fee-juice balance be seeded at genesis (see `FeesTest.setup`)
+// instead of bridged from L1 during setup — the address must be known before genesis is computed.
+const BANANA_COIN_SALT = new Fr(0xba4a4a);
+const BANANA_FPC_SALT = new Fr(0xfacade);
+
+const BANANA_COIN_CONSTRUCTOR_ARGS = ['BC', 'BC', 18n] as const;
+
+/**
+ * Computes the deterministic BananaCoin and BananaFPC instances for the given admin/deployer, matching
+ * what {@link FeesTest.applyDeployBananaToken} and {@link FeesTest.applyFPCSetup} deploy with the fixed
+ * salts above. Used both to seed the BananaFPC's fee juice at genesis and to assert the deployed
+ * addresses match the seeded one.
+ */
+async function computeBananaContractAddresses(admin: AztecAddress) {
+  const bananaCoin = await getContractInstanceFromInstantiationParams(BananaCoin.artifact, {
+    salt: BANANA_COIN_SALT,
+    constructorArgs: [admin, ...BANANA_COIN_CONSTRUCTOR_ARGS],
+    deployer: admin,
+  });
+  const bananaFPC = await getContractInstanceFromInstantiationParams(FPCContract.artifact, {
+    salt: BANANA_FPC_SALT,
+    constructorArgs: [bananaCoin.address, admin],
+    deployer: admin,
+  });
+  return { bananaCoinAddress: bananaCoin.address, bananaFPCAddress: bananaFPC.address };
+}
 
 /**
  * Test fixture for testing fees. Provides the following setup steps:
  * InitialAccounts: Initializes 3 Schnorr account contracts.
  * PublicDeployAccounts: Deploys the accounts publicly.
  * DeployFeeJuice: Deploys the Fee Juice contract.
- * FPCSetup: Deploys BananaCoin and FPC contracts, and bridges gas from L1.
- * SponsoredFPCSetup: Deploys Sponsored FPC contract, and bridges gas from L1.
+ * FPCSetup: Deploys BananaCoin and FPC contracts; the FPC's fee juice is seeded at genesis.
+ * SponsoredFPCSetup: Registers the Sponsored FPC contract, whose fee juice is seeded at genesis.
  * FundAlice: Mints private and public bananas to Alice.
  * SetupSubscription: Deploys a counter contract and a subscription contract, and mints Fee Juice to the subscription contract.
+ *
+ * The fee-domain 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 fee opts below (prover node, sponsored-FPC funding, token allowlist) rather than the
+ * base's default node config, and layers the fee-domain setup (FPC, fee juice, banana token) on top.
  */
-export class FeesTest {
+export class FeesTest extends SingleNodeTestContext {
   private accounts: AztecAddress[] = [];
-  public context!: EndToEndContext;
 
-  public logger: Logger;
   public aztecNode!: AztecNode;
   public aztecNodeAdmin!: AztecNodeAdmin;
   public cheatCodes!: CheatCodes;
@@ -65,6 +97,7 @@ export class FeesTest {
 
   public gasSettings!: GasSettings;
 
+  /** The base's {@link SingleNodeTestContext.rollup}, exposed under the fee suite's historical name. */
   public rollupContract!: RollupContract;
 
   public feeJuiceContract!: FeeJuiceContract;
@@ -75,8 +108,6 @@ export class FeesTest {
   public subscriptionContract!: AppSubscriptionContract;
   public feeJuiceBridgeTestHarness!: GasBridgingTestHarness;
 
-  public chainMonitor!: ChainMonitor;
-
   public getCoinbaseBalance!: () => Promise<bigint>;
   public getCoinbaseSequencerRewards!: () => Promise<bigint>;
   public getGasBalanceFn!: BalancesFn;
@@ -90,50 +121,69 @@ export class FeesTest {
   public readonly SUBSCRIPTION_AMOUNT = BigInt(1e19);
   public readonly APP_SPONSORED_TX_GAS_LIMIT = BigInt(10e9);
 
+  private testName: string;
+
   constructor(
     testName: string,
     private numberOfAccounts = 3,
     private setupOptions: Partial<SetupOptions & DeployAztecL1ContractsArgs> = {},
   ) {
+    super();
     if (!numberOfAccounts) {
       throw new Error('There must be at least 1 initial account.');
     }
     setupOptions.coinbase ??= EthAddress.random();
     this.coinbase = setupOptions.coinbase!;
+    this.testName = testName;
     this.logger = createLogger(`e2e:e2e_fees:${testName}`);
   }
 
-  async setup(opts: Partial<SetupOptions> = {}) {
+  override async setup(opts: SingleNodeTestOpts = {}) {
     this.logger.verbose('Setting up fresh context...');
     // Token allowlist entries are test-only: FPC-based fee payment with custom tokens won't work on mainnet alpha.
     const tokenAllowList = await getTokenAllowedSetupFunctions();
-    this.context = await setup(this.numberOfAccounts, {
+    const context = await setup(this.numberOfAccounts, {
       startProverNode: true,
       ...this.setupOptions,
       ...opts,
       fundSponsoredFPC: true,
+      // Seed the BananaFPC's fee juice at genesis instead of bridging it from L1 in applyFPCSetup. The
+      // FPC admin is the first account, so its address is deterministic once the accounts are generated.
+      computeExtraGenesisFundedAddresses: async defaultAccounts => [
+        (await computeBananaContractAddresses(defaultAccounts[0].address)).bananaFPCAddress,
+      ],
       l1ContractsArgs: { ...this.setupOptions },
       txPublicSetupAllowListExtend: [...(this.setupOptions.txPublicSetupAllowListExtend ?? []), ...tokenAllowList],
     });
 
-    this.rollupContract = RollupContract.getFromConfig(this.context.config);
-    this.chainMonitor = new ChainMonitor(this.rollupContract, this.context.dateProvider, this.logger, 200).start();
+    // Reuse the base context machinery (rollup, epoch cache, chain monitor, node tracking, teardown)
+    // over the environment built above. Restore the FeesTest-named logger afterwards, since
+    // hydrateFromContext repoints `this.logger` at the context logger.
+    await this.hydrateFromContext(context);
+    this.logger = createLogger(`e2e:e2e_fees:${this.testName}`);
+    this.rollupContract = this.rollup;
 
     await this.applyBaseSetup();
+  }
 
-    return this;
+  async catchUpProvenChain() {
+    await testSpan('wait:proven-checkpoint', async () => {
+      const bn = await this.aztecNode.getBlockNumber();
+      while ((await this.aztecNode.getBlockNumber('proven')) < bn) {
+        await sleep(1000);
+      }
+    });
   }
 
-  async teardown() {
-    await this.chainMonitor.stop();
-    await teardown(this.context);
+  /** Warps L1 to the next epoch boundary so the current epoch closes and can be proven. */
+  async advanceToNextEpoch() {
+    await testSpan('warp:proven-checkpoint-epoch', () => this.cheatCodes.rollup.advanceToNextEpoch());
   }
 
-  async catchUpProvenChain() {
-    const bn = await this.aztecNode.getBlockNumber();
-    while ((await this.aztecNode.getBlockNumber('proven')) < bn) {
-      await sleep(1000);
-    }
+  /** Advances to the next epoch and waits for the proven chain to catch up, so all prior fees are paid out. */
+  async waitForEpochProven() {
+    await this.advanceToNextEpoch();
+    await this.catchUpProvenChain();
   }
 
   async getBlockRewards() {
@@ -152,7 +202,9 @@ export class FeesTest {
   async mintAndBridgeFeeJuice(minter: AztecAddress, recipient: AztecAddress) {
     const claim = await this.feeJuiceBridgeTestHarness.prepareTokensOnL1(recipient);
     const { claimSecret: secret, messageLeafIndex: index } = claim;
-    await this.feeJuiceContract.methods.claim(recipient, claim.claimAmount, secret, index).send({ from: minter });
+    await testSpan('setup:bridge', () =>
+      this.feeJuiceContract.methods.claim(recipient, claim.claimAmount, secret, index).send({ from: minter }),
+    );
   }
 
   /** Alice mints bananaCoin tokens privately to the target address and redeems them. */
@@ -161,7 +213,7 @@ export class FeesTest {
       .balance_of_private(address)
       .simulate({ from: address });
 
-    await mintTokensToPrivate(this.bananaCoin, this.aliceAddress, address, amount);
+    await testSpan('tx:mint', () => mintTokensToPrivate(this.bananaCoin, this.aliceAddress, address, amount));
 
     const { result: balanceAfter } = await this.bananaCoin.methods
       .balance_of_private(address)
@@ -230,9 +282,14 @@ export class FeesTest {
   async applyDeployBananaToken() {
     this.logger.info('Applying deploy banana token setup');
 
-    const { contract: bananaCoin } = await BananaCoin.deploy(this.wallet, this.aliceAddress, 'BC', 'BC', 18n).send({
-      from: this.aliceAddress,
-    });
+    const { contract: bananaCoin } = await testSpan('deploy:token', () =>
+      BananaCoin.deploy(this.wallet, this.aliceAddress, ...BANANA_COIN_CONSTRUCTOR_ARGS, {
+        salt: BANANA_COIN_SALT,
+        deployer: this.aliceAddress,
+      }).send({
+        from: this.aliceAddress,
+      }),
+    );
     this.logger.info(`BananaCoin deployed at ${bananaCoin.address}`);
 
     this.bananaCoin = bananaCoin;
@@ -251,13 +308,27 @@ export class FeesTest {
     expect((await this.wallet.getContractMetadata(feeJuiceContract.address)).isContractPublished).toBe(true);
 
     const bananaCoin = this.bananaCoin;
-    const { contract: bananaFPC } = await FPCContract.deploy(this.wallet, bananaCoin.address, this.fpcAdmin).send({
-      from: this.aliceAddress,
-    });
+    const { contract: bananaFPC } = await testSpan('deploy:fpc', () =>
+      FPCContract.deploy(this.wallet, bananaCoin.address, this.fpcAdmin, {
+        salt: BANANA_FPC_SALT,
+        deployer: this.aliceAddress,
+      }).send({
+        from: this.aliceAddress,
+      }),
+    );
 
     this.logger.info(`BananaPay deployed at ${bananaFPC.address}`);
 
-    await this.feeJuiceBridgeTestHarness.bridgeFromL1ToL2(bananaFPC.address, this.aliceAddress);
+    // The BananaFPC's fee juice is seeded at genesis (see FeesTest.setup) rather than bridged here.
+    // Assert the deploy landed at the seeded address so a params drift surfaces as a clear error rather
+    // than a downstream "insufficient fee payer balance".
+    const { bananaFPCAddress } = await computeBananaContractAddresses(this.aliceAddress);
+    if (!bananaFPC.address.equals(bananaFPCAddress)) {
+      throw new Error(
+        `Deployed BananaFPC address ${bananaFPC.address} does not match the genesis-funded address ` +
+          `${bananaFPCAddress}; the deterministic deploy params drifted from the genesis funding computation.`,
+      );
+    }
 
     this.bananaFPC = bananaFPC;
 
@@ -338,10 +409,24 @@ export class FeesTest {
   public async applyFundAliceWithBananas() {
     this.logger.info('Applying fund Alice with bananas setup');
 
-    await this.mintPrivateBananas(this.ALICE_INITIAL_BANANAS, this.aliceAddress);
-    await this.bananaCoin.methods
-      .mint_to_public(this.aliceAddress, this.ALICE_INITIAL_BANANAS)
-      .send({ from: this.aliceAddress });
+    // Both mints are alice sends on BananaCoin touching disjoint balances, so they ride a single
+    // BatchCall tx (one proof, one slot) rather than two concurrent txs. The PXE serializes proving,
+    // so two concurrent sends would still be proven back-to-back and land in consecutive slots.
+    const { result: privateBalanceBefore } = await this.bananaCoin.methods
+      .balance_of_private(this.aliceAddress)
+      .simulate({ from: this.aliceAddress });
+
+    await testSpan('tx:mint', () =>
+      new BatchCall(this.wallet, [
+        this.bananaCoin.methods.mint_to_private(this.aliceAddress, this.ALICE_INITIAL_BANANAS),
+        this.bananaCoin.methods.mint_to_public(this.aliceAddress, this.ALICE_INITIAL_BANANAS),
+      ]).send({ from: this.aliceAddress }),
+    );
+
+    const { result: privateBalanceAfter } = await this.bananaCoin.methods
+      .balance_of_private(this.aliceAddress)
+      .simulate({ from: this.aliceAddress });
+    expect(privateBalanceAfter).toEqual(privateBalanceBefore + this.ALICE_INITIAL_BANANAS);
   }
 
   public async applyFundAliceWithPrivateBananas() {

package/src/single-node/l1-reorgs/setup.ts

@@ -0,0 +1,93 @@
+import type { Archiver } from '@aztec/archiver';
+import type { AztecNodeService } from '@aztec/aztec-node';
+import type { AztecAddress } from '@aztec/aztec.js/addresses';
+import { Fr } from '@aztec/aztec.js/fields';
+import type { Logger } from '@aztec/aztec.js/log';
+import type { AztecNode } from '@aztec/aztec.js/node';
+import type { Delayer } from '@aztec/ethereum/l1-tx-utils';
+import type { ChainMonitor } from '@aztec/ethereum/test';
+import type { TestContract } from '@aztec/noir-test-contracts.js/Test';
+import type { TxHash } from '@aztec/stdlib/tx';
+
+import { jest } from '@jest/globals';
+
+import type { EndToEndContext } from '../../fixtures/utils.js';
+import { proveAndSendTxs } from '../../test-wallet/utils.js';
+import { setupWithProver } from '../setup.js';
+import { FAST_REORG_TIMING, SingleNodeTestContext } from '../single_node_test_context.js';
+
+jest.setTimeout(1000 * 60 * 20);
+
+/** Number of txs to send at the start of each reorg test to trigger multi-block checkpoints. */
+export const TX_COUNT = 8;
+
+/**
+ * The single-node + prover-node fixture shared by the L1-reorg suites (`blocks`, `messages`). Stands
+ * up a {@link SingleNodeTestContext} on the {@link FAST_REORG_TIMING} cadence (ethSlot=4s,
+ * aztecSlot=24s, block=5s, epoch=4, 32 slots/epoch) with L1 speed-ups disabled so prover/sequencer txs
+ * can be held back and reorged, registers a {@link TestContract}, and exposes the per-test handles plus
+ * a `sendTransactions` helper that pre-proves and fires `count` lightweight txs to drive multi-block
+ * checkpoints. Reorgs themselves are driven by `EthCheatCodes.reorg`/`reorgWithReplacement` at the call
+ * site. The returned object's fields are populated when `setup()` resolves; create it in `beforeEach`.
+ */
+export class L1ReorgsTest {
+  public test!: SingleNodeTestContext;
+  public context!: EndToEndContext;
+  public logger!: Logger;
+  public node!: AztecNode;
+  public archiver!: Archiver;
+  public monitor!: ChainMonitor;
+  public proverDelayer!: Delayer;
+  public sequencerDelayer!: Delayer;
+  public contract!: TestContract;
+  public from!: AztecAddress;
+
+  public L1_BLOCK_TIME_IN_S!: number;
+  public L2_SLOT_DURATION_IN_S!: number;
+
+  public async setup(): Promise<void> {
+    this.test = await setupWithProver({
+      ...FAST_REORG_TIMING, // ethSlot=4s, aztecSlot=24s, block=5s, epoch=4, 32 slots/epoch (mainnet)
+      numberOfAccounts: 1,
+      maxSpeedUpAttempts: 0, // Do not speed up l1 txs, we dont want them to land
+      cancelTxOnTimeout: false,
+      minTxsPerBlock: 0,
+      maxTxsPerBlock: 1,
+      aztecProofSubmissionEpochs: 1,
+      // Pipelining + multi-blocks-per-slot: 5s blocks fit ~3 blocks per 24s slot, and TX_COUNT=8
+      // ensures multiple checkpoints have multiple blocks
+    });
+    ({
+      proverDelayer: this.proverDelayer,
+      sequencerDelayer: this.sequencerDelayer,
+      context: this.context,
+      logger: this.logger,
+      monitor: this.monitor,
+      L1_BLOCK_TIME_IN_S: this.L1_BLOCK_TIME_IN_S,
+      L2_SLOT_DURATION_IN_S: this.L2_SLOT_DURATION_IN_S,
+    } = this.test);
+    this.node = this.context.aztecNode;
+    this.archiver = (this.node as AztecNodeService).getBlockSource() as Archiver;
+    this.from = this.context.accounts[0];
+    this.contract = await this.test.registerTestContract(this.context.wallet);
+  }
+
+  public teardown(): Promise<void> {
+    return this.test.teardown();
+  }
+
+  /** Pre-proves and sends `count` txs to generate L2 activity for multi-block checkpoints. */
+  public async sendTransactions(count: number, offset = 0): Promise<TxHash[]> {
+    this.logger.warn(`Pre-proving ${count} transactions`);
+    const txHashes = await proveAndSendTxs(
+      this.context.wallet,
+      count,
+      i => this.contract.methods.emit_nullifier(new Fr(offset + i + 1)),
+      { from: this.from },
+    );
+    this.logger.warn(`Sent ${txHashes.length} transactions`);
+    return txHashes;
+  }
+}
+
+export { jest };

package/src/single-node/partial-proofs/setup.ts

@@ -0,0 +1,8 @@
+import { jest } from '@jest/globals';
+
+import { NO_REORG_SUBMISSION_EPOCHS, PROVING_SLOT_TIMING, setupWithProver } from '../setup.js';
+import { SingleNodeTestContext } from '../single_node_test_context.js';
+
+jest.setTimeout(1000 * 60 * 10);
+
+export { jest, setupWithProver, SingleNodeTestContext, NO_REORG_SUBMISSION_EPOCHS, PROVING_SLOT_TIMING };

package/src/single-node/proving/setup.ts

@@ -0,0 +1,15 @@
+import { jest } from '@jest/globals';
+
+import { NO_REORG_SUBMISSION_EPOCHS, PROVING_SLOT_TIMING, setupWithProver } from '../setup.js';
+import { SingleNodeTestContext, WORLD_STATE_CHECKPOINT_HISTORY } from '../single_node_test_context.js';
+
+jest.setTimeout(1000 * 60 * 15);
+
+export {
+  jest,
+  setupWithProver,
+  SingleNodeTestContext,
+  WORLD_STATE_CHECKPOINT_HISTORY,
+  NO_REORG_SUBMISSION_EPOCHS,
+  PROVING_SLOT_TIMING,
+};

package/src/single-node/recovery/setup.ts

@@ -0,0 +1,8 @@
+import { jest } from '@jest/globals';
+
+import { NO_REORG_SUBMISSION_EPOCHS, PROVING_SLOT_TIMING, setupWithProver } from '../setup.js';
+import { SingleNodeTestContext } from '../single_node_test_context.js';
+
+jest.setTimeout(1000 * 60 * 10);
+
+export { jest, setupWithProver, SingleNodeTestContext, NO_REORG_SUBMISSION_EPOCHS, PROVING_SLOT_TIMING };

package/src/single-node/setup.ts

@@ -0,0 +1,63 @@
+import { SingleNodeTestContext, type SingleNodeTestOpts } from './single_node_test_context.js';
+
+/**
+ * The single-node setup surface, organized over the prover axis (none / fake / real). Each factory is a
+ * thin wrapper over {@link SingleNodeTestContext.setup} that fixes the prover mode and the defaults that go
+ * with it; tests pick the factory matching their topology and vary it through `opts`.
+ */
+
+/**
+ * Proof-submission window (in epochs) so large the chain never prunes/reorgs in the test's lifetime.
+ * Tests that must keep unproven blocks alive for their whole run (no prover, or a hand-driven settler)
+ * set `aztecProofSubmissionEpochs` to this rather than picking an arbitrary large number.
+ */
+export const NO_REORG_SUBMISSION_EPOCHS = 1024;
+
+/**
+ * The "12s floor" slot cadence: a 4s L1 slot with 3 L1 slots per L2 slot, i.e. a 12s L2 slot. Shared by
+ * the proving / partial-proof suites whose bodies wait in real wall-clock for the sequencer to build
+ * empty checkpoints (one per L2 slot) and so cannot warp the clock forward. 12s is the shortest L2 slot
+ * that still fits one block per checkpoint under the default 3s block-duration timing model (which needs
+ * S >= ~8.5s); an 8s slot derives 0 blocks per checkpoint and trips the timing-config guard. Running at
+ * this floor keeps those real-time waits as short as possible.
+ */
+export const PROVING_SLOT_TIMING = {
+  ethereumSlotDuration: 4,
+  aztecSlotDurationInL1Slots: 3,
+} as const;
+
+/**
+ * Single sequencer plus the context's fake in-process prover node (`realProofs: false`,
+ * `aztecProofSubmissionEpochs: 1`, `syncChainTip: 'checkpointed'`). This is exactly today's
+ * {@link SingleNodeTestContext.setup} default, used by the proving/partial-proofs/reorg/recovery suites.
+ */
+export function setupWithProver(opts: SingleNodeTestOpts = {}): Promise<SingleNodeTestContext> {
+  return SingleNodeTestContext.setup(opts);
+}
+
+/**
+ * Single production sequencer with **no prover node**, used by the block-building/sequencer/sync suites.
+ *
+ * Dropping the prover requires raising `aztecProofSubmissionEpochs` to a high value
+ * ({@link NO_REORG_SUBMISSION_EPOCHS}): with the context's default window of `1` and no prover producing
+ * proofs, unproven blocks get pruned out from under the test after an epoch — so the high window keeps the
+ * blocks alive. Also defaults the PXE to `syncChainTip: 'proposed'` (rather than the context's
+ * `'checkpointed'`) since these tests assert on freshly proposed, not-yet-checkpointed blocks.
+ *
+ * Defaults `aztecEpochDuration` to `32` (the production default). These tests were written against the raw
+ * `setup()` helper, which deployed with the 32-slot production epoch; the context's own default of `6`
+ * lands an epoch boundary mid-test, where proposer selection changes and the propose for the boundary slot
+ * silently reverts (no checkpoint lands, the chain stops advancing). The 32-slot epoch keeps the boundary
+ * out past the short runs these tests need. All three (`startProverNode`, the proof window, the epoch) and
+ * `pxeOpts` can be overridden via `opts` — tests that need a shorter epoch (e.g. governance signalling) set
+ * their own.
+ */
+export function setupBlockProducer(opts: SingleNodeTestOpts = {}): Promise<SingleNodeTestContext> {
+  return SingleNodeTestContext.setup({
+    startProverNode: false,
+    aztecProofSubmissionEpochs: NO_REORG_SUBMISSION_EPOCHS,
+    aztecEpochDuration: 32,
+    ...opts,
+    pxeOpts: { syncChainTip: 'proposed', ...opts.pxeOpts },
+  });
+}