@aztec/end-to-end 0.0.1-commit.d3ec352c → 0.0.1-commit.d58ff9d0

package/src/single-node/fees/fees_test.ts

@@ -0,0 +1,368 @@
+import type { AztecAddress } from '@aztec/aztec.js/addresses';
+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 type { RollupContract } from '@aztec/ethereum/contracts';
+import type { DeployAztecL1ContractsArgs } from '@aztec/ethereum/deploy-aztec-l1-contracts';
+import { BlockNumber } from '@aztec/foundation/branded-types';
+import { EthAddress } from '@aztec/foundation/eth-address';
+import { sleep } from '@aztec/foundation/sleep';
+import { TestERC20Abi } from '@aztec/l1-artifacts';
+import { AppSubscriptionContract } from '@aztec/noir-contracts.js/AppSubscription';
+import { FPCContract } from '@aztec/noir-contracts.js/FPC';
+import { FeeJuiceContract } from '@aztec/noir-contracts.js/FeeJuice';
+import { SponsoredFPCContract } from '@aztec/noir-contracts.js/SponsoredFPC';
+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 { 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 { 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 {
+  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';
+
+/**
+ * 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.
+ * 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 extends SingleNodeTestContext {
+  private accounts: AztecAddress[] = [];
+
+  public aztecNode!: AztecNode;
+  public aztecNodeAdmin!: AztecNodeAdmin;
+  public cheatCodes!: CheatCodes;
+
+  public wallet!: TestWallet;
+  public aliceAddress!: AztecAddress;
+  public bobAddress!: AztecAddress;
+  public sequencerAddress!: AztecAddress;
+  public coinbase!: EthAddress;
+
+  public fpcAdmin!: AztecAddress;
+
+  public gasSettings!: GasSettings;
+
+  /** The base's {@link SingleNodeTestContext.rollup}, exposed under the fee suite's historical name. */
+  public rollupContract!: RollupContract;
+
+  public feeJuiceContract!: FeeJuiceContract;
+  public bananaCoin!: BananaCoin;
+  public bananaFPC!: FPCContract;
+  public sponsoredFPC!: SponsoredFPCContract;
+  public counterContract!: CounterContract;
+  public subscriptionContract!: AppSubscriptionContract;
+  public feeJuiceBridgeTestHarness!: GasBridgingTestHarness;
+
+  public getCoinbaseBalance!: () => Promise<bigint>;
+  public getCoinbaseSequencerRewards!: () => Promise<bigint>;
+  public getGasBalanceFn!: BalancesFn;
+  public getBananaPublicBalanceFn!: BalancesFn;
+  public getBananaPrivateBalanceFn!: BalancesFn;
+  public getProverFee!: (blockNumber: BlockNumber) => Promise<bigint>;
+  public getCommittedProverFee!: (blockNumber: BlockNumber) => Promise<bigint>;
+  public getCommittedBurn!: (blockNumber: BlockNumber) => Promise<bigint>;
+
+  public readonly ALICE_INITIAL_BANANAS = BigInt(1e22);
+  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}`);
+  }
+
+  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();
+    const context = await setup(this.numberOfAccounts, {
+      startProverNode: true,
+      ...this.setupOptions,
+      ...opts,
+      fundSponsoredFPC: true,
+      l1ContractsArgs: { ...this.setupOptions },
+      txPublicSetupAllowListExtend: [...(this.setupOptions.txPublicSetupAllowListExtend ?? []), ...tokenAllowList],
+    });
+
+    // 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();
+  }
+
+  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.cheatCodes.rollup.advanceToNextEpoch();
+    await this.catchUpProvenChain();
+  }
+
+  async getBlockRewards() {
+    const blockReward = await this.rollupContract.getCheckpointReward();
+    const rewardConfig = await this.rollupContract.getRewardConfig();
+
+    const balance = await this.feeJuiceBridgeTestHarness.getL1FeeJuiceBalance(rewardConfig.rewardDistributor);
+
+    const toDistribute = balance > blockReward ? blockReward : balance;
+    const sequencerBlockRewards = (toDistribute * BigInt(rewardConfig.sequencerBps)) / 10000n;
+    const proverBlockRewards = toDistribute - sequencerBlockRewards;
+
+    return { sequencerBlockRewards, proverBlockRewards };
+  }
+
+  async mintAndBridgeFeeJuice(minter: AztecAddress, recipient: AztecAddress) {
+    const claim = await this.feeJuiceBridgeTestHarness.prepareTokensOnL1(recipient);
+    const { claimSecret: secret, messageLeafIndex: index } = claim;
+    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. */
+  async mintPrivateBananas(amount: bigint, address: AztecAddress) {
+    const { result: balanceBefore } = await this.bananaCoin.methods
+      .balance_of_private(address)
+      .simulate({ from: address });
+
+    await testSpan('tx:mint', () => mintTokensToPrivate(this.bananaCoin, this.aliceAddress, address, amount));
+
+    const { result: balanceAfter } = await this.bananaCoin.methods
+      .balance_of_private(address)
+      .simulate({ from: address });
+    expect(balanceAfter).toEqual(balanceBefore + amount);
+  }
+
+  public async applyBaseSetup() {
+    await this.applyInitialAccounts();
+    await this.applyEnsureAuthRegistryPublished();
+    await this.applySetupFeeJuice();
+    await this.applyDeployBananaToken();
+  }
+
+  async applyEnsureAuthRegistryPublished() {
+    this.logger.info('Ensuring AuthRegistry published');
+    await ensureAuthRegistryPublished(this.wallet, this.aliceAddress);
+  }
+
+  async applyInitialAccounts() {
+    this.logger.info('Applying initial accounts setup');
+
+    this.wallet = this.context.wallet;
+    this.aztecNode = this.context.aztecNodeService;
+    this.aztecNodeAdmin = this.context.aztecNodeService;
+    this.gasSettings = GasSettings.fallback({
+      gasLimits: Gas.from((await this.aztecNode.getNodeInfo()).txsLimits.gas),
+      maxFeesPerGas: await getPaddedMaxFeesPerGas(this.aztecNode),
+    });
+    this.cheatCodes = this.context.cheatCodes;
+    this.accounts = this.context.accounts;
+    this.accounts.forEach((a, i) => this.logger.verbose(`Account ${i} address: ${a}`));
+    [this.aliceAddress, this.bobAddress, this.sequencerAddress] = this.accounts.slice(0, 3);
+
+    // We set Alice as the FPC admin to avoid the need for deployment of another account.
+    this.fpcAdmin = this.aliceAddress;
+
+    const canonicalFeeJuice = await getCanonicalFeeJuice();
+    this.feeJuiceContract = FeeJuiceContract.at(canonicalFeeJuice.address, this.wallet);
+  }
+
+  async applySetupFeeJuice() {
+    this.logger.info('Applying fee juice setup');
+
+    this.feeJuiceContract = FeeJuiceContract.at(ProtocolContractAddress.FeeJuice, this.wallet);
+
+    this.getGasBalanceFn = getBalancesFn('⛽', this.feeJuiceContract.methods.balance_of_public, this.logger);
+
+    this.feeJuiceBridgeTestHarness = await FeeJuicePortalTestingHarnessFactory.create({
+      aztecNode: this.context.aztecNodeService,
+      aztecNodeAdmin: this.context.aztecNodeService,
+      // Bridge from a dedicated L1 account so its direct writes don't race the sequencer publisher's
+      // txs on the deployer account (see L1_DIRECT_WRITE_ACCOUNT_INDEX).
+      l1Client: createExtendedL1Client(
+        this.context.config.l1RpcUrls,
+        MNEMONIC,
+        undefined,
+        undefined,
+        L1_DIRECT_WRITE_ACCOUNT_INDEX,
+      ),
+      wallet: this.wallet,
+      logger: this.logger,
+    });
+  }
+
+  async applyDeployBananaToken() {
+    this.logger.info('Applying deploy banana token setup');
+
+    const { contract: bananaCoin } = await testSpan('deploy:token', () =>
+      BananaCoin.deploy(this.wallet, this.aliceAddress, 'BC', 'BC', 18n).send({
+        from: this.aliceAddress,
+      }),
+    );
+    this.logger.info(`BananaCoin deployed at ${bananaCoin.address}`);
+
+    this.bananaCoin = bananaCoin;
+    this.getBananaPublicBalanceFn = getBalancesFn('🍌.public', this.bananaCoin.methods.balance_of_public, this.logger);
+    this.getBananaPrivateBalanceFn = getBalancesFn(
+      '🍌.private',
+      this.bananaCoin.methods.balance_of_private,
+      this.logger,
+    );
+  }
+
+  public async applyFPCSetup() {
+    this.logger.info('Applying FPC setup');
+
+    const feeJuiceContract = this.feeJuiceBridgeTestHarness.feeJuice;
+    expect((await this.wallet.getContractMetadata(feeJuiceContract.address)).isContractPublished).toBe(true);
+
+    const bananaCoin = this.bananaCoin;
+    const { contract: bananaFPC } = await testSpan('deploy:fpc', () =>
+      FPCContract.deploy(this.wallet, bananaCoin.address, this.fpcAdmin).send({
+        from: this.aliceAddress,
+      }),
+    );
+
+    this.logger.info(`BananaPay deployed at ${bananaFPC.address}`);
+
+    // bridgeFromL1ToL2 carries its own setup:bridge span.
+    await this.feeJuiceBridgeTestHarness.bridgeFromL1ToL2(bananaFPC.address, this.aliceAddress);
+
+    this.bananaFPC = bananaFPC;
+
+    const l1FeeJuiceAddress = this.feeJuiceBridgeTestHarness.l1FeeJuiceAddress;
+
+    this.getCoinbaseBalance = async () => {
+      const l1Client = createExtendedL1Client(this.context.config.l1RpcUrls, MNEMONIC);
+      const gasL1 = getContract({
+        address: l1FeeJuiceAddress.toString(),
+        abi: TestERC20Abi,
+        client: l1Client,
+      });
+      return await gasL1.read.balanceOf([this.coinbase.toString()]);
+    };
+
+    this.getCoinbaseSequencerRewards = async () => {
+      return await this.rollupContract.getSequencerRewards(this.coinbase);
+    };
+
+    this.getProverFee = async (blockNumber: BlockNumber) => {
+      const block = await this.aztecNode.getBlock(blockNumber);
+
+      // @todo @lherskind As we deal with #13601
+      // Right now the value is from `FeeLib.sol`
+      const L1_GAS_PER_EPOCH_VERIFIED = 3600000n;
+
+      // We round up
+      const mulDiv = (a: bigint, b: bigint, c: bigint) => (a * b) / c + ((a * b) % c > 0n ? 1n : 0n);
+
+      const { baseFee } = await this.rollupContract.getL1FeesAt(block!.header.globalVariables.timestamp);
+      const proverCost =
+        mulDiv(
+          mulDiv(L1_GAS_PER_EPOCH_VERIFIED, baseFee, BigInt(await this.rollupContract.getEpochDuration())),
+          1n,
+          await this.rollupContract.getManaTarget(),
+        ) + (await this.rollupContract.getProvingCostPerMana());
+
+      const price = await this.rollupContract.getEthPerFeeAsset();
+
+      const mana = block!.header.totalManaUsed.toBigInt();
+      return mulDiv(mana * proverCost, 10n ** 12n, price);
+    };
+
+    /**
+     * Reads the prover fee that the rollup actually committed for the block's checkpoint, which is what
+     * RewardLib uses to pay prover rewards. Unlike `getProverFee`, this does not re-derive the value
+     * from current L1 fees or current eth-per-fee-asset price, so it is robust to pipelined fee-asset-price
+     * drift between propose-time and reward-payout-time.
+     */
+    this.getCommittedProverFee = async (blockNumber: BlockNumber) => {
+      const block = await this.aztecNode.getBlock(blockNumber);
+      const feeHeader = await this.rollupContract.getFeeHeader(BigInt(block!.checkpointNumber));
+      return feeHeader.manaUsed * feeHeader.proverCost;
+    };
+
+    // RewardLib computes sequencerFee = checkpointFee - burn - proverFee where burn = manaUsed * congestionCost.
+    // The fixture's typical case keeps congestionCost at zero, but reading it explicitly avoids latent bugs
+    // when test load changes excess mana.
+    this.getCommittedBurn = async (blockNumber: BlockNumber) => {
+      const block = await this.aztecNode.getBlock(blockNumber);
+      const feeHeader = await this.rollupContract.getFeeHeader(BigInt(block!.checkpointNumber));
+      return feeHeader.manaUsed * feeHeader.congestionCost;
+    };
+  }
+
+  public async applySponsoredFPCSetup() {
+    this.logger.info('Applying sponsored FPC setup');
+
+    const feeJuiceContract = this.feeJuiceBridgeTestHarness.feeJuice;
+    expect((await this.wallet.getContractMetadata(feeJuiceContract.address)).isContractPublished).toBe(true);
+
+    const sponsoredFPCInstance = await setupSponsoredFPC(this.wallet);
+    this.logger.info(`SponsoredFPC at ${sponsoredFPCInstance.address}`);
+
+    this.sponsoredFPC = SponsoredFPCContract.at(sponsoredFPCInstance.address, this.wallet);
+  }
+
+  public async applyFundAliceWithBananas() {
+    this.logger.info('Applying fund Alice with bananas setup');
+
+    await this.mintPrivateBananas(this.ALICE_INITIAL_BANANAS, this.aliceAddress);
+    await testSpan('tx:mint', () =>
+      this.bananaCoin.methods.mint_to_public(this.aliceAddress, this.ALICE_INITIAL_BANANAS).send({
+        from: this.aliceAddress,
+      }),
+    );
+  }
+
+  public async applyFundAliceWithPrivateBananas() {
+    this.logger.info('Applying fund Alice with private bananas setup');
+
+    await this.mintPrivateBananas(this.ALICE_INITIAL_BANANAS, this.aliceAddress);
+  }
+}

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=36s, block=8s, 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=36s, block=8s, 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: 8s blocks fit ~4 blocks per 36s 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 },
+  });
+}