@aztec/end-to-end 0.82.2 → 0.82.3-nightly.20250403

package/src/bench/client_flows/client_flows_benchmark.ts

@@ -0,0 +1,395 @@
+import { EcdsaRAccountContractArtifact, getEcdsaRAccount } from '@aztec/accounts/ecdsa';
+import { SchnorrAccountContractArtifact, getSchnorrAccount, getSchnorrWallet } from '@aztec/accounts/schnorr';
+import {
+  type AccountWallet,
+  AztecAddress,
+  type AztecNode,
+  FeeJuicePaymentMethodWithClaim,
+  type FeePaymentMethod,
+  type Logger,
+  type PXE,
+  PrivateFeePaymentMethod,
+  SponsoredFeePaymentMethod,
+  type Wallet,
+  createLogger,
+} from '@aztec/aztec.js';
+import { CheatCodes } from '@aztec/aztec.js/testing';
+import { FEE_FUNDING_FOR_TESTER_ACCOUNT } from '@aztec/constants';
+import { type DeployL1ContractsArgs, RollupContract, createL1Clients, deployL1Contract } from '@aztec/ethereum';
+import { ChainMonitor } from '@aztec/ethereum/test';
+import { randomBytes } from '@aztec/foundation/crypto';
+import { EthAddress } from '@aztec/foundation/eth-address';
+import { Fr } from '@aztec/foundation/fields';
+import { TestERC20Abi } from '@aztec/l1-artifacts/TestERC20Abi';
+import { TestERC20Bytecode } from '@aztec/l1-artifacts/TestERC20Bytecode';
+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 { ProtocolContractAddress } from '@aztec/protocol-contracts';
+import { getCanonicalFeeJuice } from '@aztec/protocol-contracts/fee-juice';
+import { type PXEServiceConfig, createPXEService, getPXEServiceConfig } from '@aztec/pxe/server';
+import { deriveSigningKey } from '@aztec/stdlib/keys';
+
+import { MNEMONIC } from '../../fixtures/fixtures.js';
+import {
+  type ISnapshotManager,
+  type SubsystemsContext,
+  createSnapshotManager,
+  deployAccounts,
+} from '../../fixtures/snapshot_manager.js';
+import { mintTokensToPrivate } from '../../fixtures/token_utils.js';
+import { type SetupOptions, setupSponsoredFPC } from '../../fixtures/utils.js';
+import { CrossChainTestHarness } from '../../shared/cross_chain_test_harness.js';
+import {
+  FeeJuicePortalTestingHarnessFactory,
+  type GasBridgingTestHarness,
+} from '../../shared/gas_portal_test_harness.js';
+import { type ClientFlowsConfig, FULL_FLOWS_CONFIG, KEY_FLOWS_CONFIG } from './config.js';
+
+const { E2E_DATA_PATH: dataPath, BENCHMARK_CONFIG } = process.env;
+
+export type AccountType = 'ecdsar1' | 'schnorr';
+export type FeePaymentMethodGetter = (wallet: Wallet) => Promise<FeePaymentMethod>;
+export type BenchmarkingFeePaymentMethod = 'bridged_fee_juice' | 'private_fpc' | 'sponsored_fpc';
+
+export class ClientFlowsBenchmark {
+  private snapshotManager: ISnapshotManager;
+
+  public logger: Logger;
+  public pxe!: PXE;
+  public aztecNode!: AztecNode;
+  public cheatCodes!: CheatCodes;
+  public context!: SubsystemsContext;
+  public chainMonitor!: ChainMonitor;
+  public feeJuiceBridgeTestHarness!: GasBridgingTestHarness;
+
+  // The admin that aids in the setup of the test
+  public adminWallet!: AccountWallet;
+  public adminAddress!: AztecAddress;
+
+  // Aztec Node config
+  public sequencerAddress!: AztecAddress;
+  public coinbase!: EthAddress;
+
+  // Contracts
+  public feeJuiceContract!: FeeJuiceContract;
+  // Asset in which fees are paid via FPC
+  public bananaCoin!: BananaCoin;
+  public bananaFPC!: FPCContract;
+  // Random asset we want to trade
+  public candyBarCoin!: TokenContract;
+  // AMM contract
+  public amm!: AMMContract;
+  // Liquidity token for AMM
+  public liquidityToken!: TokenContract;
+  // Sponsored FPC contract
+  public sponsoredFPC!: SponsoredFPCContract;
+
+  // PXE used by the benchmarking user. It can be set up with client-side proving enabled
+  public userPXE!: PXE;
+
+  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
+      },
+    };
+
+  public config: ClientFlowsConfig;
+
+  constructor(testName?: string, setupOptions: Partial<SetupOptions & DeployL1ContractsArgs> = {}) {
+    this.logger = createLogger(`bench:client_flows${testName ? `:${testName}` : ''}`);
+    this.snapshotManager = createSnapshotManager(
+      `bench_client_flows${testName ? `/${testName}` : ''}`,
+      dataPath,
+      { startProverNode: true, ...setupOptions },
+      { ...setupOptions },
+    );
+    this.config = BENCHMARK_CONFIG === 'key_flows' ? KEY_FLOWS_CONFIG : FULL_FLOWS_CONFIG;
+  }
+
+  async setup() {
+    const context = await this.snapshotManager.setup();
+    await context.aztecNode.setConfig({ feeRecipient: this.sequencerAddress, coinbase: this.coinbase });
+
+    const rollupContract = RollupContract.getFromConfig(context.aztecNodeConfig);
+    this.chainMonitor = new ChainMonitor(rollupContract, this.logger, 200).start();
+
+    return this;
+  }
+
+  async teardown() {
+    this.chainMonitor.stop();
+    await this.snapshotManager.teardown();
+  }
+
+  async mintAndBridgeFeeJuice(address: AztecAddress, amount: bigint) {
+    const claim = await this.feeJuiceBridgeTestHarness.prepareTokensOnL1(amount, address);
+    const { claimSecret: secret, messageLeafIndex: index } = claim;
+    await this.feeJuiceContract.methods.claim(address, amount, secret, index).send().wait();
+  }
+
+  /** Admin mints bananaCoin tokens privately to the target address and redeems them. */
+  async mintPrivateBananas(amount: bigint, address: AztecAddress) {
+    const balanceBefore = await this.bananaCoin.methods.balance_of_private(address).simulate();
+
+    await mintTokensToPrivate(this.bananaCoin, this.adminWallet, address, amount);
+
+    const balanceAfter = await this.bananaCoin.methods.balance_of_private(address).simulate();
+    expect(balanceAfter).toEqual(balanceBefore + amount);
+  }
+
+  async createBenchmarkingAccountManager(type: 'ecdsar1' | 'schnorr') {
+    const benchysSecretKey = Fr.random();
+    const salt = Fr.random();
+
+    let benchysPrivateSigningKey;
+    let benchysAccountManager;
+    if (type === 'schnorr') {
+      benchysPrivateSigningKey = deriveSigningKey(benchysSecretKey);
+      benchysAccountManager = await getSchnorrAccount(this.userPXE, benchysSecretKey, benchysPrivateSigningKey, salt);
+    } else if (type === 'ecdsar1') {
+      benchysPrivateSigningKey = randomBytes(32);
+      benchysAccountManager = await getEcdsaRAccount(this.userPXE, benchysSecretKey, benchysPrivateSigningKey, salt);
+    } else {
+      throw new Error(`Unknown account type: ${type}`);
+    }
+    await benchysAccountManager.register();
+    return benchysAccountManager;
+  }
+
+  public async applyBaseSnapshots() {
+    await this.applyInitialAccountsSnapshot();
+    await this.applySetupFeeJuiceSnapshot();
+  }
+
+  async applyInitialAccountsSnapshot() {
+    await this.snapshotManager.snapshot(
+      'initial_accounts',
+      deployAccounts(2, this.logger),
+      async ({ deployedAccounts }, { pxe, aztecNode, aztecNodeConfig }) => {
+        this.pxe = pxe;
+
+        this.aztecNode = aztecNode;
+        this.cheatCodes = await CheatCodes.create(aztecNodeConfig.l1RpcUrls, pxe);
+
+        const deployedWallets = await Promise.all(
+          deployedAccounts.map(a => getSchnorrWallet(pxe, a.address, a.signingKey)),
+        );
+        [this.adminWallet] = deployedWallets;
+        this.adminAddress = this.adminWallet.getAddress();
+        this.sequencerAddress = deployedWallets[1].getAddress();
+
+        const canonicalFeeJuice = await getCanonicalFeeJuice();
+        this.feeJuiceContract = await FeeJuiceContract.at(canonicalFeeJuice.address, this.adminWallet);
+        this.coinbase = EthAddress.random();
+
+        const userPXEConfig = getPXEServiceConfig();
+        const l1Contracts = await aztecNode.getL1ContractAddresses();
+        const userPXEConfigWithContracts = {
+          ...userPXEConfig,
+          proverEnabled: ['true', '1'].includes(process.env.REAL_PROOFS ?? ''),
+          l1Contracts,
+        } as PXEServiceConfig;
+
+        this.userPXE = await createPXEService(this.aztecNode, userPXEConfigWithContracts, 'pxe-user');
+      },
+    );
+  }
+
+  async applySetupFeeJuiceSnapshot() {
+    await this.snapshotManager.snapshot(
+      'setup_fee_juice',
+      async () => {},
+      async (_data, context) => {
+        this.context = context;
+
+        this.feeJuiceContract = await FeeJuiceContract.at(ProtocolContractAddress.FeeJuice, this.adminWallet);
+
+        this.feeJuiceBridgeTestHarness = await FeeJuicePortalTestingHarnessFactory.create({
+          aztecNode: context.aztecNode,
+          aztecNodeAdmin: context.aztecNode,
+          pxeService: context.pxe,
+          publicClient: context.deployL1ContractsValues.publicClient,
+          walletClient: context.deployL1ContractsValues.walletClient,
+          wallet: this.adminWallet,
+          logger: this.logger,
+        });
+      },
+    );
+  }
+
+  async applyDeployBananaTokenSnapshot() {
+    await this.snapshotManager.snapshot(
+      'deploy_banana_token',
+      async () => {
+        const bananaCoin = await BananaCoin.deploy(this.adminWallet, this.adminAddress, 'BC', 'BC', 18n)
+          .send()
+          .deployed();
+        this.logger.info(`BananaCoin deployed at ${bananaCoin.address}`);
+        return { bananaCoinAddress: bananaCoin.address };
+      },
+      async ({ bananaCoinAddress }) => {
+        this.bananaCoin = await BananaCoin.at(bananaCoinAddress, this.adminWallet);
+      },
+    );
+  }
+
+  async applyDeployCandyBarTokenSnapshot() {
+    await this.snapshotManager.snapshot(
+      'deploy_candy_bar_token',
+      async () => {
+        const candyBarCoin = await TokenContract.deploy(this.adminWallet, this.adminAddress, 'CBC', 'CBC', 18n)
+          .send()
+          .deployed();
+        this.logger.info(`CandyBarCoin deployed at ${candyBarCoin.address}`);
+        return { candyBarCoinAddress: candyBarCoin.address };
+      },
+      async ({ candyBarCoinAddress }) => {
+        this.candyBarCoin = await TokenContract.at(candyBarCoinAddress, this.adminWallet);
+      },
+    );
+  }
+
+  public async applyFPCSetupSnapshot() {
+    await this.snapshotManager.snapshot(
+      'fpc_setup',
+      async context => {
+        const feeJuiceContract = this.feeJuiceBridgeTestHarness.feeJuice;
+        expect((await context.pxe.getContractMetadata(feeJuiceContract.address)).isContractPubliclyDeployed).toBe(true);
+
+        const bananaCoin = this.bananaCoin;
+        const bananaFPC = await FPCContract.deploy(this.adminWallet, bananaCoin.address, this.adminAddress)
+          .send()
+          .deployed();
+
+        this.logger.info(`BananaPay deployed at ${bananaFPC.address}`);
+
+        await this.feeJuiceBridgeTestHarness.bridgeFromL1ToL2(FEE_FUNDING_FOR_TESTER_ACCOUNT, bananaFPC.address);
+
+        return { bananaFPCAddress: bananaFPC.address };
+      },
+      async data => {
+        this.bananaFPC = await FPCContract.at(data.bananaFPCAddress, this.adminWallet);
+      },
+    );
+  }
+
+  async applyDeploySponsoredFPCSnapshot() {
+    await this.snapshotManager.snapshot(
+      'deploy_sponsored_fpc',
+      async () => {
+        const sponsoredFPC = await setupSponsoredFPC(this.pxe);
+        this.logger.info(`SponsoredFPC deployed at ${sponsoredFPC.address}`);
+        return { sponsoredFPCAddress: sponsoredFPC.address };
+      },
+      async ({ sponsoredFPCAddress }) => {
+        this.sponsoredFPC = await SponsoredFPCContract.at(sponsoredFPCAddress, this.adminWallet);
+      },
+    );
+  }
+
+  public async createCrossChainTestHarness(owner: AccountWallet) {
+    const { publicClient, walletClient } = createL1Clients(this.context.aztecNodeConfig.l1RpcUrls, MNEMONIC);
+
+    const underlyingERC20Address = await deployL1Contract(walletClient, publicClient, TestERC20Abi, TestERC20Bytecode, [
+      'Underlying',
+      'UND',
+      walletClient.account.address,
+    ]).then(({ address }) => address);
+
+    this.logger.verbose(`Setting up cross chain harness...`);
+    const crossChainTestHarness = await CrossChainTestHarness.new(
+      this.aztecNode,
+      this.pxe,
+      publicClient,
+      walletClient,
+      owner,
+      this.logger,
+      underlyingERC20Address,
+    );
+
+    this.logger.verbose(`L2 token deployed to: ${crossChainTestHarness.l2Token.address}`);
+
+    return crossChainTestHarness;
+  }
+
+  public async createAndFundBenchmarkingWallet(accountType: AccountType) {
+    const benchysAccountManager = await this.createBenchmarkingAccountManager(accountType);
+    const benchysWallet = await benchysAccountManager.getWallet();
+    const benchysAddress = benchysAccountManager.getAddress();
+    const claim = await this.feeJuiceBridgeTestHarness.prepareTokensOnL1(
+      FEE_FUNDING_FOR_TESTER_ACCOUNT,
+      benchysAddress,
+    );
+    const paymentMethod = new FeeJuicePaymentMethodWithClaim(benchysWallet, claim);
+    await benchysAccountManager.deploy({ fee: { paymentMethod } }).wait();
+    // Register benchy on admin's PXE so we can check its balances
+    await this.pxe.registerContract({
+      instance: benchysAccountManager.getInstance(),
+      artifact: accountType === 'ecdsar1' ? EcdsaRAccountContractArtifact : SchnorrAccountContractArtifact,
+    });
+    await this.pxe.registerAccount(benchysWallet.getSecretKey(), benchysWallet.getCompleteAddress().partialAddress);
+    return benchysWallet;
+  }
+
+  public async applyDeployAmmSnapshot() {
+    await this.snapshotManager.snapshot(
+      'deploy_amm',
+      async () => {
+        const liquidityToken = await TokenContract.deploy(this.adminWallet, this.adminAddress, 'LPT', 'LPT', 18n)
+          .send()
+          .deployed();
+        const amm = await AMMContract.deploy(
+          this.adminWallet,
+          this.bananaCoin.address,
+          this.candyBarCoin.address,
+          liquidityToken.address,
+        )
+          .send()
+          .deployed();
+        this.logger.info(`AMM deployed at ${amm.address}`);
+        await liquidityToken.methods.set_minter(amm.address, true).send().wait();
+        return { ammAddress: amm.address, liquidityTokenAddress: liquidityToken.address };
+      },
+      async ({ ammAddress, liquidityTokenAddress }) => {
+        this.liquidityToken = await TokenContract.at(liquidityTokenAddress, this.adminWallet);
+        this.amm = await AMMContract.at(ammAddress, this.adminWallet);
+      },
+    );
+  }
+
+  public async getBridgedFeeJuicePaymentMethodForWallet(wallet: Wallet) {
+    const claim = await this.feeJuiceBridgeTestHarness.prepareTokensOnL1(
+      FEE_FUNDING_FOR_TESTER_ACCOUNT,
+      wallet.getAddress(),
+    );
+    return new FeeJuicePaymentMethodWithClaim(wallet, claim);
+  }
+
+  public getPrivateFPCPaymentMethodForWallet(wallet: Wallet) {
+    return Promise.resolve(new PrivateFeePaymentMethod(this.bananaFPC.address, wallet));
+  }
+
+  public getSponsoredFPCPaymentMethodForWallet(_wallet: Wallet) {
+    return Promise.resolve(new SponsoredFeePaymentMethod(this.sponsoredFPC.address));
+  }
+}

package/src/bench/client_flows/config.ts

@@ -0,0 +1,53 @@
+import type { AccountType, BenchmarkingFeePaymentMethod } from './client_flows_benchmark.js';
+
+export type ClientFlowConfig = {
+  accounts: AccountType[];
+  feePaymentMethods: BenchmarkingFeePaymentMethod[];
+  recursions?: number[];
+};
+
+type ClientFlows = 'deployments' | 'transfers' | 'bridging' | 'amm';
+
+export type ClientFlowsConfig = {
+  [key in ClientFlows]: ClientFlowConfig;
+};
+
+export const KEY_FLOWS_CONFIG: ClientFlowsConfig = {
+  deployments: {
+    accounts: ['ecdsar1', 'schnorr'],
+    feePaymentMethods: ['sponsored_fpc'],
+  },
+  amm: {
+    accounts: ['ecdsar1'],
+    feePaymentMethods: ['sponsored_fpc'],
+  },
+  bridging: {
+    accounts: ['ecdsar1'],
+    feePaymentMethods: ['sponsored_fpc'],
+  },
+  transfers: {
+    accounts: ['ecdsar1'],
+    feePaymentMethods: ['sponsored_fpc'],
+    recursions: [1],
+  },
+};
+
+export const FULL_FLOWS_CONFIG: ClientFlowsConfig = {
+  deployments: {
+    accounts: ['ecdsar1', 'schnorr'],
+    feePaymentMethods: ['bridged_fee_juice', 'sponsored_fpc'],
+  },
+  amm: {
+    accounts: ['ecdsar1', 'schnorr'],
+    feePaymentMethods: ['sponsored_fpc', 'private_fpc'],
+  },
+  bridging: {
+    accounts: ['ecdsar1', 'schnorr'],
+    feePaymentMethods: ['sponsored_fpc', 'private_fpc'],
+  },
+  transfers: {
+    accounts: ['ecdsar1', 'schnorr'],
+    feePaymentMethods: ['sponsored_fpc', 'private_fpc'],
+    recursions: [0, 1, 2],
+  },
+};

package/src/bench/client_flows/data_extractor.ts

@@ -0,0 +1,217 @@
+import type { Logger } from '@aztec/aztec.js';
+import { BBNativePrivateKernelProver } from '@aztec/bb-prover';
+import { BBWASMBundlePrivateKernelProver } from '@aztec/bb-prover/wasm/bundle';
+import { createLogger, logger } from '@aztec/foundation/log';
+import { WASMSimulator } from '@aztec/simulator/client';
+import type { PrivateExecutionStep } from '@aztec/stdlib/kernel';
+
+import { decode } from '@msgpack/msgpack';
+import assert from 'node:assert';
+import { readFile, readdir, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+
+const logLevel = ['silent', 'fatal', 'error', 'warn', 'info', 'verbose', 'debug', 'trace'] as const;
+type LogLevel = (typeof logLevel)[number];
+
+type Log = {
+  type: LogLevel;
+  timestamp: number;
+  prefix: string;
+  message: string;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  data: any;
+};
+
+const GATE_TYPES = [
+  'ecc_op',
+  'busread',
+  'lookup',
+  'pub_inputs',
+  'arithmetic',
+  'delta_range',
+  'elliptic',
+  'aux',
+  'poseidon2_external',
+  'poseidon2_internal',
+  'overflow',
+] as const;
+
+type GateType = (typeof GATE_TYPES)[number];
+
+type StructuredTrace = {
+  [k in GateType]: number;
+};
+
+export class ProxyLogger {
+  private static instance: ProxyLogger;
+  private logs: Log[] = [];
+
+  private constructor() {}
+
+  static create() {
+    ProxyLogger.instance = new ProxyLogger();
+  }
+
+  static getInstance() {
+    return ProxyLogger.instance;
+  }
+
+  createLogger(prefix: string): Logger {
+    return new Proxy(createLogger(prefix), {
+      get: (target: Logger, prop: keyof Logger) => {
+        if (logLevel.includes(prop as (typeof logLevel)[number])) {
+          return function (this: Logger, ...data: Parameters<Logger[LogLevel]>) {
+            const loggingFn = prop as LogLevel;
+            const args = [loggingFn, prefix, ...data] as Parameters<ProxyLogger['handleLog']>;
+            ProxyLogger.getInstance().handleLog(...args);
+            target[loggingFn].call(this, ...[data[0], data[1]]);
+          };
+        } else {
+          return target[prop];
+        }
+      },
+    });
+  }
+
+  private handleLog(type: (typeof logLevel)[number], prefix: string, message: string, data: any) {
+    this.logs.unshift({ type, prefix, message, data, timestamp: Date.now() });
+  }
+
+  public flushLogs() {
+    this.logs = [];
+  }
+
+  public getLogs() {
+    return this.logs;
+  }
+}
+
+type NativeProverConfig = { bbBinaryPath?: string; bbWorkingDirectory?: string };
+
+type ProverType = 'wasm' | 'native';
+
+type Step = { fnName: string; gateCount: number; accGateCount?: number };
+
+async function createProver(config: NativeProverConfig = {}, log: Logger) {
+  const simulationProvider = new WASMSimulator();
+  if (!config.bbBinaryPath || !config.bbWorkingDirectory) {
+    return { prover: new BBWASMBundlePrivateKernelProver(simulationProvider, 16, log), type: 'wasm' as ProverType };
+  } else {
+    const bbConfig = config as Required<NativeProverConfig>;
+    return {
+      prover: await BBNativePrivateKernelProver.new({ bbSkipCleanup: false, ...bbConfig }, simulationProvider, log),
+      type: 'native' as ProverType,
+    };
+  }
+}
+
+function getMinimumTrace(logs: Log[], proverType: ProverType): StructuredTrace {
+  const minimumMessage = 'Minimum required block sizes for structured trace:';
+  const minimumMessageIndex = logs.findIndex(log => log.message.includes(minimumMessage));
+  const candidateLogs = logs.slice(minimumMessageIndex - GATE_TYPES.length, minimumMessageIndex);
+  const traceLogs =
+    proverType === 'wasm'
+      ? candidateLogs.map(log => log.message)
+      : logs
+          .slice(minimumMessageIndex - GATE_TYPES.length, minimumMessageIndex)
+          .filter(log => GATE_TYPES.some(type => log.message.includes(`bb - ${type}`)))
+          .map(log => log.message.split('\n'))
+          .flat();
+  const traceSizes = traceLogs.map(log => {
+    const [gateType, gateSizeStr] = log
+      .replace(/\n.*\)$/, '')
+      .replace(/bb - /, '')
+      .split(':')
+      .map(s => s.trim());
+    const gateSize = parseInt(gateSizeStr);
+    assert(GATE_TYPES.includes(gateType as GateType), `Gate type ${gateType} is not recognized`);
+    return { [gateType]: gateSize };
+  });
+  assert(traceSizes.length === GATE_TYPES.length, 'Decoded trace sizes do not match expected amount of gate types');
+  return traceSizes.reduce((acc, curr) => ({ ...acc, ...curr }), {}) as StructuredTrace;
+}
+
+async function main() {
+  ProxyLogger.create();
+  const proxyLogger = ProxyLogger.getInstance();
+  const ivcFolder = process.env.CAPTURE_IVC_FOLDER;
+  if (!ivcFolder) {
+    throw new Error('CAPTURE_IVC_FOLDER is not set');
+  }
+  const flows = await readdir(ivcFolder);
+  logger.info(`Flows in ${ivcFolder}: \n${flows.map(flowName => `\t- ${flowName}`).join('\n')}`);
+  const { prover, type: proverType } = await createProver(
+    { bbBinaryPath: process.env.BB_BINARY_PATH, bbWorkingDirectory: process.env.BB_WORKING_DIRECTORY },
+    proxyLogger.createLogger('bb:prover'),
+  );
+
+  const userLog = createLogger('client_ivc_flows:data_processor');
+
+  for (const flow of flows) {
+    userLog.info(`Processing flow ${flow}`);
+    const bytecode = await readFile(join(ivcFolder, flow, 'acir.msgpack'));
+    const acirStack = decode(bytecode) as Buffer[];
+    const witnesses = await readFile(join(ivcFolder, flow, 'witnesses.json'));
+    const witnessStack = JSON.parse(witnesses.toString()).map((witnessMap: Record<string, string>) => {
+      return new Map<number, string>(Object.entries(witnessMap).map(([k, v]) => [Number(k), v]));
+    });
+    const stepsFile = await readFile(join(ivcFolder, flow, 'steps.json'));
+    const executionSteps = JSON.parse(stepsFile.toString()) as { fnName: string; gateCount: number }[];
+    const privateExecutionSteps: PrivateExecutionStep[] = executionSteps.map((step, i) => ({
+      functionName: step.fnName,
+      gateCount: step.gateCount,
+      bytecode: acirStack[i],
+      witness: witnessStack[i],
+    }));
+    let stats: { duration: number; eventName: string; proofSize: number } | undefined;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    let error: any | undefined;
+    let currentLogs: Log[] = [];
+    try {
+      await prover.createClientIvcProof(privateExecutionSteps);
+    } catch (e) {
+      userLog.error(`Failed to generate client ivc proof for ${flow}`, e);
+      error = (e as Error).message;
+    }
+    // Extract logs from this run from the proxy and write them to disk unconditionally
+    currentLogs = proxyLogger.getLogs();
+    await writeFile(join(ivcFolder, flow, 'logs.json'), JSON.stringify(currentLogs, null, 2));
+
+    if (!error) {
+      stats = currentLogs[0].data as { duration: number; eventName: string; proofSize: number };
+    }
+
+    const minimumTrace = getMinimumTrace(currentLogs, proverType);
+
+    const steps = executionSteps.reduce<Step[]>((acc, step, i) => {
+      const previousAccGateCount = i === 0 ? 0 : acc[i - 1].accGateCount!;
+      return [
+        ...acc,
+        {
+          fnName: step.fnName,
+          gateCount: step.gateCount,
+          accGateCount: previousAccGateCount + step.gateCount,
+        },
+      ];
+    }, []);
+    const totalGateCount = steps[steps.length - 1].accGateCount;
+    const benchmark = {
+      proverType,
+      minimumTrace: minimumTrace,
+      totalGateCount,
+      stats,
+      steps,
+      error,
+    };
+    await writeFile(join(ivcFolder, flow, 'benchmark.json'), JSON.stringify(benchmark, null, 2));
+    proxyLogger.flushLogs();
+  }
+}
+
+try {
+  await main();
+} catch (e) {
+  // eslint-disable-next-line no-console
+  console.error(e);
+  process.exit(1);
+}