@aztec/end-to-end 0.87.5 → 0.87.7

package/src/bench/client_flows/client_flows_benchmark.ts

@@ -2,6 +2,7 @@ import { EcdsaRAccountContractArtifact, getEcdsaRAccount } from '@aztec/accounts
 import { SchnorrAccountContractArtifact, getSchnorrAccount, getSchnorrWallet } from '@aztec/accounts/schnorr';
 import {
   type AccountWallet,
+  AccountWalletWithSecretKey,
   AztecAddress,
   type AztecNode,
   FeeJuicePaymentMethod,
@@ -47,6 +48,7 @@ import {
   FeeJuicePortalTestingHarnessFactory,
   type GasBridgingTestHarness,
 } from '../../shared/gas_portal_test_harness.js';
+import { ProxyLogger } from './benchmark.js';
 import { type ClientFlowsConfig, FULL_FLOWS_CONFIG, KEY_FLOWS_CONFIG } from './config.js';
 
 const { E2E_DATA_PATH: dataPath, BENCHMARK_CONFIG } = process.env;
@@ -91,6 +93,8 @@ export class ClientFlowsBenchmark {
   // PXE used by the benchmarking user. It can be set up with client-side proving enabled
   public userPXE!: PXE;
 
+  public realProofs = ['true', '1'].includes(process.env.REAL_PROOFS ?? '');
+
   public paymentMethods: Record<BenchmarkingFeePaymentMethod, { forWallet: FeePaymentMethodGetter; circuits: number }> =
     {
       // eslint-disable-next-line camelcase
@@ -121,6 +125,8 @@ export class ClientFlowsBenchmark {
 
   public config: ClientFlowsConfig;
 
+  private proxyLogger: ProxyLogger;
+
   constructor(testName?: string, setupOptions: Partial<SetupOptions & DeployL1ContractsArgs> = {}) {
     this.logger = createLogger(`bench:client_flows${testName ? `:${testName}` : ''}`);
     this.snapshotManager = createSnapshotManager(
@@ -130,6 +136,8 @@ export class ClientFlowsBenchmark {
       { ...setupOptions },
     );
     this.config = BENCHMARK_CONFIG === 'key_flows' ? KEY_FLOWS_CONFIG : FULL_FLOWS_CONFIG;
+    ProxyLogger.create();
+    this.proxyLogger = ProxyLogger.getInstance();
   }
 
   async setup() {
@@ -163,7 +171,7 @@ export class ClientFlowsBenchmark {
     expect(balanceAfter).toEqual(balanceBefore + amount);
   }
 
-  async createBenchmarkingAccountManager(type: 'ecdsar1' | 'schnorr') {
+  async createBenchmarkingAccountManager(pxe: PXE, type: 'ecdsar1' | 'schnorr') {
     const benchysSecretKey = Fr.random();
     const salt = Fr.random();
 
@@ -171,10 +179,10 @@ export class ClientFlowsBenchmark {
     let benchysAccountManager;
     if (type === 'schnorr') {
       benchysPrivateSigningKey = deriveSigningKey(benchysSecretKey);
-      benchysAccountManager = await getSchnorrAccount(this.userPXE, benchysSecretKey, benchysPrivateSigningKey, salt);
+      benchysAccountManager = await getSchnorrAccount(pxe, benchysSecretKey, benchysPrivateSigningKey, salt);
     } else if (type === 'ecdsar1') {
       benchysPrivateSigningKey = randomBytes(32);
-      benchysAccountManager = await getEcdsaRAccount(this.userPXE, benchysSecretKey, benchysPrivateSigningKey, salt);
+      benchysAccountManager = await getEcdsaRAccount(pxe, benchysSecretKey, benchysPrivateSigningKey, salt);
     } else {
       throw new Error(`Unknown account type: ${type}`);
     }
@@ -212,11 +220,15 @@ export class ClientFlowsBenchmark {
         const l1Contracts = await aztecNode.getL1ContractAddresses();
         const userPXEConfigWithContracts = {
           ...userPXEConfig,
-          proverEnabled: ['true', '1'].includes(process.env.REAL_PROOFS ?? ''),
+          proverEnabled: this.realProofs,
           l1Contracts,
         } as PXEServiceConfig;
 
-        this.userPXE = await createPXEService(this.aztecNode, userPXEConfigWithContracts, 'pxe-user');
+        this.userPXE = await createPXEService(this.aztecNode, userPXEConfigWithContracts, {
+          loggers: {
+            prover: this.proxyLogger.createLogger('pxe:bb:wasm:bundle:proxied'),
+          },
+        });
       },
     );
   }
@@ -337,7 +349,7 @@ export class ClientFlowsBenchmark {
   }
 
   public async createAndFundBenchmarkingWallet(accountType: AccountType) {
-    const benchysAccountManager = await this.createBenchmarkingAccountManager(accountType);
+    const benchysAccountManager = await this.createBenchmarkingAccountManager(this.pxe, accountType);
     const benchysWallet = await benchysAccountManager.getWallet();
     const benchysAddress = benchysAccountManager.getAddress();
     const claim = await this.feeJuiceBridgeTestHarness.prepareTokensOnL1(
@@ -346,13 +358,19 @@ export class ClientFlowsBenchmark {
     );
     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({
+    // Register benchy on the user's PXE, where we're going to be interacting from
+    await this.userPXE.registerContract({
       instance: benchysAccountManager.getInstance(),
       artifact: accountType === 'ecdsar1' ? EcdsaRAccountContractArtifact : SchnorrAccountContractArtifact,
     });
-    await this.pxe.registerAccount(benchysWallet.getSecretKey(), benchysWallet.getCompleteAddress().partialAddress);
-    return benchysWallet;
+    await this.userPXE.registerAccount(benchysWallet.getSecretKey(), benchysWallet.getCompleteAddress().partialAddress);
+    const entrypoint = await benchysAccountManager.getAccount();
+    return new AccountWalletWithSecretKey(
+      this.userPXE,
+      entrypoint,
+      benchysWallet.getSecretKey(),
+      benchysAccountManager.salt,
+    );
   }
 
   public async applyDeployAmmSnapshot() {

package/src/bench/client_flows/data_extractor.ts

@@ -5,134 +5,29 @@ 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 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;
-
-  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;
-  }
-}
+import { type Log, type ProverType, ProxyLogger, generateBenchmark } from './benchmark.js';
 
 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();
+  const simulator = new WASMSimulator();
   if (!config.bbBinaryPath || !config.bbWorkingDirectory) {
-    return { prover: new BBWASMBundlePrivateKernelProver(simulationProvider, 16, log), type: 'wasm' as ProverType };
+    return { prover: new BBWASMBundlePrivateKernelProver(simulator, 16, log), type: 'wasm' as ProverType };
   } else {
     const bbConfig = config as Required<NativeProverConfig>;
     return {
-      prover: await BBNativePrivateKernelProver.new({ bbSkipCleanup: false, ...bbConfig }, simulationProvider, log),
+      prover: await BBNativePrivateKernelProver.new({ bbSkipCleanup: false, ...bbConfig }, simulator, log),
       type: 'native' as ProverType,
     };
   }
 }
 
-function getMinimumTrace(logs: Log[]): StructuredTrace {
-  const minimumMessage = 'Trace details:';
-  const minimumMessageIndex = logs.findIndex(log => log.message.includes(minimumMessage));
-  const candidateLogs = logs.slice(minimumMessageIndex - GATE_TYPES.length, minimumMessageIndex);
-
-  const traceLogs = candidateLogs
-    .filter(log => GATE_TYPES.some(type => log.message.includes(type)))
-    .map(log => log.message.split(/\t|\n/))
-    .flat()
-    .map(log => log.replace(/\(mem: .*\)/, '').trim())
-    .filter(Boolean);
-
-  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();
@@ -160,15 +55,15 @@ async function main() {
     });
     const profileFile = await readFile(join(ivcFolder, flow, 'profile.json'));
     const profile = JSON.parse(profileFile.toString()) as {
-      syncTime: number;
+      stats: ProvingStats | SimulationStats;
       steps: {
-        fnName: string;
+        functionName: string;
         gateCount: number;
         timings: { witgen: number; gateCount: number };
       }[];
     };
     const privateExecutionSteps: PrivateExecutionStep[] = profile.steps.map((step, i) => ({
-      functionName: step.fnName,
+      functionName: step.functionName,
       gateCount: step.gateCount,
       bytecode: stepsFromFile[i].bytecode,
       // TODO(AD) do we still want to take this from witness.json?
@@ -176,10 +71,9 @@ async function main() {
       vk: stepsFromFile[i].vk,
       timings: {
         witgen: step.timings.witgen,
-        gateCount: step.timings.witgen,
+        gateCount: step.timings.gateCount,
       },
     }));
-    let stats: { duration: number; eventName: string; proofSize: number } | undefined;
 
     let error: any;
     let currentLogs: Log[] = [];
@@ -195,38 +89,10 @@ async function main() {
     // 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 };
+    if (!(profile.stats.timings as ProvingTimings).proving) {
+      (profile.stats.timings as ProvingTimings).proving = provingTime;
     }
-
-    const minimumTrace = getMinimumTrace(currentLogs);
-
-    const steps = profile.steps.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,
-          timings: {
-            witgen: step.timings.witgen,
-          },
-        },
-      ];
-    }, []);
-    const totalGateCount = steps[steps.length - 1].accGateCount;
-    const benchmark = {
-      syncTime: profile.syncTime,
-      provingTime,
-      proverType,
-      minimumTrace: minimumTrace,
-      totalGateCount,
-      stats,
-      steps,
-      error,
-    };
+    const benchmark = generateBenchmark(flow, currentLogs, profile.stats, privateExecutionSteps, proverType, error);
     await writeFile(join(ivcFolder, flow, 'benchmark.json'), JSON.stringify(benchmark, null, 2));
     proxyLogger.flushLogs();
   }

package/src/bench/utils.ts

@@ -53,7 +53,7 @@ type MetricFilter = {
 };
 
 // See https://github.com/benchmark-action/github-action-benchmark/blob/e3c661617bc6aa55f26ae4457c737a55545a86a4/src/extract.ts#L659-L670
-type GithubActionBenchmarkResult = {
+export type GithubActionBenchmarkResult = {
   name: string;
   value: number;
   range?: string;

package/src/e2e_p2p/shared.ts

@@ -48,7 +48,7 @@ export const createPXEServiceAndSubmitTransactions = async (
 ): Promise<NodeContext> => {
   const rpcConfig = getRpcConfig();
   rpcConfig.proverEnabled = false;
-  const pxeService = await createPXEService(node, rpcConfig, true);
+  const pxeService = await createPXEService(node, rpcConfig, { useLogSuffix: true });
 
   const account = await getSchnorrAccount(
     pxeService,
@@ -71,7 +71,7 @@ export async function createPXEServiceAndPrepareTransactions(
 ): Promise<{ pxeService: PXEService; txs: ProvenTx[]; node: AztecNodeService }> {
   const rpcConfig = getRpcConfig();
   rpcConfig.proverEnabled = false;
-  const pxe = await createPXEService(node, rpcConfig, true);
+  const pxe = await createPXEService(node, rpcConfig, { useLogSuffix: true });
 
   const account = await getSchnorrAccount(pxe, fundedAccount.secret, fundedAccount.signingKey, fundedAccount.salt);
   await account.register();

package/src/fixtures/utils.ts

@@ -54,13 +54,13 @@ import { type ProverNode, type ProverNodeConfig, createProverNode } from '@aztec
 import {
   type PXEService,
   type PXEServiceConfig,
-  createPXEServiceWithSimulationProvider,
+  createPXEServiceWithSimulator,
   getPXEServiceConfig,
 } from '@aztec/pxe/server';
 import type { SequencerClient } from '@aztec/sequencer-client';
 import type { TestSequencerClient } from '@aztec/sequencer-client/test';
-import { WASMSimulator } from '@aztec/simulator/client';
-import { SimulationProviderRecorderWrapper } from '@aztec/simulator/testing';
+import { MemoryCircuitRecorder, SimulatorRecorderWrapper, WASMSimulator } from '@aztec/simulator/client';
+import { FileCircuitRecorder } from '@aztec/simulator/testing';
 import { getContractClassFromArtifact, getContractInstanceFromDeployParams } from '@aztec/stdlib/contract';
 import type { AztecNodeAdmin } from '@aztec/stdlib/interfaces/client';
 import type { PublicDataTreeLeaf } from '@aztec/stdlib/trees';
@@ -170,14 +170,14 @@ export async function setupPXEService(
     pxeServiceConfig.dataDirectory = path.join(tmpdir(), randomBytes(8).toString('hex'));
   }
 
-  const simulationProvider = new WASMSimulator();
-  const simulationProviderWithRecorder = new SimulationProviderRecorderWrapper(simulationProvider);
-  const pxe = await createPXEServiceWithSimulationProvider(
-    aztecNode,
-    simulationProviderWithRecorder,
-    pxeServiceConfig,
+  const simulator = new WASMSimulator();
+  const recorder = process.env.CIRCUIT_RECORD_DIR
+    ? new FileCircuitRecorder(process.env.CIRCUIT_RECORD_DIR)
+    : new MemoryCircuitRecorder();
+  const simulatorWithRecorder = new SimulatorRecorderWrapper(simulator, recorder);
+  const pxe = await createPXEServiceWithSimulator(aztecNode, simulatorWithRecorder, pxeServiceConfig, {
     useLogSuffix,
-  );
+  });
 
   const teardown = async () => {
     if (!configuredDataDirectory) {

package/dest/shared/capture_private_execution_steps.d.ts

@@ -1,7 +0,0 @@
-/**
- * This module exposes the ability to capture the private exection steps that go into our "Client IVC" prover.
- * These are used for debugging and benchmarking barretenberg (the prover component).
- */
-import type { ContractFunctionInteraction, DeployMethod, DeployOptions, ProfileMethodOptions } from '@aztec/aztec.js/contracts';
-export declare function capturePrivateExecutionStepsIfEnvSet(label: string, interaction: ContractFunctionInteraction | DeployMethod, opts?: Omit<ProfileMethodOptions & DeployOptions, 'profileMode'>, expectedSteps?: number): Promise<void>;
-//# sourceMappingURL=capture_private_execution_steps.d.ts.map

package/dest/shared/capture_private_execution_steps.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"capture_private_execution_steps.d.ts","sourceRoot":"","sources":["../../src/shared/capture_private_execution_steps.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,KAAK,EACV,2BAA2B,EAC3B,YAAY,EACZ,aAAa,EACb,oBAAoB,EACrB,MAAM,2BAA2B,CAAC;AASnC,wBAAsB,oCAAoC,CACxD,KAAK,EAAE,MAAM,EACb,WAAW,EAAE,2BAA2B,GAAG,YAAY,EACvD,IAAI,CAAC,EAAE,IAAI,CAAC,oBAAoB,GAAG,aAAa,EAAE,aAAa,CAAC,EAChE,aAAa,CAAC,EAAE,MAAM,iBA6CvB"}

package/dest/shared/capture_private_execution_steps.js

@@ -1,49 +0,0 @@
-/**
- * This module exposes the ability to capture the private exection steps that go into our "Client IVC" prover.
- * These are used for debugging and benchmarking barretenberg (the prover component).
- */ import { createLogger } from '@aztec/foundation/log';
-import { serializePrivateExecutionSteps } from '@aztec/stdlib/kernel';
-import { promises as fs } from 'fs';
-import path from 'path';
-const logger = createLogger('e2e:capture-private-execution-steps');
-export async function capturePrivateExecutionStepsIfEnvSet(label, interaction, opts, expectedSteps) {
-    // Not included in env_var.ts as internal to e2e tests.
-    const ivcFolder = process.env.CAPTURE_IVC_FOLDER;
-    if (!ivcFolder) {
-        return;
-    }
-    const profileMode = [
-        'execution-steps',
-        'full'
-    ].includes(process.env.PROFILE_MODE ?? '') ? process.env.PROFILE_MODE : 'execution-steps';
-    logger.info(`Capturing client ivc execution profile for ${label} in mode ${profileMode}`);
-    const result = await interaction.profile({
-        ...opts,
-        profileMode
-    });
-    if (expectedSteps !== undefined && result.executionSteps.length !== expectedSteps) {
-        throw new Error(`Expected ${expectedSteps} execution steps, got ${result.executionSteps.length}`);
-    }
-    const resultsDirectory = path.join(ivcFolder, label);
-    logger.info(`Writing private execution steps to ${resultsDirectory}`);
-    await fs.mkdir(resultsDirectory, {
-        recursive: true
-    });
-    // Write the client IVC files read by the prover.
-    const ivcInputsPath = path.join(resultsDirectory, 'ivc-inputs.msgpack');
-    await fs.writeFile(ivcInputsPath, serializePrivateExecutionSteps(result.executionSteps));
-    if (profileMode === 'full') {
-        // If we have gate counts, write the steps in human-readable format.
-        await fs.writeFile(path.join(resultsDirectory, 'profile.json'), JSON.stringify({
-            timings: result.timings,
-            steps: result.executionSteps.map((step)=>({
-                    fnName: step.functionName,
-                    gateCount: step.gateCount,
-                    timings: step.timings
-                }))
-        }, null, 2));
-        // In full mode, we also write the raw witnesses in a more human-readable format.
-        await fs.writeFile(path.join(resultsDirectory, 'witnesses.json'), JSON.stringify(result.executionSteps.map((step)=>Object.fromEntries(step.witness))));
-    }
-    logger.info(`Wrote private execution steps to ${resultsDirectory}`);
-}

package/src/shared/capture_private_execution_steps.ts

@@ -1,68 +0,0 @@
-/**
- * This module exposes the ability to capture the private exection steps that go into our "Client IVC" prover.
- * These are used for debugging and benchmarking barretenberg (the prover component).
- */
-import type {
-  ContractFunctionInteraction,
-  DeployMethod,
-  DeployOptions,
-  ProfileMethodOptions,
-} from '@aztec/aztec.js/contracts';
-import { createLogger } from '@aztec/foundation/log';
-import { serializePrivateExecutionSteps } from '@aztec/stdlib/kernel';
-
-import { promises as fs } from 'fs';
-import path from 'path';
-
-const logger = createLogger('e2e:capture-private-execution-steps');
-
-export async function capturePrivateExecutionStepsIfEnvSet(
-  label: string,
-  interaction: ContractFunctionInteraction | DeployMethod,
-  opts?: Omit<ProfileMethodOptions & DeployOptions, 'profileMode'>,
-  expectedSteps?: number,
-) {
-  // Not included in env_var.ts as internal to e2e tests.
-  const ivcFolder = process.env.CAPTURE_IVC_FOLDER;
-  if (!ivcFolder) {
-    return;
-  }
-  const profileMode = ['execution-steps', 'full'].includes(process.env.PROFILE_MODE ?? '')
-    ? (process.env.PROFILE_MODE as 'full' | 'execution-steps')
-    : 'execution-steps';
-  logger.info(`Capturing client ivc execution profile for ${label} in mode ${profileMode}`);
-  const result = await interaction.profile({ ...opts, profileMode });
-  if (expectedSteps !== undefined && result.executionSteps.length !== expectedSteps) {
-    throw new Error(`Expected ${expectedSteps} execution steps, got ${result.executionSteps.length}`);
-  }
-  const resultsDirectory = path.join(ivcFolder, label);
-  logger.info(`Writing private execution steps to ${resultsDirectory}`);
-  await fs.mkdir(resultsDirectory, { recursive: true });
-  // Write the client IVC files read by the prover.
-  const ivcInputsPath = path.join(resultsDirectory, 'ivc-inputs.msgpack');
-  await fs.writeFile(ivcInputsPath, serializePrivateExecutionSteps(result.executionSteps));
-  if (profileMode === 'full') {
-    // If we have gate counts, write the steps in human-readable format.
-    await fs.writeFile(
-      path.join(resultsDirectory, 'profile.json'),
-      JSON.stringify(
-        {
-          timings: result.timings,
-          steps: result.executionSteps.map(step => ({
-            fnName: step.functionName,
-            gateCount: step.gateCount,
-            timings: step.timings,
-          })),
-        },
-        null,
-        2,
-      ),
-    );
-    // In full mode, we also write the raw witnesses in a more human-readable format.
-    await fs.writeFile(
-      path.join(resultsDirectory, 'witnesses.json'),
-      JSON.stringify(result.executionSteps.map(step => Object.fromEntries(step.witness))),
-    );
-  }
-  logger.info(`Wrote private execution steps to ${resultsDirectory}`);
-}