@aztec/aztec 0.0.1-commit.993d240 → 0.0.1-commit.9a89641

package/src/local-network/local-network.ts

@@ -1,27 +1,25 @@
 #!/usr/bin/env -S node --no-warnings
 import { getInitialTestAccountsData } from '@aztec/accounts/testing';
-import { AztecNodeService } from '@aztec/aztec-node';
+import { createAztecNodeService } from '@aztec/aztec-node';
 import { type AztecNodeConfig, getConfigEnvVars } from '@aztec/aztec-node/config';
 import { Fr } from '@aztec/aztec.js/fields';
 import { createLogger } from '@aztec/aztec.js/log';
 import { type BlobClientInterface, createBlobClient } from '@aztec/blob-client/client';
 import { GENESIS_ARCHIVE_ROOT } from '@aztec/constants';
-import { createEthereumChain } from '@aztec/ethereum/chain';
 import { waitForPublicClient } from '@aztec/ethereum/client';
 import { getL1ContractsConfigEnvVars } from '@aztec/ethereum/config';
 import { NULL_KEY } from '@aztec/ethereum/constants';
 import { deployAztecL1Contracts } from '@aztec/ethereum/deploy-aztec-l1-contracts';
 import type { L1ContractAddresses } from '@aztec/ethereum/l1-contract-addresses';
-import { EthCheatCodes } from '@aztec/ethereum/test';
 import { SecretValue } from '@aztec/foundation/config';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import type { LogFn } from '@aztec/foundation/log';
 import { DateProvider, TestDateProvider } from '@aztec/foundation/timer';
 import { getVKTreeRoot } from '@aztec/noir-protocol-circuits-types/vk-tree';
 import { protocolContractsHash } from '@aztec/protocol-contracts';
-import { SequencerState } from '@aztec/sequencer-client';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
 import type { ProvingJobBroker } from '@aztec/stdlib/interfaces/server';
+import { TxStatus } from '@aztec/stdlib/tx';
 import type { GenesisData } from '@aztec/stdlib/world-state';
 import {
   type TelemetryClient,
@@ -29,17 +27,15 @@ import {
   initTelemetryClient,
 } from '@aztec/telemetry-client';
 import { EmbeddedWallet } from '@aztec/wallets/embedded';
-import { deployFundedSchnorrAccounts } from '@aztec/wallets/testing';
+import { createFundedInitializerlessAccounts } from '@aztec/wallets/testing';
 import { getGenesisValues } from '@aztec/world-state/testing';
 
-import { type Hex, createPublicClient, fallback, http as httpViemTransport } from 'viem';
+import type { Hex } from 'viem';
 import { mnemonicToAccount, privateKeyToAddress } from 'viem/accounts';
 import { foundry } from 'viem/chains';
 
 import { createAccountLogs } from '../cli/util.js';
 import { DefaultMnemonic } from '../mnemonic.js';
-import { AnvilTestWatcher } from '../testing/anvil_test_watcher.js';
-import { EpochTestSettler } from '../testing/epoch_test_settler.js';
 import { getTokenAllowedSetupFunctions } from '../testing/token_allowed_setup.js';
 import { publishStandardAuthRegistry } from './auth_registry.js';
 import { getBananaFPCAddress, setupBananaFPC } from './banana_fpc.js';
@@ -47,7 +43,11 @@ import { getSponsoredFPCAddress } from './sponsored_fpc.js';
 
 const logger = createLogger('local-network');
 
-const localAnvil = foundry;
+// The embedded wallet defaults to waiting for PROPOSED, which returns as soon as a tx lands in a
+// proposed L2 block. That is flaky for the serial sandbox setup below: a proposed block can be
+// pruned before its checkpoint is published, dropping a tx we already moved on from ("Tx dropped by
+// P2P node"). Wait for the checkpoint so each setup tx is durably included before the next is sent.
+const setupWaitOpts = { waitForStatus: TxStatus.CHECKPOINTED };
 
 /**
  * Function to deploy our L1 contracts to the local network L1
@@ -88,6 +88,8 @@ export type LocalNetworkConfig = AztecNodeConfig & {
   l1Mnemonic: string;
   /** Whether to deploy test accounts on local network start.*/
   testAccounts: boolean;
+  /** Override the default per-address fee juice granted at genesis to funded addresses. */
+  initialAccountFeeJuice?: Fr;
 };
 
 /**
@@ -109,10 +111,33 @@ export async function createLocalNetwork(config: Partial<LocalNetworkConfig> = {
   // in the setup allowlist so FPC-based fee payments work out of the box.
   const tokenAllowList = await getTokenAllowedSetupFunctions();
 
+  const envConfig = getConfigEnvVars();
   const aztecNodeConfig: AztecNodeConfig = {
-    ...getConfigEnvVars(),
+    ...envConfig,
     ...config,
+    skipOrphanProposedBlockPruning: true,
+    // The local network builds node config from env without a DATA_DIRECTORY, so the validator's
+    // local signing protection runs against an ephemeral store. That is acceptable for this dev
+    // network; production validators must persist it and fail-fast when the data directory is unset.
+    allowEphemeralSigningProtection: config.allowEphemeralSigningProtection ?? true,
     txPublicSetupAllowListExtend: [...tokenAllowList, ...(config.txPublicSetupAllowListExtend ?? [])],
+    // The local network runs against anvil with no committee, so it defaults to the deterministic
+    // AutomineSequencer, which owns L1 time control (warps the dateProvider and L1 timestamps to slot
+    // boundaries as it builds), replacing the deleted AnvilTestWatcher. This remains true when p2p is
+    // enabled for local peer testing; local-network is not a mode for connecting to an existing network.
+    useAutomineSequencer: config.useAutomineSequencer ?? true,
+    // The AutomineSequencer owns epoch proving in the local network — it writes epoch out hashes to
+    // the L1 Outbox and advances the proven tip as checkpoints land, through the same serial queue as
+    // its builds — replacing the standalone EpochTestSettler that used to race the build loop.
+    automineEnableProveEpoch: config.automineEnableProveEpoch ?? true,
+    // Defaults for the local network / sandbox; callers (e.g. the CLI) may override. No real proving
+    // happens here — the AutomineSequencer synthetically settles epochs. Short epochs let it write out
+    // hashes quickly (so users can consume L2-to-L1 messages without a long wait), with a wider
+    // proof-submission window so the synthetic settler has headroom before the rollup would prune an
+    // unproven checkpoint.
+    realProofs: config.realProofs ?? false,
+    aztecEpochDuration: config.aztecEpochDuration ?? 4,
+    aztecProofSubmissionEpochs: config.aztecProofSubmissionEpochs ?? 2,
   };
   const hdAccount = mnemonicToAccount(config.l1Mnemonic || DefaultMnemonic);
   if (
@@ -136,7 +161,7 @@ export async function createLocalNetwork(config: Partial<LocalNetworkConfig> = {
   const initialAccounts = await (async () => {
     if (config.testAccounts === true || config.testAccounts === undefined) {
       if (aztecNodeConfig.p2pEnabled) {
-        userLog(`Not setting up test accounts as we are connecting to a network`);
+        userLog(`Not setting up test accounts when p2p is enabled`);
       } else {
         userLog(`Setting up test accounts`);
         return await getInitialTestAccountsData();
@@ -147,46 +172,24 @@ export async function createLocalNetwork(config: Partial<LocalNetworkConfig> = {
 
   const bananaFPC = await getBananaFPCAddress(initialAccounts);
   const sponsoredFPC = await getSponsoredFPCAddress();
-  const prefundAddresses = (aztecNodeConfig.prefundAddresses ?? []).map(a => AztecAddress.fromString(a));
+  const prefundAddresses = (aztecNodeConfig.prefundAddresses ?? []).map(a => AztecAddress.fromStringUnsafe(a));
   const fundedAddresses = [
     ...initialAccounts.map(a => a.address),
     ...(initialAccounts.length ? [bananaFPC, sponsoredFPC] : []),
     ...prefundAddresses,
   ];
-  const { genesisArchiveRoot, genesis, fundingNeeded } = await getGenesisValues(fundedAddresses);
+  const { genesisArchiveRoot, genesis, fundingNeeded } = await getGenesisValues(
+    fundedAddresses,
+    config.initialAccountFeeJuice,
+  );
 
   const dateProvider = new TestDateProvider();
 
-  let cheatcodes: EthCheatCodes | undefined;
-  let rollupAddress: EthAddress | undefined;
-  let watcher: AnvilTestWatcher | undefined;
   if (!aztecNodeConfig.p2pEnabled) {
-    ({ rollupAddress } = await deployContractsToL1(
-      aztecNodeConfig,
-      aztecNodeConfig.validatorPrivateKeys.getValue()[0],
-      {
-        genesisArchiveRoot,
-        feeJuicePortalInitialBalance: fundingNeeded,
-      },
-    ));
-
-    const chain =
-      aztecNodeConfig.l1RpcUrls.length > 0
-        ? createEthereumChain([l1RpcUrl], aztecNodeConfig.l1ChainId)
-        : { chainInfo: localAnvil };
-
-    const publicClient = createPublicClient({
-      chain: chain.chainInfo,
-      transport: fallback([httpViemTransport(l1RpcUrl)]) as any,
+    await deployContractsToL1(aztecNodeConfig, aztecNodeConfig.validatorPrivateKeys.getValue()[0], {
+      genesisArchiveRoot,
+      feeJuicePortalInitialBalance: fundingNeeded,
     });
-
-    cheatcodes = new EthCheatCodes([l1RpcUrl], dateProvider);
-
-    watcher = new AnvilTestWatcher(cheatcodes, rollupAddress, publicClient, dateProvider);
-    watcher.setisLocalNetwork(true);
-    watcher.setIsMarkingAsProven(false); // Do not mark as proven in the watcher. It's marked in the epochTestSettler after the out hash is set.
-
-    await watcher.start();
   }
 
   const telemetry = await initTelemetryClient(getTelemetryClientConfig());
@@ -194,48 +197,6 @@ export async function createLocalNetwork(config: Partial<LocalNetworkConfig> = {
   const blobClient = createBlobClient();
   const node = await createAztecNode(aztecNodeConfig, { telemetry, blobClient, dateProvider }, { genesis });
 
-  // Now that the node is up, let the watcher check for pending txs so it can skip unfilled slots faster when
-  // transactions are waiting in the mempool. Also let it check if the sequencer is actively building, to avoid
-  // warping time out from under an in-progress block.
-  watcher?.setGetPendingTxCount(() => node.getPendingTxCount());
-  const sequencer = node.getSequencer()?.getSequencer();
-  if (sequencer) {
-    const idleStates: Set<string> = new Set([
-      SequencerState.STOPPED,
-      SequencerState.STOPPING,
-      SequencerState.IDLE,
-      SequencerState.SYNCHRONIZING,
-    ]);
-    watcher?.setIsSequencerBuilding(() => !idleStates.has(sequencer.getState()));
-    // Under proposer pipelining the L1 publish for slot N happens during wall-clock slot N,
-    // but the proposer for slot N has already built the checkpoint during slot N-1 and is
-    // waiting for L1 to advance. We need to fast-forward L1 to wake that wait — and the wait
-    // we have to break first is `waitForValidParentCheckpointOnL1`, which blocks the
-    // checkpoint_proposal_job's background submission task until the archiver has synced past
-    // the build slot. That wait happens *before* `PUBLISHING_CHECKPOINT` is set, so a hook on
-    // that state transition would be circular (L1 has to advance before the state we'd use to
-    // advance L1 fires). The earliest pre-wait signal is `block-proposed`, which the sequencer
-    // emits once each block is built. In sandbox single-block-per-slot mode this is
-    // effectively "checkpoint built", and the watcher warp is harmless if a subsequent
-    // assembly/validation/parent-wait step aborts: L1 just sits one slot ahead, which the
-    // cascade absorbs.
-    if (watcher) {
-      sequencer.on('block-proposed', ({ slot }) => watcher!.setProposedTargetSlot(Number(slot)));
-    }
-  }
-
-  let epochTestSettler: EpochTestSettler | undefined;
-  if (!aztecNodeConfig.p2pEnabled) {
-    epochTestSettler = new EpochTestSettler(
-      cheatcodes!,
-      rollupAddress!,
-      node.getBlockSource(),
-      logger.createChild('epoch-settler'),
-      { pollingIntervalMs: 200 },
-    );
-    await epochTestSettler.start();
-  }
-
   if (initialAccounts.length) {
     const wallet = await EmbeddedWallet.create(node, {
       pxeConfig: { proverEnabled: aztecNodeConfig.realProofs },
@@ -243,14 +204,14 @@ export async function createLocalNetwork(config: Partial<LocalNetworkConfig> = {
     });
 
     userLog('Setting up funded test accounts...');
-    const accountManagers = await deployFundedSchnorrAccounts(wallet, initialAccounts);
+    const accountManagers = await createFundedInitializerlessAccounts(wallet, initialAccounts);
     const accLogs = await createAccountLogs(accountManagers, wallet);
     userLog(accLogs.join(''));
 
     userLog('Publishing standard AuthRegistry contract...');
-    await publishStandardAuthRegistry(wallet, initialAccounts[0].address);
+    await publishStandardAuthRegistry(wallet, initialAccounts[0].address, setupWaitOpts);
 
-    await setupBananaFPC(initialAccounts, wallet, userLog);
+    await setupBananaFPC(initialAccounts, wallet, userLog, setupWaitOpts);
 
     userLog(`SponsoredFPC: ${await getSponsoredFPCAddress()}`);
 
@@ -260,8 +221,6 @@ export async function createLocalNetwork(config: Partial<LocalNetworkConfig> = {
 
   const stop = async () => {
     await node.stop();
-    await watcher?.stop();
-    await epochTestSettler?.stop();
   };
 
   return { node, stop };
@@ -287,7 +246,7 @@ export async function createAztecNode(
     ...getConfigEnvVars(),
     ...config,
   };
-  const node = await AztecNodeService.createAndSync(
+  const node = await createAztecNodeService(
     aztecNodeConfig,
     { ...deps, proverNodeDeps: { broker: deps.proverBroker } },
     options,

package/src/testing/cheat_codes.ts

@@ -1,132 +1,48 @@
 import { EthCheatCodes, RollupCheatCodes } from '@aztec/ethereum/test';
-import { SlotNumber } from '@aztec/foundation/branded-types';
-import { createLogger } from '@aztec/foundation/log';
 import type { DateProvider } from '@aztec/foundation/timer';
-import type { AutomineSequencer } from '@aztec/sequencer-client';
 import type { AztecNode, AztecNodeDebug } from '@aztec/stdlib/interfaces/client';
 
 /**
- * A class that provides utility functions for interacting with the chain.
- * @deprecated There used to be 3 kinds of cheat codes: eth, rollup and aztec. We have nuked the Aztec ones because
- * they became unused (we now have better testing tools). If you are introducing a new functionality to the cheat
- * codes, please consider whether it makes sense to just introduce new utils in your tests instead.
+ * Wrapper for Aztec Debug API.
+ * @deprecated use the AztecNode debug API directly.
  */
 export class CheatCodes {
-  private logger = createLogger('aztecjs:cheat_codes');
-
   constructor(
     /** Cheat codes for L1.*/
     public eth: EthCheatCodes,
     /** Cheat codes for the Aztec Rollup contract on L1. */
     public rollup: RollupCheatCodes,
-    /** When wired, redirects time-warps through the AutomineSequencer queue (test-only). */
-    private automine?: AutomineSequencer,
   ) {}
 
-  static async create(
-    rpcUrls: string[],
-    node: AztecNode,
-    dateProvider: DateProvider,
-    automine?: AutomineSequencer,
-  ): Promise<CheatCodes> {
+  static async create(rpcUrls: string[], node: AztecNode, dateProvider: DateProvider): Promise<CheatCodes> {
     const ethCheatCodes = new EthCheatCodes(rpcUrls, dateProvider);
     const rollupCheatCodes = new RollupCheatCodes(
       ethCheatCodes,
       await node.getNodeInfo().then(n => n.l1ContractAddresses),
     );
-    return new CheatCodes(ethCheatCodes, rollupCheatCodes, automine);
+    return new CheatCodes(ethCheatCodes, rollupCheatCodes);
   }
 
   /**
-   * Warps the L1 timestamp to a target timestamp and mines an L2 block that advances the L2 timestamp to at least
-   * the target timestamp. If the target timestamp falls within the current L2 slot (which already has a block),
-   * the timestamp is automatically adjusted forward to the start of the next slot so that `mineBlock()` succeeds.
-   * @param node - The Aztec node used to force an empty block to be mined.
-   * @param targetTimestamp - The target timestamp to warp to (in seconds)
+   * Warps the L1 timestamp to at least `targetTimestamp` and mines an L2 block advancing the L2 timestamp to at least
+   * the target. Forwards to the node's debug API, which serializes the warp through the automine sequencer queue.
+   * @param node - The Aztec node whose debug API performs the warp. Must run an automine sequencer.
+   * @param targetTimestamp - The target timestamp to warp to (in seconds).
+   * @deprecated Call `node.warpL2TimeAtLeastTo(targetTimestamp)` on the node debug API directly.
    */
-  async warpL2TimeAtLeastTo(node: AztecNode & AztecNodeDebug, targetTimestamp: bigint | number) {
-    const targetBigInt = BigInt(targetTimestamp);
-    const currentTimestamp = BigInt(await this.eth.lastBlockTimestamp());
-
-    if (targetBigInt <= currentTimestamp) {
-      throw new Error(
-        `warpL2TimeAtLeastTo: target timestamp ${targetBigInt} is not in the future (current L1 timestamp is ${currentTimestamp}).`,
-      );
-    }
-
-    // AutomineSequencer owns time control through its serial queue — delegate to keep warps atomic
-    // with respect to any in-flight build, and avoid the mineBlock-loop hack below.
-    // `warpTo` internally builds an empty L2 checkpoint, which auto-mines exactly one L1 block at
-    // the target slot boundary, so no separate `node.mineBlock()` is needed here.
-    if (this.automine) {
-      await this.automine.warpTo(Number(targetBigInt));
-      return;
-    }
-
-    const currentSlot = await this.rollup.getSlot();
-    const targetSlot = await this.rollup.getSlotAt(targetBigInt);
-
-    let effectiveTimestamp = targetBigInt;
-    let effectiveTargetSlot = targetSlot;
-
-    if (targetSlot <= currentSlot) {
-      // Target lands in the same (or earlier) slot — auto-adjust to the next slot's start.
-      const nextSlot = SlotNumber(currentSlot + 1);
-      const nextSlotTimestamp = await this.rollup.getTimestampForSlot(nextSlot);
-      this.logger.warn(
-        `warpL2TimeAtLeastTo: target timestamp ${targetBigInt} falls in current slot ${currentSlot}. ` +
-          `Auto-adjusting to start of slot ${nextSlot} at timestamp ${nextSlotTimestamp}.`,
-      );
-      effectiveTimestamp = nextSlotTimestamp;
-      effectiveTargetSlot = nextSlot;
-    }
-
-    await this.eth.warp(effectiveTimestamp, { resetBlockInterval: true });
-
-    // The sequencer's polling loop may have a `work()` cycle in flight that captured pre-warp slot/timestamp values
-    // just before our warp landed. That cycle would mine an L2 block at the stale slot — the L1 sync prunes such a
-    // block from the canonical chain, but it lingers in local world state and the PXE will use it as the anchor for
-    // subsequent txs, leading to `expiration_timestamp` values that are already in the past relative to L1. Mine
-    // until we observe an L2 block at (or past) the post-warp slot, ensuring the next tx anchors to a fresh block.
-    const maxAttempts = 5;
-    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
-      await node.mineBlock();
-      const blockData = await node.getBlockData('latest');
-      const blockSlot = blockData?.header.globalVariables.slotNumber;
-      if (blockSlot !== undefined && BigInt(blockSlot) >= BigInt(effectiveTargetSlot)) {
-        return;
-      }
-      this.logger.warn(
-        `warpL2TimeAtLeastTo: mined L2 block at slot ${blockSlot}, expected at least ${effectiveTargetSlot}. ` +
-          `Retrying mineBlock (attempt ${attempt}/${maxAttempts}).`,
-      );
-    }
-    throw new Error(
-      `warpL2TimeAtLeastTo: failed to mine an L2 block at or past slot ${effectiveTargetSlot} after ${maxAttempts} attempts.`,
-    );
+  warpL2TimeAtLeastTo(node: AztecNode & AztecNodeDebug, targetTimestamp: bigint | number): Promise<void> {
+    return node.warpL2TimeAtLeastTo(Number(targetTimestamp));
   }
 
   /**
-   * Warps the L1 timestamp forward by a specified duration and mines an L2 block that advances the L2 timestamp at
-   * least by the duration. If the duration is too short to cross an L2 slot boundary, the warp is automatically
-   * extended to the start of the next slot so that `mineBlock()` succeeds.
-   * @param node - The Aztec node used to force an empty block to be mined.
-   * @param duration - The duration to advance time by (in seconds)
+   * Warps the L1 timestamp forward by at least `duration` seconds and mines an L2 block advancing the L2 timestamp at
+   * least by the duration. Forwards to the node's debug API, which serializes the warp through the automine sequencer
+   * queue.
+   * @param node - The Aztec node whose debug API performs the warp. Must run an automine sequencer.
+   * @param duration - The duration to advance time by (in seconds).
+   * @deprecated Call `node.warpL2TimeAtLeastBy(duration)` on the node debug API directly.
    */
-  async warpL2TimeAtLeastBy(node: AztecNode & AztecNodeDebug, duration: bigint | number) {
-    if (BigInt(duration) <= 0n) {
-      throw new Error(`warpL2TimeAtLeastBy: duration must be positive, got ${duration} seconds.`);
-    }
-
-    // Advance relative to whichever clock leads. A live sequencer mines L2 blocks at slot boundaries that can run
-    // ahead of anvil's L1 timestamp, so basing the target on L1 alone would advance the L2 timestamp by less than
-    // `duration`. Anchoring to the latest L2 block timestamp when it leads guarantees the post-warp L2 block is at
-    // least `duration` ahead of the current one.
-    const currentL1Timestamp = BigInt(await this.eth.lastBlockTimestamp());
-    const latestBlockData = await node.getBlockData('latest');
-    const latestL2Timestamp = latestBlockData ? BigInt(latestBlockData.header.globalVariables.timestamp) : 0n;
-    const baseTimestamp = latestL2Timestamp > currentL1Timestamp ? latestL2Timestamp : currentL1Timestamp;
-    const targetTimestamp = baseTimestamp + BigInt(duration);
-    await this.warpL2TimeAtLeastTo(node, targetTimestamp);
+  warpL2TimeAtLeastBy(node: AztecNode & AztecNodeDebug, duration: bigint | number): Promise<void> {
+    return node.warpL2TimeAtLeastBy(Number(duration));
   }
 }

package/src/testing/epoch_test_settler.ts

@@ -1,10 +1,9 @@
-import { Fr } from '@aztec/aztec.js/fields';
 import { type EthCheatCodes, RollupCheatCodes } from '@aztec/ethereum/test';
-import { type EpochNumber, SlotNumber } from '@aztec/foundation/branded-types';
+import type { EpochNumber } from '@aztec/foundation/branded-types';
 import type { Logger } from '@aztec/foundation/log';
+import { settleEpochOutbox } from '@aztec/prover-client/test';
 import { EpochMonitor } from '@aztec/prover-node';
 import type { EthAddress, L2BlockSource } from '@aztec/stdlib/block';
-import { computeEpochOutHash } from '@aztec/stdlib/messaging';
 
 export class EpochTestSettler {
   private rollupCheatCodes: RollupCheatCodes;
@@ -31,33 +30,12 @@ export class EpochTestSettler {
   }
 
   async handleEpochReadyToProve(epoch: EpochNumber): Promise<boolean> {
-    const blocks = await this.l2BlockSource.getBlocks({ epoch, onlyCheckpointed: true });
-    this.log.info(
-      `Settling epoch ${epoch} with blocks ${blocks[0]?.header.getBlockNumber()} to ${blocks.at(-1)?.header.getBlockNumber()}`,
-      { blocks: blocks.map(b => b.toBlockInfo()) },
-    );
-    const messagesInEpoch: Fr[][][][] = [];
-    let previousSlotNumber = SlotNumber.ZERO;
-    let checkpointIndex = -1;
-
-    for (const block of blocks) {
-      const slotNumber = block.header.globalVariables.slotNumber;
-      if (slotNumber !== previousSlotNumber) {
-        checkpointIndex++;
-        messagesInEpoch[checkpointIndex] = [];
-        previousSlotNumber = slotNumber;
-      }
-      messagesInEpoch[checkpointIndex].push(block.body.txEffects.map(txEffect => txEffect.l2ToL1Msgs));
-    }
-
-    const outHash = computeEpochOutHash(messagesInEpoch);
-    if (!outHash.isZero()) {
-      await this.rollupCheatCodes.insertOutbox(epoch, messagesInEpoch.length, outHash.toBigInt());
-    } else {
-      this.log.info(`No L2 to L1 messages in epoch ${epoch}`);
-    }
-
-    const lastCheckpoint = blocks.at(-1)?.checkpointNumber;
+    const lastCheckpoint = await settleEpochOutbox({
+      rollupCheatCodes: this.rollupCheatCodes,
+      l2BlockSource: this.l2BlockSource,
+      epoch,
+      log: this.log,
+    });
     if (lastCheckpoint !== undefined) {
       await this.rollupCheatCodes.markAsProven(lastCheckpoint);
     } else {

package/src/testing/index.ts

@@ -1,5 +1,5 @@
-export { AnvilTestWatcher, type AnvilTestWatcherOpts } from './anvil_test_watcher.js';
 export { EthCheatCodes, RollupCheatCodes } from '@aztec/ethereum/test';
 export { CheatCodes } from './cheat_codes.js';
 export { EpochTestSettler } from './epoch_test_settler.js';
+export { setupLocalNetwork, TEST_FEE_PADDING, type LocalNetwork, type LocalNetworkOptions } from './local-network.js';
 export { getTokenAllowedSetupFunctions } from './token_allowed_setup.js';

package/src/testing/local-network.ts

@@ -0,0 +1,97 @@
+import type { AztecNodeService } from '@aztec/aztec-node';
+import type { AztecNodeConfig } from '@aztec/aztec-node/config';
+import type { Fr } from '@aztec/aztec.js/fields';
+import { startAnvil } from '@aztec/ethereum/test';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+
+import { foundry } from 'viem/chains';
+
+import { createLocalNetwork } from '../local-network/local-network.js';
+
+/** A running in-process local network: an inline Aztec node backed by its own anvil L1. */
+export interface LocalNetwork extends AsyncDisposable {
+  /** Fully-synced Aztec node, ready to serve client requests. */
+  node: AztecNodeService;
+  /** RPC URL of the spawned anvil instance. */
+  l1RpcUrl: string;
+  /** Chain id used on L1 (foundry's default 31337). */
+  l1ChainId: number;
+  /** Stops every process started by the fixture: node and anvil. Also invoked by `await using`. */
+  stop: () => Promise<void>;
+}
+
+/** Options for {@link setupLocalNetwork}. */
+export interface LocalNetworkOptions {
+  /**
+   * Addresses that should hold fee juice at genesis. Saves each of these the round-trip of bridging
+   * + claiming fee juice before they can pay for gas.
+   */
+  fundedAddresses?: AztecAddress[];
+  /** Override the default per-address genesis fee juice granted to {@link fundedAddresses}. */
+  initialAccountFeeJuice?: Fr;
+  /** Node config overrides, e.g. `realProofs`, `aztecEpochDuration`, `p2pEnabled`. */
+  config?: Partial<AztecNodeConfig>;
+}
+
+/**
+ * Spin up an in-process local network with the given addresses pre-funded.
+ *
+ * Each call spawns its own anvil on an OS-assigned random port and runs the Aztec node inline via
+ * the same {@link createLocalNetwork} codepath that backs `aztec start --local-network` (with the
+ * sandbox account/FPC/token setup skipped). Distinct ports let independent suites run in parallel.
+ * The caller must `await result.stop()` in its teardown (or hold the result with `await using`).
+ *
+ * Requires a Foundry toolchain (`anvil`/`forge`), installed via `aztec-up` or `foundryup`. Binaries
+ * are located in the standard install directories or on `PATH`; set `$ANVIL_BIN` / `$FORGE_BIN` to
+ * pin specific ones.
+ */
+export async function setupLocalNetwork(opts: LocalNetworkOptions = {}): Promise<LocalNetwork> {
+  // `--port 0` → anvil binds an ephemeral port that `startAnvil` reads back, so parallel suites
+  // never collide on a fixed port.
+  const { rpcUrl, stop: stopAnvil } = await startAnvil({ port: 0 });
+
+  try {
+    const { node, stop: stopNode } = await createLocalNetwork(
+      {
+        ...opts.config,
+        l1RpcUrls: [rpcUrl],
+        testAccounts: false,
+        prefundAddresses: (opts.fundedAddresses ?? []).map(a => a.toString()),
+        initialAccountFeeJuice: opts.initialAccountFeeJuice,
+      },
+      () => {},
+    );
+
+    // Stop the node before anvil (its teardown still talks to L1); the finally guarantees anvil is
+    // reaped even if node shutdown throws.
+    const stop = async () => {
+      try {
+        await stopNode();
+      } finally {
+        await stopAnvil();
+      }
+    };
+
+    return {
+      node,
+      l1RpcUrl: rpcUrl,
+      l1ChainId: foundry.id,
+      stop,
+      [Symbol.asyncDispose]: stop,
+    };
+  } catch (err) {
+    await stopAnvil();
+    throw err;
+  }
+}
+
+/**
+ * Min-fee padding multiplier for test wallets whose txs may mine well after their fee estimate.
+ * The automine sequencer builds one block per tx and advances L1 time in big jumps, and proposer
+ * pipelining evolves the fee-asset price across the build/publish gap (~20x observed in CI), so the
+ * network's congestion base fee can swing sharply between the wallet's fee estimate and the block
+ * the tx actually lands in. The default wallet padding isn't enough and trips
+ * `maxFeesPerGas.feePerL2Gas must be >= gasFees.feePerL2Gas`. Apply via
+ * `wallet.setMinFeePadding(TEST_FEE_PADDING)` on every test wallet that sends txs.
+ */
+export const TEST_FEE_PADDING = 30;

package/src/testing/token_allowed_setup.ts

@@ -1,19 +1,26 @@
 import { TokenContractArtifact } from '@aztec/noir-contracts.js/Token';
 import { buildAllowedElement } from '@aztec/p2p/msg_validators';
+import type { ContractArtifact } from '@aztec/stdlib/abi';
 import { getContractClassFromArtifact } from '@aztec/stdlib/contract';
 import type { AllowedElement } from '@aztec/stdlib/interfaces/server';
 
 /**
- * Returns Token-specific allowlist entries needed for FPC-based fee payments.
- * These are test-only: FPC-based fee payment with custom tokens won't work on mainnet alpha.
+ * Returns the allowlist entries needed for FPC-based fee payments, keyed by the contract class of
+ * the `artifact` actually deployed as the fee token (defaults to canonical Token). The setup-phase
+ * validator matches these entries by class id, so a test deploying the codegen'd TestToken as its
+ * fee vehicle must pass `TestTokenContract.artifact` here -- otherwise the FPC fee calls are matched
+ * against the wrong class and rejected. Test-only: FPC fee payment with custom tokens won't work on
+ * mainnet alpha.
  */
-export async function getTokenAllowedSetupFunctions(): Promise<AllowedElement[]> {
-  const tokenClassId = (await getContractClassFromArtifact(TokenContractArtifact)).id;
+export async function getTokenAllowedSetupFunctions(
+  artifact: ContractArtifact = TokenContractArtifact,
+): Promise<AllowedElement[]> {
+  const tokenClassId = (await getContractClassFromArtifact(artifact)).id;
   const target = { classId: tokenClassId };
   return Promise.all([
-    // Token: needed for private transfers via FPC (transfer_to_public enqueues this)
-    buildAllowedElement(TokenContractArtifact, target, '_increase_public_balance', { onlySelf: true }),
-    // Token: needed for public transfers via FPC (fee_entrypoint_public enqueues this)
-    buildAllowedElement(TokenContractArtifact, target, 'transfer_in_public'),
+    // needed for private transfers via FPC (transfer_to_public enqueues this)
+    buildAllowedElement(artifact, target, '_increase_public_balance', { onlySelf: true }),
+    // needed for public transfers via FPC (fee_entrypoint_public enqueues this)
+    buildAllowedElement(artifact, target, 'transfer_in_public'),
   ]);
 }