@aztec/end-to-end 0.0.1-commit.a89ec08 → 0.0.1-commit.aa0c64f

package/src/bench/client_flows/client_flows_benchmark.ts

@@ -13,6 +13,7 @@ import { deployL1Contract } from '@aztec/ethereum/deploy-l1-contract';
 import { ChainMonitor } from '@aztec/ethereum/test';
 import { randomBytes } from '@aztec/foundation/crypto/random';
 import { Fr } from '@aztec/foundation/curves/bn254';
+import { GrumpkinScalar } from '@aztec/foundation/curves/grumpkin';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { TestERC20Abi } from '@aztec/l1-artifacts/TestERC20Abi';
 import { TestERC20Bytecode } from '@aztec/l1-artifacts/TestERC20Bytecode';
@@ -20,16 +21,21 @@ 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 { deriveSigningKey } from '@aztec/stdlib/keys';
+import { Gas, GasSettings } from '@aztec/stdlib/gas';
+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';
@@ -71,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;
@@ -88,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;
 
@@ -123,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();
@@ -132,11 +140,11 @@ export class ClientFlowsBenchmark {
   async setup() {
     this.logger.info('Setting up subsystems from fresh');
     // Token allowlist entries are test-only: FPC-based fee payment with custom tokens won't work on mainnet alpha.
-    const tokenAllowList = await getTokenAllowedSetupFunctions();
-    this.context = await setup(0, {
+    // 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],
     });
@@ -152,6 +160,7 @@ export class ClientFlowsBenchmark {
 
   async teardown() {
     await this.chainMonitor.stop();
+    await this.userWallet?.stop();
     await teardown(this.context);
   }
 
@@ -183,7 +192,7 @@ export class ClientFlowsBenchmark {
 
     let benchysPrivateSigningKey;
     if (type === 'schnorr') {
-      benchysPrivateSigningKey = deriveSigningKey(benchysSecret);
+      benchysPrivateSigningKey = GrumpkinScalar.random();
       return wallet.createSchnorrAccount(benchysSecret, salt, benchysPrivateSigningKey);
     } else if (type === 'ecdsar1') {
       benchysPrivateSigningKey = randomBytes(32);
@@ -200,15 +209,7 @@ 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;
@@ -231,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' },
+          ),
+      },
     });
   }
 
@@ -241,7 +255,15 @@ export class ClientFlowsBenchmark {
     this.feeJuiceBridgeTestHarness = await FeeJuicePortalTestingHarnessFactory.create({
       aztecNode: this.context.aztecNodeService,
       aztecNodeAdmin: this.context.aztecNodeService,
-      l1Client: this.context.deployL1ContractsValues.l1Client,
+      // 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,
     });
@@ -249,11 +271,14 @@ export class ClientFlowsBenchmark {
 
   async applyDeployBananaToken() {
     this.logger.info('Applying banana token deployment');
-    const {
-      receipt: { contract: bananaCoin, instance: bananaCoinInstance },
-    } = await BananaCoin.deploy(this.adminWallet, this.adminAddress, 'BC', 'BC', 18n).send({
+    const { contract: bananaCoin, instance: bananaCoinInstance } = await BananaCoin.deploy(
+      this.adminWallet,
+      this.adminAddress,
+      'BC',
+      'BC',
+      18n,
+    ).send({
       from: this.adminAddress,
-      wait: { returnReceipt: true },
     });
     this.logger.info(`BananaCoin deployed at ${bananaCoin.address}`);
     this.bananaCoin = bananaCoin;
@@ -262,11 +287,14 @@ export class ClientFlowsBenchmark {
 
   async applyDeployCandyBarToken() {
     this.logger.info('Applying candy bar token deployment');
-    const {
-      receipt: { contract: candyBarCoin, instance: candyBarCoinInstance },
-    } = await TokenContract.deploy(this.adminWallet, this.adminAddress, 'CBC', 'CBC', 18n).send({
+    const { contract: candyBarCoin, instance: candyBarCoinInstance } = await TestTokenContract.deploy(
+      this.adminWallet,
+      this.adminAddress,
+      'CBC',
+      'CBC',
+      18n,
+    ).send({
       from: this.adminAddress,
-      wait: { returnReceipt: true },
     });
     this.logger.info(`CandyBarCoin deployed at ${candyBarCoin.address}`);
     this.candyBarCoin = candyBarCoin;
@@ -279,11 +307,12 @@ export class ClientFlowsBenchmark {
     expect((await this.context.wallet.getContractMetadata(feeJuiceContract.address)).isContractPublished).toBe(true);
 
     const bananaCoin = this.bananaCoin;
-    const {
-      receipt: { contract: bananaFPC, instance: bananaFPCInstance },
-    } = await FPCContract.deploy(this.adminWallet, bananaCoin.address, this.adminAddress).send({
+    const { contract: bananaFPC, instance: bananaFPCInstance } = await FPCContract.deploy(
+      this.adminWallet,
+      bananaCoin.address,
+      this.adminAddress,
+    ).send({
       from: this.adminAddress,
-      wait: { returnReceipt: true },
     });
 
     this.logger.info(`BananaPay deployed at ${bananaFPC.address}`);
@@ -328,7 +357,6 @@ 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();
@@ -338,8 +366,8 @@ export class ClientFlowsBenchmark {
     });
     // 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;
@@ -347,20 +375,21 @@ export class ClientFlowsBenchmark {
 
   public async applyDeployAmm() {
     this.logger.info('Applying AMM deployment');
-    const {
-      receipt: { contract: liquidityToken, instance: liquidityTokenInstance },
-    } = await TokenContract.deploy(this.adminWallet, this.adminAddress, 'LPT', 'LPT', 18n).send({
+    const { contract: liquidityToken, instance: liquidityTokenInstance } = await TestTokenContract.deploy(
+      this.adminWallet,
+      this.adminAddress,
+      'LPT',
+      'LPT',
+      18n,
+    ).send({
       from: this.adminAddress,
-      wait: { returnReceipt: true },
     });
-    const {
-      receipt: { contract: amm, instance: ammInstance },
-    } = await AMMContract.deploy(
+    const { contract: amm, instance: ammInstance } = await AMMContract.deploy(
       this.adminWallet,
       this.bananaCoin.address,
       this.candyBarCoin.address,
       liquidityToken.address,
-    ).send({ from: this.adminAddress, wait: { returnReceipt: true } });
+    ).send({ from: this.adminAddress });
     this.logger.info(`AMM deployed at ${amm.address}`);
     await liquidityToken.methods.set_minter(amm.address, true).send({ from: this.adminAddress });
     this.liquidityToken = liquidityToken;
@@ -377,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.fallback({ 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/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

@@ -2,8 +2,10 @@ import type { AztecNodeService } from '@aztec/aztec-node';
 import { AztecAddress } from '@aztec/aztec.js/addresses';
 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';
@@ -11,10 +13,16 @@ import type { BenchmarkDataPoint, BenchmarkMetricsType, BenchmarkTelemetryClient
 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> & {
@@ -23,11 +31,19 @@ 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 });
+  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;
   context.logger.warn(`Cleared benchmark data points from setup`);
   telemetry.clear();
@@ -48,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;
@@ -159,10 +183,90 @@ export async function sendTxs(
 
 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(txHash => waitForTx(context.aztecNode, txHash, txWaitOpts)));
+  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[] {
   return [...Array(length)].map(_ => BigInt(Math.floor(Math.random() * 255)));
 }