@aztec/end-to-end 0.0.1-commit.3469e52 → 0.0.1-commit.350e0a4d

package/src/bench/client_flows/client_flows_benchmark.ts

@@ -1,10 +1,11 @@
+import { NO_FROM } from '@aztec/aztec.js/account';
 import { AztecAddress } from '@aztec/aztec.js/addresses';
 import { FeeJuicePaymentMethodWithClaim } from '@aztec/aztec.js/fee';
 import { type FeePaymentMethod, PrivateFeePaymentMethod, SponsoredFeePaymentMethod } from '@aztec/aztec.js/fee';
 import { type Logger, createLogger } from '@aztec/aztec.js/log';
 import type { AztecNode } from '@aztec/aztec.js/node';
 import type { Wallet } from '@aztec/aztec.js/wallet';
-import { CheatCodes } from '@aztec/aztec/testing';
+import { CheatCodes, getTokenAllowedSetupFunctions } from '@aztec/aztec/testing';
 import { createExtendedL1Client } from '@aztec/ethereum/client';
 import { RollupContract } from '@aztec/ethereum/contracts';
 import type { DeployAztecL1ContractsArgs } from '@aztec/ethereum/deploy-aztec-l1-contracts';
@@ -19,17 +20,22 @@ import { AMMContract } from '@aztec/noir-contracts.js/AMM';
 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, TokenContract } from '@aztec/noir-contracts.js/Token';
+import { TestTokenContract as BananaCoin, TestTokenContract } from '@aztec/noir-test-contracts.js/TestToken';
 import { ProtocolContractAddress } from '@aztec/protocol-contracts';
 import { getCanonicalFeeJuice } from '@aztec/protocol-contracts/fee-juice';
 import { type PXEConfig, getPXEConfig } from '@aztec/pxe/server';
 import type { ContractInstanceWithAddress } from '@aztec/stdlib/contract';
-import { GasSettings } from '@aztec/stdlib/gas';
+import { Gas, GasSettings } from '@aztec/stdlib/gas';
 import { deriveSigningKey } from '@aztec/stdlib/keys';
-import { TestWallet } from '@aztec/test-wallet/server';
+import { AppTaggingSecretKind } from '@aztec/stdlib/logs';
 
-import { MNEMONIC } from '../../fixtures/fixtures.js';
-import { type EndToEndContext, type SetupOptions, deployAccounts, setup, teardown } from '../../fixtures/setup.js';
+import {
+  AUTOMINE_E2E_OPTS,
+  L1_DIRECT_WRITE_ACCOUNT_INDEX,
+  MNEMONIC,
+  getPaddedMaxFeesPerGas,
+} from '../../fixtures/fixtures.js';
+import { type EndToEndContext, type SetupOptions, setup, teardown } from '../../fixtures/setup.js';
 import { mintTokensToPrivate } from '../../fixtures/token_utils.js';
 import { setupSponsoredFPC } from '../../fixtures/utils.js';
 import { CrossChainTestHarness } from '../../shared/cross_chain_test_harness.js';
@@ -37,6 +43,7 @@ import {
   FeeJuicePortalTestingHarnessFactory,
   type GasBridgingTestHarness,
 } from '../../shared/gas_portal_test_harness.js';
+import { TestWallet } from '../../test-wallet/test_wallet.js';
 import { ProxyLogger } from './benchmark.js';
 import { type ClientFlowsConfig, FULL_FLOWS_CONFIG, KEY_FLOWS_CONFIG } from './config.js';
 
@@ -70,13 +77,13 @@ export class ClientFlowsBenchmark {
   public bananaFPC!: FPCContract;
   public bananaFPCInstance!: ContractInstanceWithAddress;
   // Random asset we want to trade
-  public candyBarCoin!: TokenContract;
+  public candyBarCoin!: TestTokenContract;
   public candyBarCoinInstance!: ContractInstanceWithAddress;
   // AMM contract
   public amm!: AMMContract;
   public ammInstance!: ContractInstanceWithAddress;
   // Liquidity token for AMM
-  public liquidityToken!: TokenContract;
+  public liquidityToken!: TestTokenContract;
   public liquidityTokenInstance!: ContractInstanceWithAddress;
   // Sponsored FPC contract
   public sponsoredFPC!: SponsoredFPCContract;
@@ -87,33 +94,35 @@ export class ClientFlowsBenchmark {
 
   public realProofs = ['true', '1'].includes(process.env.REAL_PROOFS ?? '');
 
-  public paymentMethods: Record<BenchmarkingFeePaymentMethod, { forWallet: FeePaymentMethodGetter; circuits: number }> =
-    {
-      // eslint-disable-next-line camelcase
-      bridged_fee_juice: {
-        forWallet: this.getBridgedFeeJuicePaymentMethodForWallet.bind(this),
-        circuits: 2, // FeeJuice claim + kernel inner
-      },
-      // eslint-disable-next-line camelcase
-      private_fpc: {
-        forWallet: this.getPrivateFPCPaymentMethodForWallet.bind(this),
-        circuits:
-          2 + // FPC entrypoint + kernel inner
-          2 + // BananaCoin transfer_to_public + kernel inner
-          2 + // Account verify_private_authwit + kernel inner
-          2, // BananaCoin prepare_private_balance_increase + kernel inner
-      },
-      // eslint-disable-next-line camelcase
-      sponsored_fpc: {
-        forWallet: this.getSponsoredFPCPaymentMethodForWallet.bind(this),
-        circuits: 2, // Sponsored FPC sponsor_unconditionally + kernel inner
-      },
-      // eslint-disable-next-line camelcase
-      fee_juice: {
-        forWallet: () => Promise.resolve(undefined),
-        circuits: 0,
-      },
-    };
+  // `apps` is the number of private function calls contributed by this payment method.
+  // Each app produces one execution step at proving time; the orchestrator additionally produces
+  // one kernel step per batch of N apps (see `expectedExecutionSteps` in `benchmark.ts`).
+  public paymentMethods: Record<BenchmarkingFeePaymentMethod, { forWallet: FeePaymentMethodGetter; apps: number }> = {
+    // eslint-disable-next-line camelcase
+    bridged_fee_juice: {
+      forWallet: this.getBridgedFeeJuicePaymentMethodForWallet.bind(this),
+      apps: 1, // FeeJuice claim
+    },
+    // eslint-disable-next-line camelcase
+    private_fpc: {
+      forWallet: this.getPrivateFPCPaymentMethodForWallet.bind(this),
+      apps:
+        1 + // FPC entrypoint
+        1 + // BananaCoin transfer_to_public
+        1 + // Account verify_private_authwit
+        1, // BananaCoin prepare_private_balance_increase
+    },
+    // eslint-disable-next-line camelcase
+    sponsored_fpc: {
+      forWallet: this.getSponsoredFPCPaymentMethodForWallet.bind(this),
+      apps: 1, // Sponsored FPC sponsor_unconditionally
+    },
+    // eslint-disable-next-line camelcase
+    fee_juice: {
+      forWallet: () => Promise.resolve(undefined),
+      apps: 0,
+    },
+  };
 
   public config: ClientFlowsConfig;
 
@@ -122,7 +131,7 @@ export class ClientFlowsBenchmark {
 
   constructor(testName?: string, setupOptions: Partial<SetupOptions & DeployAztecL1ContractsArgs> = {}) {
     this.logger = createLogger(`bench:client_flows${testName ? `:${testName}` : ''}`);
-    this.setupOptions = { startProverNode: true, ...setupOptions };
+    this.setupOptions = { ...AUTOMINE_E2E_OPTS, startProverNode: true, ...setupOptions };
     this.config = BENCHMARK_CONFIG === 'key_flows' ? KEY_FLOWS_CONFIG : FULL_FLOWS_CONFIG;
     ProxyLogger.create();
     this.proxyLogger = ProxyLogger.getInstance();
@@ -130,24 +139,28 @@ export class ClientFlowsBenchmark {
 
   async setup() {
     this.logger.info('Setting up subsystems from fresh');
-    this.context = await setup(0, {
+    // Token allowlist entries are test-only: FPC-based fee payment with custom tokens won't work on mainnet alpha.
+    // BananaCoin is the codegen'd TestToken here, so the allowlist must key on its class, not canonical Token's.
+    const tokenAllowList = await getTokenAllowedSetupFunctions(BananaCoin.artifact);
+    this.context = await setup(2, {
       ...this.setupOptions,
       fundSponsoredFPC: true,
-      skipAccountDeployment: true,
       l1ContractsArgs: this.setupOptions,
+      txPublicSetupAllowListExtend: [...(this.setupOptions.txPublicSetupAllowListExtend ?? []), ...tokenAllowList],
     });
     await this.applyBaseSetup();
 
-    await this.context.aztecNodeService!.setConfig({ feeRecipient: this.sequencerAddress, coinbase: this.coinbase });
+    await this.context.aztecNodeService.setConfig({ feeRecipient: this.sequencerAddress, coinbase: this.coinbase });
 
     const rollupContract = RollupContract.getFromConfig(this.context.config);
-    this.chainMonitor = new ChainMonitor(rollupContract, this.context.dateProvider!, this.logger, 200).start();
+    this.chainMonitor = new ChainMonitor(rollupContract, this.context.dateProvider, this.logger, 200).start();
 
     return this;
   }
 
   async teardown() {
     await this.chainMonitor.stop();
+    await this.userWallet?.stop();
     await teardown(this.context);
   }
 
@@ -156,21 +169,20 @@ export class ClientFlowsBenchmark {
     const { claimSecret: secret, messageLeafIndex: index } = claim;
     await this.feeJuiceContract.methods
       .claim(address, claim.claimAmount, secret, index)
-      .send({ from: this.adminAddress })
-      .wait();
+      .send({ from: this.adminAddress });
   }
 
   /** Admin mints bananaCoin tokens privately to the target address and redeems them. */
   async mintPrivateBananas(amount: bigint, address: AztecAddress) {
-    const balanceBefore = await this.bananaCoin.methods
+    const { result: balanceBefore } = await this.bananaCoin.methods
       .balance_of_private(address)
-      .simulate({ from: this.adminAddress });
+      .simulate({ from: address });
 
     await mintTokensToPrivate(this.bananaCoin, this.adminAddress, address, amount);
 
-    const balanceAfter = await this.bananaCoin.methods
+    const { result: balanceAfter } = await this.bananaCoin.methods
       .balance_of_private(address)
-      .simulate({ from: this.adminAddress });
+      .simulate({ from: address });
     expect(balanceAfter).toEqual(balanceBefore + amount);
   }
 
@@ -197,18 +209,10 @@ export class ClientFlowsBenchmark {
 
   async applyInitialAccounts() {
     this.logger.info('Applying initial accounts setup');
-    const { deployedAccounts } = await deployAccounts(
-      2,
-      this.logger,
-    )({
-      wallet: this.context.wallet,
-      initialFundedAccounts: this.context.initialFundedAccounts,
-    });
-
-    const [{ address: adminAddress }, { address: sequencerAddress }] = deployedAccounts;
+    const [adminAddress, sequencerAddress] = this.context.accounts;
 
     this.adminWallet = this.context.wallet;
-    this.aztecNode = this.context.aztecNodeService!;
+    this.aztecNode = this.context.aztecNodeService;
     this.cheatCodes = this.context.cheatCodes;
 
     this.adminAddress = adminAddress;
@@ -228,6 +232,19 @@ export class ClientFlowsBenchmark {
       loggers: {
         prover: this.proxyLogger.createLogger('pxe:bb:wasm:bundle:proxied'),
       },
+      // The benchmark measures steady-state app cost, not first-send discovery cost. Reproduce the pre-handshake-default
+      // behavior of unconstrained delivery: derive the tagging secret from the (sender, recipient) key pair via ECDH
+      // instead of taking the current default (a non-interactive handshake, which injects two extra private app
+      // executions and a nullifier per cold chain). Constrained delivery is unaffected: the Noir circuit rejects
+      // address-derived for constrained, so the hook falls through to a handshake there.
+      hooks: {
+        resolveTaggingSecretStrategy: ({ deliveryMode }) =>
+          Promise.resolve(
+            deliveryMode === AppTaggingSecretKind.UNCONSTRAINED
+              ? { type: 'address-derived' }
+              : { type: 'non-interactive-handshake' },
+          ),
+      },
     });
   }
 
@@ -236,9 +253,17 @@ export class ClientFlowsBenchmark {
     this.feeJuiceContract = FeeJuiceContract.at(ProtocolContractAddress.FeeJuice, this.adminWallet);
 
     this.feeJuiceBridgeTestHarness = await FeeJuicePortalTestingHarnessFactory.create({
-      aztecNode: this.context.aztecNodeService!,
-      aztecNodeAdmin: this.context.aztecNodeService!,
-      l1Client: this.context.deployL1ContractsValues.l1Client,
+      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.adminWallet,
       logger: this.logger,
     });
@@ -252,9 +277,9 @@ export class ClientFlowsBenchmark {
       'BC',
       'BC',
       18n,
-    )
-      .send({ from: this.adminAddress })
-      .wait();
+    ).send({
+      from: this.adminAddress,
+    });
     this.logger.info(`BananaCoin deployed at ${bananaCoin.address}`);
     this.bananaCoin = bananaCoin;
     this.bananaCoinInstance = bananaCoinInstance;
@@ -262,15 +287,15 @@ export class ClientFlowsBenchmark {
 
   async applyDeployCandyBarToken() {
     this.logger.info('Applying candy bar token deployment');
-    const { contract: candyBarCoin, instance: candyBarCoinInstance } = await TokenContract.deploy(
+    const { contract: candyBarCoin, instance: candyBarCoinInstance } = await TestTokenContract.deploy(
       this.adminWallet,
       this.adminAddress,
       'CBC',
       'CBC',
       18n,
-    )
-      .send({ from: this.adminAddress })
-      .wait();
+    ).send({
+      from: this.adminAddress,
+    });
     this.logger.info(`CandyBarCoin deployed at ${candyBarCoin.address}`);
     this.candyBarCoin = candyBarCoin;
     this.candyBarCoinInstance = candyBarCoinInstance;
@@ -286,9 +311,9 @@ export class ClientFlowsBenchmark {
       this.adminWallet,
       bananaCoin.address,
       this.adminAddress,
-    )
-      .send({ from: this.adminAddress })
-      .wait();
+    ).send({
+      from: this.adminAddress,
+    });
 
     this.logger.info(`BananaPay deployed at ${bananaFPC.address}`);
 
@@ -332,20 +357,17 @@ export class ClientFlowsBenchmark {
 
   public async createAndFundBenchmarkingAccountOnUserWallet(accountType: AccountType) {
     const benchysAccountManager = await this.createBenchmarkingAccountManager(this.adminWallet, accountType);
-    const benchysAccount = await benchysAccountManager.getAccount();
     const benchysAddress = benchysAccountManager.address;
     const claim = await this.feeJuiceBridgeTestHarness.prepareTokensOnL1(benchysAddress);
     const behchysDeployMethod = await benchysAccountManager.getDeployMethod();
-    await behchysDeployMethod
-      .send({
-        from: AztecAddress.ZERO,
-        fee: { paymentMethod: new FeeJuicePaymentMethodWithClaim(benchysAddress, claim) },
-      })
-      .wait();
+    await behchysDeployMethod.send({
+      from: NO_FROM,
+      fee: { paymentMethod: new FeeJuicePaymentMethodWithClaim(benchysAddress, claim) },
+    });
     // Register benchy on the user's Wallet, where we're going to be interacting from
     const accountManager = await this.userWallet.createAccount({
-      secret: benchysAccount.getSecretKey(),
-      salt: new Fr(benchysAccount.salt),
+      secret: benchysAccountManager.getSecretKey(),
+      salt: new Fr(benchysAccountManager.getInstance().salt),
       contract: benchysAccountManager.getAccountContract(),
     });
     return accountManager.address;
@@ -353,25 +375,23 @@ export class ClientFlowsBenchmark {
 
   public async applyDeployAmm() {
     this.logger.info('Applying AMM deployment');
-    const { contract: liquidityToken, instance: liquidityTokenInstance } = await TokenContract.deploy(
+    const { contract: liquidityToken, instance: liquidityTokenInstance } = await TestTokenContract.deploy(
       this.adminWallet,
       this.adminAddress,
       'LPT',
       'LPT',
       18n,
-    )
-      .send({ from: this.adminAddress })
-      .wait();
+    ).send({
+      from: this.adminAddress,
+    });
     const { contract: amm, instance: ammInstance } = await AMMContract.deploy(
       this.adminWallet,
       this.bananaCoin.address,
       this.candyBarCoin.address,
       liquidityToken.address,
-    )
-      .send({ from: this.adminAddress })
-      .wait();
+    ).send({ from: this.adminAddress });
     this.logger.info(`AMM deployed at ${amm.address}`);
-    await liquidityToken.methods.set_minter(amm.address, true).send({ from: this.adminAddress }).wait();
+    await liquidityToken.methods.set_minter(amm.address, true).send({ from: this.adminAddress });
     this.liquidityToken = liquidityToken;
     this.liquidityTokenInstance = liquidityTokenInstance;
     this.amm = amm;
@@ -386,8 +406,9 @@ export class ClientFlowsBenchmark {
   public async getPrivateFPCPaymentMethodForWallet(wallet: Wallet, sender: AztecAddress) {
     // The private fee paying method assembled on the app side requires knowledge of the maximum
     // fee the user is willing to pay
-    const maxFeesPerGas = (await this.aztecNode.getCurrentMinFees()).mul(1.5);
-    const gasSettings = GasSettings.default({ maxFeesPerGas });
+    const maxFeesPerGas = await getPaddedMaxFeesPerGas(this.aztecNode);
+    const gasLimits = Gas.from((await this.aztecNode.getNodeInfo()).txsLimits.gas);
+    const gasSettings = GasSettings.fallback({ gasLimits, maxFeesPerGas });
     return new PrivateFeePaymentMethod(this.bananaFPC.address, sender, wallet, gasSettings);
   }
 

package/src/bench/client_flows/config.ts

@@ -6,7 +6,7 @@ export type ClientFlowConfig = {
   recursions?: number[];
 };
 
-type ClientFlows = 'accountDeployments' | 'deployments' | 'transfers' | 'bridging' | 'amm';
+type ClientFlows = 'accountDeployments' | 'deployments' | 'transfers' | 'bridging' | 'amm' | 'storageProof';
 
 export type ClientFlowsConfig = {
   [key in ClientFlows]: ClientFlowConfig;
@@ -34,6 +34,10 @@ export const KEY_FLOWS_CONFIG: ClientFlowsConfig = {
     feePaymentMethods: ['sponsored_fpc', 'private_fpc'],
     recursions: [0, 1],
   },
+  storageProof: {
+    accounts: ['ecdsar1'],
+    feePaymentMethods: ['sponsored_fpc'],
+  },
 };
 
 export const FULL_FLOWS_CONFIG: ClientFlowsConfig = {
@@ -58,4 +62,8 @@ export const FULL_FLOWS_CONFIG: ClientFlowsConfig = {
     feePaymentMethods: ['sponsored_fpc', 'private_fpc'],
     recursions: [0, 1, 2],
   },
+  storageProof: {
+    accounts: ['ecdsar1', 'schnorr'],
+    feePaymentMethods: ['sponsored_fpc', 'private_fpc'],
+  },
 };

package/src/bench/client_flows/data_extractor.ts

@@ -51,6 +51,7 @@ async function main() {
       // TODO(AD) do we still want to take this from witness.json?
       witness: witnessStack[i],
       vk: stepsFromFile[i].vk,
+      kind: stepsFromFile[i].kind,
       timings: {
         witgen: step.timings.witgen,
         gateCount: step.timings.gateCount,

package/src/bench/utils.ts

@@ -1,18 +1,28 @@
 import type { AztecNodeService } from '@aztec/aztec-node';
 import { AztecAddress } from '@aztec/aztec.js/addresses';
-import { BatchCall, type SentTx, type WaitOpts } from '@aztec/aztec.js/contracts';
+import { BatchCall, NO_WAIT, type WaitOpts } from '@aztec/aztec.js/contracts';
+import { waitForTx } from '@aztec/aztec.js/node';
+import { SlotNumber } from '@aztec/foundation/branded-types';
 import { mean, stdDev, times } from '@aztec/foundation/collection';
 import { BenchmarkingContract } from '@aztec/noir-test-contracts.js/Benchmarking';
+import { type Sequencer, type SequencerEvents, SequencerState } from '@aztec/sequencer-client';
+import type { TxHash } from '@aztec/stdlib/tx';
 import type { MetricDefinition } from '@aztec/telemetry-client';
 import type { BenchmarkDataPoint, BenchmarkMetricsType, BenchmarkTelemetryClient } from '@aztec/telemetry-client/bench';
 
 import { mkdirSync, writeFileSync } from 'fs';
 import path from 'path';
 
+import { PIPELINING_SETUP_OPTS } from '../fixtures/fixtures.js';
 import { type EndToEndContext, type SetupOptions, setup } from '../fixtures/utils.js';
 
+const MAX_BENCH_WAIT_BLOCKS = 6;
+const BENCH_FINAL_WAIT_TIMEOUT_SECONDS = 10;
+const SEQUENCER_IDLE_TIMEOUT_MS = 60_000;
+const DEFAULT_L1_PUBLISHING_TIME_SECONDS = 12;
+
 /**
- * Setup for benchmarks. Initializes a remote node with a single account and deploys a benchmark contract.
+ * Setup for benchmarks. Initializes a remote node with a funded hardcoded account and deploys a benchmark contract.
  */
 export async function benchmarkSetup(
   opts: Partial<SetupOptions> & {
@@ -21,12 +31,20 @@ export async function benchmarkSetup(
     benchOutput?: string;
   },
 ) {
-  const context = await setup(1, { ...opts, telemetryConfig: { benchmark: true } });
-  const defaultAccountAddress = context.accounts[0];
-  const contract = await BenchmarkingContract.deploy(context.wallet).send({ from: defaultAccountAddress }).deployed();
+  const context = await setup(1, {
+    ...PIPELINING_SETUP_OPTS,
+    ...opts,
+    telemetryConfig: { benchmark: true },
+  });
+  const [defaultAccountAddress] = context.accounts;
+  const sequencer = getSequencerClient(context);
+  await waitForSequencerIdle(sequencer.getSequencer());
+  const deployment = BenchmarkingContract.deploy(context.wallet);
+  const { txHash } = await deployment.send({ from: defaultAccountAddress, wait: NO_WAIT });
+  await waitTxs([txHash], context);
+  const contract = await deployment.register();
   context.logger.info(`Deployed benchmarking contract at ${contract.address}`);
-  const sequencer = (context.aztecNode as AztecNodeService).getSequencer()!;
-  const telemetry = context.telemetryClient! as BenchmarkTelemetryClient;
+  const telemetry = context.telemetryClient as BenchmarkTelemetryClient;
   context.logger.warn(`Cleared benchmark data points from setup`);
   telemetry.clear();
   const origTeardown = context.teardown.bind(context);
@@ -46,6 +64,14 @@ export async function benchmarkSetup(
   return { telemetry, context, contract, sequencer };
 }
 
+function getSequencerClient(context: EndToEndContext) {
+  const sequencer = (context.aztecNode as AztecNodeService).getSequencer();
+  if (!sequencer) {
+    throw new Error('Benchmark setup requires a local sequencer');
+  }
+  return sequencer;
+}
+
 type MetricFilter = {
   source: MetricDefinition;
   transform: (value: number) => number;
@@ -142,18 +168,103 @@ export async function sendTxs(
   context: EndToEndContext,
   contract: BenchmarkingContract,
   heavyPublicCompute: boolean = false,
-): Promise<SentTx[]> {
+): Promise<TxHash[]> {
   const calls = await Promise.all(times(txCount, index => makeCall(index, context, contract, heavyPublicCompute)));
   context.logger.info(`Creating ${txCount} txs`);
   const [from] = context.accounts;
   context.logger.info(`Sending ${txCount} txs`);
-  return calls.map(call => call.send({ from }));
+  return Promise.all(
+    calls.map(async call => {
+      const { txHash } = await call.send({ from, wait: NO_WAIT });
+      return txHash;
+    }),
+  );
 }
 
-export async function waitTxs(txs: SentTx[], context: EndToEndContext, txWaitOpts?: WaitOpts) {
+export async function waitTxs(txs: TxHash[], context: EndToEndContext, txWaitOpts?: WaitOpts) {
   context.logger.info(`Awaiting ${txs.length} txs to be mined`);
-  await Promise.all(txs.map(tx => tx.wait(txWaitOpts)));
-  context.logger.info(`All ${txs.length} txs have been mined`);
+  await waitTxsWithBlockMining(txs, context, txWaitOpts);
+  context.logger.info(`${txs.length} txs have been mined`);
+}
+
+async function waitTxsWithBlockMining(txs: TxHash[], context: EndToEndContext, txWaitOpts?: WaitOpts) {
+  const sequencer = getSequencerClient(context).getSequencer();
+  for (let attempt = 0; attempt <= MAX_BENCH_WAIT_BLOCKS; attempt++) {
+    if (await haveAllTxsMined(txs, context, txWaitOpts)) {
+      await waitForSequencerIdle(sequencer);
+      return;
+    }
+    await waitForSequencerIdle(sequencer);
+    context.logger.info('Mining next benchmark block while waiting for txs', {
+      attempt,
+      txs: txs.length,
+    });
+    await mineNextBenchmarkBlock(context, sequencer);
+  }
+  await Promise.all(
+    txs.map(txHash =>
+      waitForTx(context.aztecNode, txHash, {
+        ...txWaitOpts,
+        timeout: txWaitOpts?.timeout ?? BENCH_FINAL_WAIT_TIMEOUT_SECONDS,
+      }),
+    ),
+  );
+}
+
+async function haveAllTxsMined(txs: TxHash[], context: EndToEndContext, txWaitOpts?: WaitOpts): Promise<boolean> {
+  const receipts = await Promise.all(txs.map(txHash => context.aztecNode.getTxReceipt(txHash)));
+  for (const receipt of receipts) {
+    if (receipt.isDropped()) {
+      throw new Error(`Transaction ${receipt.txHash.toString()} was dropped. Reason: ${receipt.error ?? 'unknown'}`);
+    }
+    if (!receipt.isMined()) {
+      return false;
+    }
+    if (!receipt.hasExecutionSucceeded() && !txWaitOpts?.dontThrowOnRevert) {
+      throw new Error(
+        `Transaction ${receipt.txHash.toString()} reverted: ${receipt.executionResult}. Reason: ${
+          receipt.error ?? 'unknown'
+        }`,
+      );
+    }
+  }
+  return true;
+}
+
+async function mineNextBenchmarkBlock(context: EndToEndContext, sequencer: Sequencer) {
+  const l1PublishingTime = BigInt(context.config.l1PublishingTime ?? DEFAULT_L1_PUBLISHING_TIME_SECONDS);
+  const currentTimestamp = BigInt(await context.cheatCodes.eth.lastBlockTimestamp());
+  let targetSlot = SlotNumber((await context.cheatCodes.rollup.getSlot()) + 1);
+  let targetTimestamp = await context.cheatCodes.rollup.getTimestampForSlot(targetSlot);
+  while (targetTimestamp - l1PublishingTime - 1n <= currentTimestamp) {
+    targetSlot = SlotNumber(targetSlot + 1);
+    targetTimestamp = await context.cheatCodes.rollup.getTimestampForSlot(targetSlot);
+  }
+
+  const triggerTimestamp = targetTimestamp - l1PublishingTime - 1n;
+  await context.cheatCodes.eth.warp(triggerTimestamp, { resetBlockInterval: true });
+  await context.aztecNode.mineBlock();
+  await waitForSequencerIdle(sequencer);
+}
+
+function waitForSequencerIdle(sequencer: Sequencer, timeout = SEQUENCER_IDLE_TIMEOUT_MS): Promise<void> {
+  if (sequencer.status().state === SequencerState.IDLE) {
+    return Promise.resolve();
+  }
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => {
+      sequencer.off('state-changed', handler);
+      reject(new Error('Timeout waiting for sequencer IDLE state'));
+    }, timeout);
+    const handler = (args: Parameters<SequencerEvents['state-changed']>[0]) => {
+      if (args.newState === SequencerState.IDLE) {
+        clearTimeout(timer);
+        sequencer.off('state-changed', handler);
+        resolve();
+      }
+    };
+    sequencer.on('state-changed', handler);
+  });
 }
 
 function randomBytesAsBigInts(length: number): bigint[] {