@aztec/end-to-end 0.0.0-test.1 → 0.0.1-commit.017a351

package/src/bench/client_flows/client_flows_benchmark.ts

@@ -0,0 +1,399 @@
+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, 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';
+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 { EthAddress } from '@aztec/foundation/eth-address';
+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 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 { AUTOMINE_E2E_OPTS, MNEMONIC, getPaddedMaxFeesPerGas } from '../../fixtures/fixtures.js';
+import { type EndToEndContext, type SetupOptions, deployAccounts, 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';
+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';
+
+const { BENCHMARK_CONFIG } = process.env;
+
+export type AccountType = 'ecdsar1' | 'schnorr';
+export type FeePaymentMethodGetter = (wallet: Wallet, sender: AztecAddress) => Promise<FeePaymentMethod | undefined>;
+export type BenchmarkingFeePaymentMethod = 'bridged_fee_juice' | 'private_fpc' | 'sponsored_fpc' | 'fee_juice';
+
+export class ClientFlowsBenchmark {
+  public logger: Logger;
+  public aztecNode!: AztecNode;
+  public cheatCodes!: CheatCodes;
+  public context!: EndToEndContext;
+  public chainMonitor!: ChainMonitor;
+  public feeJuiceBridgeTestHarness!: GasBridgingTestHarness;
+  public adminWallet!: TestWallet;
+
+  // The admin that aids in the setup of the test
+  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 bananaCoinInstance!: ContractInstanceWithAddress;
+  public bananaFPC!: FPCContract;
+  public bananaFPCInstance!: ContractInstanceWithAddress;
+  // Random asset we want to trade
+  public candyBarCoin!: TokenContract;
+  public candyBarCoinInstance!: ContractInstanceWithAddress;
+  // AMM contract
+  public amm!: AMMContract;
+  public ammInstance!: ContractInstanceWithAddress;
+  // Liquidity token for AMM
+  public liquidityToken!: TokenContract;
+  public liquidityTokenInstance!: ContractInstanceWithAddress;
+  // Sponsored FPC contract
+  public sponsoredFPC!: SponsoredFPCContract;
+  public sponsoredFPCInstance!: ContractInstanceWithAddress;
+
+  // PXE and Wallet used by the benchmarking user. It can be set up with client-side proving enabled
+  public userWallet!: TestWallet;
+
+  public realProofs = ['true', '1'].includes(process.env.REAL_PROOFS ?? '');
+
+  // `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;
+
+  private proxyLogger: ProxyLogger;
+  private setupOptions: Partial<SetupOptions & DeployAztecL1ContractsArgs>;
+
+  constructor(testName?: string, setupOptions: Partial<SetupOptions & DeployAztecL1ContractsArgs> = {}) {
+    this.logger = createLogger(`bench:client_flows${testName ? `:${testName}` : ''}`);
+    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();
+  }
+
+  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, {
+      ...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 });
+
+    const rollupContract = RollupContract.getFromConfig(this.context.config);
+    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);
+  }
+
+  async mintAndBridgeFeeJuice(address: AztecAddress) {
+    const claim = await this.feeJuiceBridgeTestHarness.prepareTokensOnL1(address);
+    const { claimSecret: secret, messageLeafIndex: index } = claim;
+    await this.feeJuiceContract.methods
+      .claim(address, claim.claimAmount, secret, index)
+      .send({ from: this.adminAddress });
+  }
+
+  /** Admin mints bananaCoin tokens privately to the target address and redeems them. */
+  async mintPrivateBananas(amount: bigint, address: AztecAddress) {
+    const { result: balanceBefore } = await this.bananaCoin.methods
+      .balance_of_private(address)
+      .simulate({ from: address });
+
+    await mintTokensToPrivate(this.bananaCoin, this.adminAddress, address, amount);
+
+    const { result: balanceAfter } = await this.bananaCoin.methods
+      .balance_of_private(address)
+      .simulate({ from: address });
+    expect(balanceAfter).toEqual(balanceBefore + amount);
+  }
+
+  createBenchmarkingAccountManager(wallet: TestWallet, type: 'ecdsar1' | 'schnorr') {
+    const benchysSecret = Fr.random();
+    const salt = Fr.random();
+
+    let benchysPrivateSigningKey;
+    if (type === 'schnorr') {
+      benchysPrivateSigningKey = deriveSigningKey(benchysSecret);
+      return wallet.createSchnorrAccount(benchysSecret, salt, benchysPrivateSigningKey);
+    } else if (type === 'ecdsar1') {
+      benchysPrivateSigningKey = randomBytes(32);
+      return wallet.createECDSARAccount(benchysSecret, salt, benchysPrivateSigningKey);
+    } else {
+      throw new Error(`Unknown account type: ${type}`);
+    }
+  }
+
+  public async applyBaseSetup() {
+    await this.applyInitialAccounts();
+    await this.applySetupFeeJuice();
+  }
+
+  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;
+
+    this.adminWallet = this.context.wallet;
+    this.aztecNode = this.context.aztecNodeService;
+    this.cheatCodes = this.context.cheatCodes;
+
+    this.adminAddress = adminAddress;
+    this.sequencerAddress = sequencerAddress;
+
+    const canonicalFeeJuice = await getCanonicalFeeJuice();
+    this.feeJuiceContract = FeeJuiceContract.at(canonicalFeeJuice.address, this.adminWallet);
+    this.coinbase = EthAddress.random();
+
+    const userPXEConfig = getPXEConfig();
+    const userPXEConfigWithContracts = {
+      ...userPXEConfig,
+      proverEnabled: this.realProofs,
+    } as PXEConfig;
+
+    this.userWallet = await TestWallet.create(this.aztecNode, userPXEConfigWithContracts, {
+      loggers: {
+        prover: this.proxyLogger.createLogger('pxe:bb:wasm:bundle:proxied'),
+      },
+    });
+  }
+
+  async applySetupFeeJuice() {
+    this.logger.info('Applying fee juice setup');
+    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,
+      wallet: this.adminWallet,
+      logger: this.logger,
+    });
+  }
+
+  async applyDeployBananaToken() {
+    this.logger.info('Applying banana token deployment');
+    const { contract: bananaCoin, instance: bananaCoinInstance } = await BananaCoin.deploy(
+      this.adminWallet,
+      this.adminAddress,
+      'BC',
+      'BC',
+      18n,
+    ).send({
+      from: this.adminAddress,
+    });
+    this.logger.info(`BananaCoin deployed at ${bananaCoin.address}`);
+    this.bananaCoin = bananaCoin;
+    this.bananaCoinInstance = bananaCoinInstance;
+  }
+
+  async applyDeployCandyBarToken() {
+    this.logger.info('Applying candy bar token deployment');
+    const { contract: candyBarCoin, instance: candyBarCoinInstance } = await TokenContract.deploy(
+      this.adminWallet,
+      this.adminAddress,
+      'CBC',
+      'CBC',
+      18n,
+    ).send({
+      from: this.adminAddress,
+    });
+    this.logger.info(`CandyBarCoin deployed at ${candyBarCoin.address}`);
+    this.candyBarCoin = candyBarCoin;
+    this.candyBarCoinInstance = candyBarCoinInstance;
+  }
+
+  public async applyFPCSetup() {
+    this.logger.info('Applying FPC setup');
+    const feeJuiceContract = this.feeJuiceBridgeTestHarness.feeJuice;
+    expect((await this.context.wallet.getContractMetadata(feeJuiceContract.address)).isContractPublished).toBe(true);
+
+    const bananaCoin = this.bananaCoin;
+    const { contract: bananaFPC, instance: bananaFPCInstance } = await FPCContract.deploy(
+      this.adminWallet,
+      bananaCoin.address,
+      this.adminAddress,
+    ).send({
+      from: this.adminAddress,
+    });
+
+    this.logger.info(`BananaPay deployed at ${bananaFPC.address}`);
+
+    await this.feeJuiceBridgeTestHarness.bridgeFromL1ToL2(bananaFPC.address, this.adminAddress);
+
+    this.bananaFPC = bananaFPC;
+    this.bananaFPCInstance = bananaFPCInstance;
+  }
+
+  async applyDeploySponsoredFPC() {
+    this.logger.info('Applying sponsored FPC deployment');
+    const sponsoredFPCInstance = await setupSponsoredFPC(this.adminWallet);
+    this.logger.info(`SponsoredFPC at ${sponsoredFPCInstance.address}`);
+    this.sponsoredFPC = SponsoredFPCContract.at(sponsoredFPCInstance.address, this.adminWallet);
+    this.sponsoredFPCInstance = sponsoredFPCInstance;
+  }
+
+  public async createCrossChainTestHarness(owner: AztecAddress) {
+    const l1Client = createExtendedL1Client(this.context.config.l1RpcUrls, MNEMONIC);
+
+    const underlyingERC20Address = await deployL1Contract(l1Client, TestERC20Abi, TestERC20Bytecode, [
+      'Underlying',
+      'UND',
+      l1Client.account.address,
+    ]).then(({ address }) => address);
+
+    this.logger.verbose(`Setting up cross chain harness...`);
+    const crossChainTestHarness = await CrossChainTestHarness.new(
+      this.aztecNode,
+      l1Client,
+      this.adminWallet,
+      owner,
+      this.logger,
+      underlyingERC20Address,
+    );
+
+    this.logger.verbose(`L2 token deployed to: ${crossChainTestHarness.l2Token.address}`);
+
+    return crossChainTestHarness;
+  }
+
+  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: 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(benchysAccountManager.getInstance().salt),
+      contract: benchysAccountManager.getAccountContract(),
+    });
+    return accountManager.address;
+  }
+
+  public async applyDeployAmm() {
+    this.logger.info('Applying AMM deployment');
+    const { contract: liquidityToken, instance: liquidityTokenInstance } = await TokenContract.deploy(
+      this.adminWallet,
+      this.adminAddress,
+      'LPT',
+      'LPT',
+      18n,
+    ).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 });
+    this.logger.info(`AMM deployed at ${amm.address}`);
+    await liquidityToken.methods.set_minter(amm.address, true).send({ from: this.adminAddress });
+    this.liquidityToken = liquidityToken;
+    this.liquidityTokenInstance = liquidityTokenInstance;
+    this.amm = amm;
+    this.ammInstance = ammInstance;
+  }
+
+  public async getBridgedFeeJuicePaymentMethodForWallet(_wallet: Wallet, sender: AztecAddress) {
+    const claim = await this.feeJuiceBridgeTestHarness.prepareTokensOnL1(sender);
+    return new FeeJuicePaymentMethodWithClaim(sender, claim);
+  }
+
+  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 getPaddedMaxFeesPerGas(this.aztecNode);
+    const gasSettings = GasSettings.fallback({ maxFeesPerGas });
+    return new PrivateFeePaymentMethod(this.bananaFPC.address, sender, wallet, gasSettings);
+  }
+
+  public getSponsoredFPCPaymentMethodForWallet(_wallet: Wallet, _sender: AztecAddress) {
+    return Promise.resolve(new SponsoredFeePaymentMethod(this.sponsoredFPC.address));
+  }
+}

package/src/bench/client_flows/config.ts

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

package/src/bench/client_flows/data_extractor.ts

@@ -0,0 +1,89 @@
+import { BBBundlePrivateKernelProver } from '@aztec/bb-prover/client/bundle';
+import { createLogger, logger } from '@aztec/foundation/log';
+import { Timer } from '@aztec/foundation/timer';
+import { WASMSimulator } from '@aztec/simulator/client';
+import type { PrivateExecutionStep } from '@aztec/stdlib/kernel';
+import type { ProvingStats, ProvingTimings, SimulationStats } from '@aztec/stdlib/tx';
+
+import { Decoder } from 'msgpackr';
+import { readFile, readdir, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+
+import { type Log, ProxyLogger, generateBenchmark } from './benchmark.js';
+
+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 simulator = new WASMSimulator();
+  const log = proxyLogger.createLogger('bb:prover');
+  const prover = new BBBundlePrivateKernelProver(simulator, { logger: log });
+
+  const userLog = createLogger('chonk_flows:data_processor');
+
+  for (const flow of flows) {
+    userLog.info(`Processing flow ${flow}`);
+    const ivcInputs = await readFile(join(ivcFolder, flow, 'ivc-inputs.msgpack'));
+    const stepsFromFile: PrivateExecutionStep[] = new Decoder({ useRecords: false }).unpack(ivcInputs);
+    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 profileFile = await readFile(join(ivcFolder, flow, 'profile.json'));
+    const profile = JSON.parse(profileFile.toString()) as {
+      stats: ProvingStats | SimulationStats;
+      steps: {
+        functionName: string;
+        gateCount: number;
+        timings: { witgen: number; gateCount: number };
+      }[];
+    };
+    const privateExecutionSteps: PrivateExecutionStep[] = profile.steps.map((step, i) => ({
+      functionName: step.functionName,
+      gateCount: step.gateCount,
+      bytecode: stepsFromFile[i].bytecode,
+      // TODO(AD) do we still want to take this from witness.json?
+      witness: witnessStack[i],
+      vk: stepsFromFile[i].vk,
+      timings: {
+        witgen: step.timings.witgen,
+        gateCount: step.timings.gateCount,
+      },
+    }));
+
+    let error: any;
+    let currentLogs: Log[] = [];
+    let provingTime;
+    try {
+      const provingTimer = new Timer();
+      await prover.createChonkProof(privateExecutionSteps);
+      provingTime = provingTimer.ms();
+    } catch (e) {
+      userLog.error(`Failed to generate chonk 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 (!(profile.stats.timings as ProvingTimings).proving) {
+      (profile.stats.timings as ProvingTimings).proving = provingTime;
+    }
+    const benchmark = generateBenchmark(flow, currentLogs, profile.stats, privateExecutionSteps, 'native', 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);
+}