@aztec/end-to-end 0.0.1-commit.96dac018d → 0.0.1-commit.9a89641

package/src/{e2e_blacklist_token_contract → automine/token}/blacklist_token_contract_test.ts

@@ -1,21 +1,18 @@
 import { AztecAddress } from '@aztec/aztec.js/addresses';
 import { computeSecretHash } from '@aztec/aztec.js/crypto';
 import { Fr } from '@aztec/aztec.js/fields';
-import { type Logger, createLogger } from '@aztec/aztec.js/log';
-import type { AztecNode } from '@aztec/aztec.js/node';
+import { createLogger } from '@aztec/aztec.js/log';
 import type { TxHash } from '@aztec/aztec.js/tx';
-import type { CheatCodes } from '@aztec/aztec/testing';
 import type { TokenContract } from '@aztec/noir-contracts.js/Token';
 import { TokenBlacklistContract } from '@aztec/noir-contracts.js/TokenBlacklist';
 import { GenericProxyContract } from '@aztec/noir-test-contracts.js/GenericProxy';
 import { InvalidAccountContract } from '@aztec/noir-test-contracts.js/InvalidAccount';
-import type { SequencerClient } from '@aztec/sequencer-client';
 
 import { jest } from '@jest/globals';
 
-import { type EndToEndContext, deployAccounts, publicDeployAccounts, setup, teardown } from '../fixtures/setup.js';
-import { TokenSimulator } from '../simulators/token_simulator.js';
-import type { TestWallet } from '../test-wallet/test_wallet.js';
+import { ensureAuthRegistryPublished } from '../../fixtures/setup.js';
+import { TokenSimulator } from '../../simulators/token_simulator.js';
+import { AutomineTestContext, type AutomineTestOpts } from '../automine_test_context.js';
 
 export class Role {
   private isAdmin = false;
@@ -44,35 +41,33 @@ export class Role {
   }
 }
 
-export class BlacklistTokenContractTest {
+/**
+ * TokenBlacklist-domain harness over the automine topology: extends {@link AutomineTestContext} with a
+ * {@link TokenSimulator}, the {@link Role} helper, the TokenBlacklist deploy plus a bad-account and
+ * authwit proxy, and the role-change-delay warp. Base setup and mint run in {@link setup}.
+ */
+export class BlacklistTokenContractTest extends AutomineTestContext {
   // This value MUST match the same value that we have in the contract
   static CHANGE_ROLES_DELAY = 86400;
 
-  context!: EndToEndContext;
-  logger: Logger;
-  wallet!: TestWallet;
   asset!: TokenBlacklistContract;
   tokenSim!: TokenSimulator;
   badAccount!: InvalidAccountContract;
   authwitProxy!: GenericProxyContract;
-  cheatCodes!: CheatCodes;
-  sequencer!: SequencerClient;
-  aztecNode!: AztecNode;
 
   adminAddress!: AztecAddress;
   otherAddress!: AztecAddress;
   blacklistedAddress!: AztecAddress;
 
+  private testName: string;
+
   constructor(testName: string) {
-    this.logger = createLogger(`e2e:e2e_blacklist_token_contract:${testName}`);
+    super();
+    this.testName = testName;
   }
 
   async crossTimestampOfChange() {
-    await this.cheatCodes.warpL2TimeAtLeastBy(
-      this.sequencer,
-      this.aztecNode,
-      BlacklistTokenContractTest.CHANGE_ROLES_DELAY,
-    );
+    await this.markProvenAndWarp(BlacklistTokenContractTest.CHANGE_ROLES_DELAY);
   }
 
   /**
@@ -81,46 +76,38 @@ export class BlacklistTokenContractTest {
    * 2. Publicly deploy accounts, deploy token contract and a "bad account".
    */
   async applyBaseSetup() {
-    // Adding a timeout of 2 minutes in here such that it is propagated to the underlying tests
-    jest.setTimeout(120_000);
-
-    this.logger.info('Deploying 3 accounts');
-    const { deployedAccounts } = await deployAccounts(
-      3,
-      this.logger,
-    )({
-      wallet: this.context.wallet,
-      initialFundedAccounts: this.context.initialFundedAccounts,
-    });
+    // Bumped from 2 min: pipelined cadence (~24s/dependent-tx) makes the 3-account deploy plus token/bad-account/
+    // proxy deploys exceed the original window.
+    jest.setTimeout(600_000);
 
     this.cheatCodes = this.context.cheatCodes;
     this.aztecNode = this.context.aztecNodeService;
     this.sequencer = this.context.sequencer!;
     this.wallet = this.context.wallet;
-    this.adminAddress = deployedAccounts[0].address;
-    this.otherAddress = deployedAccounts[1].address;
-    this.blacklistedAddress = deployedAccounts[2].address;
+    [this.adminAddress, this.otherAddress, this.blacklistedAddress] = this.context.accounts;
 
     this.logger.info('Setting up blacklist token contract');
-    // Create the token contract state.
-    this.logger.verbose(`Public deploy accounts...`);
-    await publicDeployAccounts(this.wallet, [this.adminAddress, this.otherAddress, this.blacklistedAddress]);
+    await ensureAuthRegistryPublished(this.wallet, this.adminAddress);
 
     this.logger.verbose(`Deploying TokenContract...`);
-    this.asset = await TokenBlacklistContract.deploy(this.wallet, this.adminAddress).send({
+    ({ contract: this.asset } = await TokenBlacklistContract.deploy(this.wallet, this.adminAddress).send({
       from: this.adminAddress,
-    });
+    }));
     this.logger.verbose(`Token deployed to ${this.asset.address}`);
 
     this.logger.verbose(`Deploying bad account...`);
-    this.badAccount = await InvalidAccountContract.deploy(this.wallet).send({ from: this.adminAddress });
+    ({ contract: this.badAccount } = await InvalidAccountContract.deploy(this.wallet).send({
+      from: this.adminAddress,
+    }));
     this.logger.verbose(`Deployed to ${this.badAccount.address}.`);
 
     // Deploy a proxy contract for "on behalf of other" tests. The note owner must be the tx sender
     // (so their notes are in scope), but msg_sender in the target must differ from the note owner
     // to trigger authwit validation. The proxy forwards calls so that msg_sender != tx sender.
     this.logger.verbose(`Deploying generic proxy...`);
-    this.authwitProxy = await GenericProxyContract.deploy(this.wallet).send({ from: this.adminAddress });
+    ({ contract: this.authwitProxy } = await GenericProxyContract.deploy(this.wallet).send({
+      from: this.adminAddress,
+    }));
     this.logger.verbose(`Deployed to ${this.authwitProxy.address}.`);
 
     await this.crossTimestampOfChange();
@@ -133,24 +120,18 @@ export class BlacklistTokenContractTest {
       [this.adminAddress, this.otherAddress, this.blacklistedAddress],
     );
 
-    expect(await this.asset.methods.get_roles(this.adminAddress).simulate({ from: this.adminAddress })).toEqual(
-      new Role().withAdmin().toNoirStruct(),
-    );
+    expect(
+      (await this.asset.methods.get_roles(this.adminAddress).simulate({ from: this.adminAddress })).result,
+    ).toEqual(new Role().withAdmin().toNoirStruct());
   }
 
-  async setup() {
-    this.logger.info('Setting up fresh context');
-    this.context = await setup(0, {
-      fundSponsoredFPC: true,
-      skipAccountDeployment: true,
-    });
+  override async setup(opts: AutomineTestOpts = {}) {
+    await super.setup({ numberOfAccounts: 3, ...opts });
+    // hydrateFromContext repoints `this.logger` at the context logger; restore the harness-named one.
+    this.logger = createLogger(`e2e:automine:blacklist:${this.testName}`);
     await this.applyBaseSetup();
   }
 
-  async teardown() {
-    await teardown(this.context);
-  }
-
   async addPendingShieldNoteToPXE(
     contract: TokenBlacklistContract,
     recipient: AztecAddress,
@@ -189,9 +170,9 @@ export class BlacklistTokenContractTest {
 
     await this.crossTimestampOfChange();
 
-    expect(await this.asset.methods.get_roles(this.adminAddress).simulate({ from: this.adminAddress })).toEqual(
-      adminMinterRole.toNoirStruct(),
-    );
+    expect(
+      (await this.asset.methods.get_roles(this.adminAddress).simulate({ from: this.adminAddress })).result,
+    ).toEqual(adminMinterRole.toNoirStruct());
 
     this.logger.verbose(`Minting ${amount} publicly...`);
     await asset.methods.mint_public(this.adminAddress, amount).send({ from: this.adminAddress });
@@ -199,7 +180,7 @@ export class BlacklistTokenContractTest {
     this.logger.verbose(`Minting ${amount} privately...`);
     const secret = Fr.random();
     const secretHash = await computeSecretHash(secret);
-    const receipt = await asset.methods.mint_private(amount, secretHash).send({ from: this.adminAddress });
+    const { receipt } = await asset.methods.mint_private(amount, secretHash).send({ from: this.adminAddress });
 
     await this.addPendingShieldNoteToPXE(asset, this.adminAddress, amount, secretHash, receipt.txHash);
     await asset.methods.redeem_shield(this.adminAddress, amount, secret).send({ from: this.adminAddress });
@@ -207,20 +188,20 @@ export class BlacklistTokenContractTest {
 
     tokenSim.mintPublic(this.adminAddress, amount);
 
-    const publicBalance = await asset.methods
+    const { result: publicBalance } = await asset.methods
       .balance_of_public(this.adminAddress)
       .simulate({ from: this.adminAddress });
     this.logger.verbose(`Public balance of wallet 0: ${publicBalance}`);
     expect(publicBalance).toEqual(this.tokenSim.balanceOfPublic(this.adminAddress));
 
     tokenSim.mintPrivate(this.adminAddress, amount);
-    const privateBalance = await asset.methods
+    const { result: privateBalance } = await asset.methods
       .balance_of_private(this.adminAddress)
       .simulate({ from: this.adminAddress });
     this.logger.verbose(`Private balance of wallet 0: ${privateBalance}`);
     expect(privateBalance).toEqual(tokenSim.balanceOfPrivate(this.adminAddress));
 
-    const totalSupply = await asset.methods.total_supply().simulate({ from: this.adminAddress });
+    const { result: totalSupply } = await asset.methods.total_supply().simulate({ from: this.adminAddress });
     this.logger.verbose(`Total supply: ${totalSupply}`);
     expect(totalSupply).toEqual(tokenSim.totalSupply);
   }

package/src/{e2e_token_contract → automine/token}/token_contract_test.ts

@@ -1,5 +1,5 @@
 import { AztecAddress } from '@aztec/aztec.js/addresses';
-import { type Logger, createLogger } from '@aztec/aztec.js/log';
+import { createLogger } from '@aztec/aztec.js/log';
 import type { AztecNode } from '@aztec/aztec.js/node';
 import { TokenContract } from '@aztec/noir-contracts.js/Token';
 import { GenericProxyContract } from '@aztec/noir-test-contracts.js/GenericProxy';
@@ -7,19 +7,23 @@ import { InvalidAccountContract } from '@aztec/noir-test-contracts.js/InvalidAcc
 
 import { jest } from '@jest/globals';
 
-import { type EndToEndContext, deployAccounts, publicDeployAccounts, setup, teardown } from '../fixtures/setup.js';
-import { mintTokensToPrivate } from '../fixtures/token_utils.js';
-import { TokenSimulator } from '../simulators/token_simulator.js';
-import type { TestWallet } from '../test-wallet/test_wallet.js';
+import { ensureAuthRegistryPublished } from '../../fixtures/setup.js';
+import { mintTokensToPrivate } from '../../fixtures/token_utils.js';
+import { TokenSimulator } from '../../simulators/token_simulator.js';
+import { AutomineTestContext, type AutomineTestOpts } from '../automine_test_context.js';
 
 const { METRICS_PORT: metricsPort } = process.env;
 
-export class TokenContractTest {
+/**
+ * Token-domain harness over the automine topology: extends {@link AutomineTestContext} with a
+ * {@link TokenSimulator}, the USDC Token deploy plus a bad-account and authwit proxy, and an optional
+ * mint. Base setup is opt-in via {@link applyBaseSnapshots} (run during `setup()`); {@link applyMint}
+ * is called explicitly after `setup()`.
+ */
+export class TokenContractTest extends AutomineTestContext {
   static TOKEN_NAME = 'USDC';
   static TOKEN_SYMBOL = 'USD';
   static TOKEN_DECIMALS = 18n;
-  context!: EndToEndContext;
-  logger: Logger;
   metricsPort?: number;
   asset!: TokenContract;
   tokenSim!: TokenSimulator;
@@ -27,16 +31,16 @@ export class TokenContractTest {
 
   badAccount!: InvalidAccountContract;
   authwitProxy!: GenericProxyContract;
-  wallet!: TestWallet;
   adminAddress!: AztecAddress;
-  account1Address!: AztecAddress;
+  otherAddress!: AztecAddress;
   account2Address!: AztecAddress;
 
   private shouldApplyBaseSetup = false;
-  private shouldApplyMint = false;
+  private testName: string;
 
   constructor(testName: string) {
-    this.logger = createLogger(`e2e:e2e_token_contract:${testName}`);
+    super();
+    this.testName = testName;
     this.metricsPort = metricsPort ? parseInt(metricsPort) : undefined;
   }
 
@@ -48,14 +52,6 @@ export class TokenContractTest {
     this.shouldApplyBaseSetup = true;
   }
 
-  /**
-   * Registers that mint should be applied during setup().
-   * Call this before setup() to mint tokens to the admin account.
-   */
-  applyMintSnapshot() {
-    this.shouldApplyMint = true;
-  }
-
   /**
    * Applies base setup: deploys 3 accounts, publicly deploys accounts, token contract and a "bad account".
    */
@@ -63,75 +59,60 @@ export class TokenContractTest {
     // Adding a timeout of 2 minutes in here such that it is propagated to the underlying tests
     jest.setTimeout(120_000);
 
-    this.logger.info('Applying base setup - deploying 3 accounts');
-    const { deployedAccounts } = await deployAccounts(
-      3,
-      this.logger,
-    )({
-      wallet: this.context.wallet,
-      initialFundedAccounts: this.context.initialFundedAccounts,
-    });
-
     this.node = this.context.aztecNodeService;
     this.wallet = this.context.wallet;
-    [this.adminAddress, this.account1Address, this.account2Address] = deployedAccounts.map(acc => acc.address);
+    [this.adminAddress, this.otherAddress, this.account2Address] = this.context.accounts;
 
     this.logger.info('Applying base setup - deploying token contract');
-    this.logger.verbose(`Public deploy accounts...`);
-    await publicDeployAccounts(this.wallet, [this.adminAddress, this.account1Address]);
+    await ensureAuthRegistryPublished(this.wallet, this.adminAddress);
 
     this.logger.verbose(`Deploying TokenContract...`);
-    this.asset = await TokenContract.deploy(
+    ({ contract: this.asset } = await TokenContract.deploy(
       this.wallet,
       this.adminAddress,
       TokenContractTest.TOKEN_NAME,
       TokenContractTest.TOKEN_SYMBOL,
       TokenContractTest.TOKEN_DECIMALS,
-    ).send({ from: this.adminAddress });
+    ).send({ from: this.adminAddress }));
     this.logger.verbose(`Token deployed to ${this.asset.address}`);
 
     this.logger.verbose(`Deploying bad account...`);
-    this.badAccount = await InvalidAccountContract.deploy(this.wallet).send({ from: this.adminAddress });
+    ({ contract: this.badAccount } = await InvalidAccountContract.deploy(this.wallet).send({
+      from: this.adminAddress,
+    }));
     this.logger.verbose(`Deployed to ${this.badAccount.address}.`);
 
     // Deploy a proxy contract for "on behalf of other" tests. The note owner must be the tx sender
     // (so their notes are in scope), but msg_sender in the target must differ from the note owner
     // to trigger authwit validation. The proxy forwards calls so that msg_sender != tx sender.
     this.logger.verbose(`Deploying generic proxy...`);
-    this.authwitProxy = await GenericProxyContract.deploy(this.wallet).send({ from: this.adminAddress });
+    ({ contract: this.authwitProxy } = await GenericProxyContract.deploy(this.wallet).send({
+      from: this.adminAddress,
+    }));
     this.logger.verbose(`Deployed to ${this.authwitProxy.address}.`);
 
     this.tokenSim = new TokenSimulator(this.asset, this.wallet, this.adminAddress, this.logger, [
       this.adminAddress,
-      this.account1Address,
+      this.otherAddress,
     ]);
 
-    expect(await this.asset.methods.get_admin().simulate({ from: this.adminAddress })).toBe(
+    expect((await this.asset.methods.get_admin().simulate({ from: this.adminAddress })).result).toBe(
       this.adminAddress.toBigInt(),
     );
   }
 
-  async setup() {
-    this.context = await setup(0, {
-      metricsPort: this.metricsPort,
-      fundSponsoredFPC: true,
-      skipAccountDeployment: true,
-    });
+  override async setup(opts: AutomineTestOpts = {}) {
+    await super.setup({ numberOfAccounts: 3, metricsPort: this.metricsPort, ...opts });
+    // hydrateFromContext repoints `this.logger` at the context logger; restore the harness-named one.
+    this.logger = createLogger(`e2e:automine:token:${this.testName}`);
 
     if (this.shouldApplyBaseSetup) {
       await this.applyBaseSetup();
     }
-
-    if (this.shouldApplyMint) {
-      await this.applyMint();
-    }
-  }
-
-  async teardown() {
-    await teardown(this.context);
   }
 
-  private async applyMint() {
+  /** Mints an initial public and private balance to the admin account. Call after {@link setup}. */
+  async applyMint() {
     this.logger.info('Applying mint setup');
     const { asset, adminAddress, tokenSim } = this;
     const amount = 10000n;
@@ -140,7 +121,9 @@ export class TokenContractTest {
     await asset.methods.mint_to_public(adminAddress, amount).send({ from: adminAddress });
     tokenSim.mintPublic(adminAddress, amount);
 
-    const publicBalance = await asset.methods.balance_of_public(adminAddress).simulate({ from: adminAddress });
+    const { result: publicBalance } = await asset.methods
+      .balance_of_public(adminAddress)
+      .simulate({ from: adminAddress });
     this.logger.verbose(`Public balance of wallet 0: ${publicBalance}`);
     expect(publicBalance).toEqual(this.tokenSim.balanceOfPublic(adminAddress));
 
@@ -148,11 +131,13 @@ export class TokenContractTest {
     await mintTokensToPrivate(asset, adminAddress, adminAddress, amount);
     tokenSim.mintPrivate(adminAddress, amount);
 
-    const privateBalance = await asset.methods.balance_of_private(adminAddress).simulate({ from: adminAddress });
+    const { result: privateBalance } = await asset.methods
+      .balance_of_private(adminAddress)
+      .simulate({ from: adminAddress });
     this.logger.verbose(`Private balance of wallet 0: ${privateBalance}`);
     expect(privateBalance).toEqual(tokenSim.balanceOfPrivate(adminAddress));
 
-    const totalSupply = await asset.methods.total_supply().simulate({ from: adminAddress });
+    const { result: totalSupply } = await asset.methods.total_supply().simulate({ from: adminAddress });
     this.logger.verbose(`Total supply: ${totalSupply}`);
     expect(totalSupply).toEqual(tokenSim.totalSupply);
 

package/src/automine/token/token_test_helpers.ts

@@ -0,0 +1,138 @@
+import type { AztecAddress } from '@aztec/aztec.js/addresses';
+import type { ContractFunctionInteraction } from '@aztec/aztec.js/contracts';
+import type { Logger } from '@aztec/aztec.js/log';
+import type { Wallet } from '@aztec/aztec.js/wallet';
+import { AMMContract } from '@aztec/noir-contracts.js/AMM';
+import type { GenericProxyContract } from '@aztec/noir-test-contracts.js/GenericProxy';
+
+import { sendThroughAuthwitProxy } from '../../fixtures/authwit_proxy.js';
+import { DUPLICATE_NULLIFIER_ERROR } from '../../fixtures/fixtures.js';
+import { type AnyTokenContract, mintTokensToPrivate } from '../../fixtures/token_utils.js';
+import type { TestWallet } from '../../test-wallet/test_wallet.js';
+
+/** Whether an amount / balance is read from the private or public balance of the token. */
+export type BalanceKind = 'private' | 'public';
+
+/** The invalid-authwit-nonce assertion the contract raises when `from == msg_sender` but nonce != 0. */
+export const INVALID_AUTHWIT_NONCE_ERROR =
+  "Assertion failed: Invalid authwit nonce. When 'from' and 'msg_sender' are the same, 'authwit_nonce' must be zero";
+
+/** Minimal token shape needed to read balances — satisfied structurally by Token/TestToken/TokenBlacklist. */
+export interface BalanceReadable {
+  methods: {
+    balance_of_private(owner: AztecAddress): { simulate(opts: { from: AztecAddress }): Promise<{ result: bigint }> };
+    balance_of_public(owner: AztecAddress): { simulate(opts: { from: AztecAddress }): Promise<{ result: bigint }> };
+  };
+}
+
+/** Reads the private or public balance of an account, simulating from that account's own scope. */
+export async function balanceOf(asset: BalanceReadable, kind: BalanceKind, account: AztecAddress): Promise<bigint> {
+  const interaction =
+    kind === 'private' ? asset.methods.balance_of_private(account) : asset.methods.balance_of_public(account);
+  return (await interaction.simulate({ from: account })).result;
+}
+
+/** Returns half of an account's balance, asserting it is non-zero so the operation under test is meaningful. */
+export async function halfBalanceOf(asset: BalanceReadable, kind: BalanceKind, owner: AztecAddress): Promise<bigint> {
+  const amount = (await balanceOf(asset, kind, owner)) / 2n;
+  expect(amount).toBeGreaterThan(0n);
+  return amount;
+}
+
+/** Returns an amount just above an account's balance (balance + delta), asserting it is non-zero. */
+export async function amountAboveBalance(
+  asset: BalanceReadable,
+  kind: BalanceKind,
+  owner: AztecAddress,
+  delta = 1n,
+): Promise<bigint> {
+  const amount = (await balanceOf(asset, kind, owner)) + delta;
+  expect(amount).toBeGreaterThan(0n);
+  return amount;
+}
+
+/**
+ * Grants a public authwit for `caller` to run `action` on behalf of `owner`, executes it from `caller`,
+ * then asserts a replay of the same call reverts as unauthorized (the authwit is single-use).
+ *
+ * `onExecuted` runs after the successful execution (before the replay attempt) so callers can update
+ * their {@link TokenSimulator} to match the state change the executed action produced.
+ */
+export async function assertPublicAuthwitReplayRejected(
+  wallet: TestWallet,
+  owner: AztecAddress,
+  action: ContractFunctionInteraction,
+  caller: AztecAddress,
+  onExecuted?: () => void,
+): Promise<void> {
+  const grant = await wallet.setPublicAuthWit(owner, { caller, action }, true);
+  await grant.send();
+
+  await action.send({ from: caller });
+  onExecuted?.();
+
+  await expect(action.simulate({ from: caller })).rejects.toThrow(/unauthorized/);
+}
+
+/**
+ * Creates a private authwit for `owner`, executes `action` through the authwit proxy (so `msg_sender`
+ * differs from the note owner), then asserts a replay reverts with a duplicate-nullifier error.
+ *
+ * `onExecuted` runs after the successful execution (before the replay attempt) so callers can update
+ * their {@link TokenSimulator} to match the state change the executed action produced.
+ */
+export async function assertAuthwitProxyReplayRejected(
+  proxy: GenericProxyContract,
+  wallet: TestWallet,
+  owner: AztecAddress,
+  action: ContractFunctionInteraction,
+  onExecuted?: () => void,
+): Promise<void> {
+  const witness = await wallet.createAuthWit(owner, { caller: proxy.address, action });
+
+  await sendThroughAuthwitProxy(proxy, action, { from: owner, authWitnesses: [witness] });
+  onExecuted?.();
+
+  await expect(sendThroughAuthwitProxy(proxy, action, { from: owner, authWitnesses: [witness] })).rejects.toThrow(
+    DUPLICATE_NULLIFIER_ERROR,
+  );
+}
+
+/**
+ * Deploys an {@link AMMContract} over three freshly deployed tokens (token0, token1, and the liquidity
+ * token), makes the AMM the liquidity token's minter, and mints `initialBalance` of token0 and token1 to
+ * each liquidity provider plus token0 to the swapper. `deploy` selects the token flavour (Token vs
+ * TestToken), so the concrete token type flows through to the caller.
+ */
+export async function deployAmmWithTokens<T extends AnyTokenContract>(
+  wallet: Wallet,
+  admin: AztecAddress,
+  deploy: (wallet: Wallet, admin: AztecAddress, initialBalance: bigint, logger: Logger) => Promise<{ contract: T }>,
+  opts: { liquidityProviders: AztecAddress[]; swapper: AztecAddress; initialBalance: bigint; logger: Logger },
+): Promise<{ token0: T; token1: T; liquidityToken: T; amm: AMMContract }> {
+  const { liquidityProviders, swapper, initialBalance, logger } = opts;
+
+  const { contract: token0 } = await deploy(wallet, admin, 0n, logger);
+  const { contract: token1 } = await deploy(wallet, admin, 0n, logger);
+  const { contract: liquidityToken } = await deploy(wallet, admin, 0n, logger);
+
+  const { contract: amm } = await AMMContract.deploy(
+    wallet,
+    token0.address,
+    token1.address,
+    liquidityToken.address,
+  ).send({ from: admin });
+
+  // TODO(#9480): consider deploying the token by some factory when the AMM is deployed, and making the AMM be the
+  // minter there.
+  await liquidityToken.methods.set_minter(amm.address, true).send({ from: admin });
+
+  for (const lp of liquidityProviders) {
+    await mintTokensToPrivate(token0, admin, lp, initialBalance);
+    await mintTokensToPrivate(token1, admin, lp, initialBalance);
+  }
+  // Note that the swapper only holds token0, not token1.
+  await mintTokensToPrivate(token0, admin, swapper, initialBalance);
+
+  return { token0, token1, liquidityToken, amm };
+}

package/src/bench/client_flows/benchmark.ts

@@ -5,6 +5,7 @@ import {
   type ProfileInteractionOptions,
 } from '@aztec/aztec.js/contracts';
 import type { Logger } from '@aztec/aztec.js/log';
+import { MAX_APPS_PER_KERNEL } from '@aztec/constants';
 import { createLogger } from '@aztec/foundation/log';
 import { type PrivateExecutionStep, serializePrivateExecutionSteps } from '@aztec/stdlib/kernel';
 import type {
@@ -320,6 +321,26 @@ export function convertProfileToGHBenchmark(benchmark: ClientFlowBenchmark): Git
   return benches;
 }
 
+/**
+ * Computes the expected number of `PrivateExecutionStep` entries the orchestrator will produce
+ * for a tx with `apps` private function calls.
+ *
+ * Step layout: `apps` app circuits + kernel iterations + 1 final reset + 1 tail + 1 hiding kernel.
+ * Each kernel iteration absorbs up to `MAX_APPS_PER_KERNEL` apps via the `init_K` / `inner_K`
+ * variants, so the kernel count is `ceil(apps / MAX_APPS_PER_KERNEL)`.
+ *
+ * Caveat: this assumes no mid-flow reset is triggered, which would split a batch into two kernels
+ * separated by a reset. For the flows currently exercised in this benchmark suite that holds, but
+ * a future flow that grows large enough to overflow per-tx limits before consuming all apps will
+ * not match this formula.
+ */
+export function expectedExecutionSteps(apps: number): number {
+  const kernels = Math.ceil(apps / MAX_APPS_PER_KERNEL);
+  // The final reset and tail are proved as a single circuit (reset_tail or reset_tail_to_public),
+  // so they share one execution step.
+  return apps + kernels + 1 /* reset+tail */ + 1 /* hiding */;
+}
+
 export async function captureProfile(
   label: string,
   interaction: ContractFunctionInteraction | DeployMethod,