@alejoamiras/aztec-benchmark 0.0.0-canary.gb8d1485

package/action/index.cjs

@@ -0,0 +1,93 @@
+const core = require('@actions/core');
+const exec = require('@actions/exec');
+const fs = require('node:fs');
+const path = require('node:path');
+const { runComparison } = require('./comparison.cjs');
+
+/**
+ * Main function for the GitHub Action.
+ * This function is responsible for:
+ * - Reading action inputs (threshold, output path, base suffix, current suffix).
+ * - Setting up paths and suffixes for benchmark reports.
+ * - Executing the benchmark CLI to generate the 'latest' reports.
+ * - Running the comparison logic between 'base' and 'latest' reports.
+ * - Writing the comparison result to a markdown file.
+ * - Setting action outputs (markdown content and file path).
+ * It handles errors and sets the action to failed if any step fails.
+ */
+async function run() {
+  try {
+    const threshold = parseFloat(core.getInput('threshold'));
+    const outputMarkdownPath = core.getInput('output_markdown_path');
+    const baseSuffix = core.getInput('base_suffix');
+    const currentSuffix = core.getInput('current_suffix');
+    const configPath = core.getInput('config_path');
+    const reportsDir = core.getInput('reports_dir');
+    const onlyReport = core.getInput('only_report') === 'true';
+    const circuitDetails = core.getInput('circuit_details') === 'true';
+
+    core.info('--- Inputs ---');
+    core.info(`Config Path: ${configPath}`);
+    core.info(`Threshold: ${threshold}%`);
+    core.info(`Output Markdown Path: ${outputMarkdownPath}`);
+    core.info(`Reports Directory: ${reportsDir}`);
+    core.info(`Base Suffix: ${baseSuffix}`);
+    core.info(`Current Suffix: ${currentSuffix}`);
+    core.info(`Only report: ${onlyReport}`);
+    core.info(`Circuit details: ${circuitDetails}`);
+
+    if (isNaN(threshold)) {
+      throw new Error('Invalid threshold value. Please provide a number.');
+    }
+
+    if (!onlyReport) {
+      core.startGroup('Generating latest benchmark reports (all contracts)');
+      const cliArgs = [];
+      cliArgs.push('--config', configPath);
+      cliArgs.push('--output-dir', reportsDir);
+      cliArgs.push('--suffix', currentSuffix);
+
+      core.info(`Executing: aztec-benchmark ${cliArgs.join(' ')}`);
+
+      const execOptions = {
+        cwd: process.cwd(),
+      };
+      // Scoped name — the unscoped `aztec-benchmark` registry name is not ours; invoking it
+      // via npx would be a dependency-confusion target on runners without a local install.
+      const exitCode = await exec.exec('npx', ['--yes', '@alejoamiras/aztec-benchmark', ...cliArgs], execOptions);
+      if (exitCode !== 0) {
+        throw new Error(`Benchmark CLI execution failed with exit code ${exitCode}`);
+      }
+      core.endGroup();
+    } else {
+      core.info('Skipping aztec-benchmark execution (per only_report input).');
+    }
+
+    core.startGroup('Comparing benchmark reports');
+    const comparisonInputs = {
+      reportsDir,
+      baseSuffix,
+      prSuffix: currentSuffix,
+      threshold,
+      circuitDetails,
+    };
+    const markdownResult = runComparison(comparisonInputs);
+    core.endGroup();
+
+    const resolvedOutputPath = path.resolve(outputMarkdownPath);
+    core.info(`Writing comparison report to: ${resolvedOutputPath}`);
+    fs.writeFileSync(resolvedOutputPath, markdownResult);
+
+    core.setOutput('comparison_markdown', markdownResult);
+    core.setOutput('markdown_file_path', resolvedOutputPath);
+
+    core.info('Benchmark generation and comparison action completed successfully.');
+  } catch (error) {
+    core.setFailed(`Action failed: ${error.message}`);
+    if (error.stack) {
+      core.debug(error.stack);
+    }
+  }
+}
+
+run();

package/bin/aztec-benchmark

@@ -0,0 +1,21 @@
+#!/usr/bin/env sh
+
+# Resolve the true path of the script, following symlinks
+SOURCE="${0}"
+while [ -h "$SOURCE" ]; do # resolve $SOURCE until the file is no longer a symlink
+  DIR="$( cd -P "$( dirname "$SOURCE" )" >/dev/null 2>&1 && pwd )"
+  SOURCE="$(readlink "$SOURCE")"
+  case $SOURCE in
+    /*) ;;
+    *) SOURCE="$DIR/$SOURCE" ;;
+  esac
+done
+SCRIPT_DIR="$( cd -P "$( dirname "$SOURCE" )" >/dev/null 2>&1 && pwd )"
+
+# The actual CLI script is in dist/cli.js relative to the package root
+# SCRIPT_DIR is currently aztec-benchmark/bin
+PACKAGE_ROOT="$(dirname "$SCRIPT_DIR")"
+CLI_SCRIPT="$PACKAGE_ROOT/dist/cli.js"
+
+# Execute the CLI script with tsx, passing all arguments
+exec tsx "$CLI_SCRIPT" "$@" 

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,145 @@
+#!/usr/bin/env node
+import fs from 'node:fs';
+import path from 'node:path';
+import toml from '@iarna/toml';
+import { Command } from 'commander';
+import { Profiler } from './profiler.js';
+const program = new Command();
+program
+    .name('aztec-benchmark')
+    .description('Runs benchmarks defined in Nargo.toml and associated *.benchmark.ts files.')
+    .option('-c, --contracts <names...>', 'Specify contracts to benchmark by name (defined in Nargo.toml)')
+    .option('--config <path>', 'Path to the Nargo.toml file', './Nargo.toml')
+    .option('-o, --output-dir <path>', 'Directory to save benchmark reports', './benchmarks')
+    .option('-s, --suffix <suffix>', 'Optional suffix to append to the report filename (e.g., _pr)')
+    .option('--skip-proving', 'Skip proving transactions (only measure gate counts and gas)')
+    /**
+     * Main action for the CLI.
+     * Parses Nargo.toml, finds and runs specified benchmarks, and saves the reports.
+     * @param options - The command line options.
+     * @param options.contracts - Specific contracts to benchmark.
+     * @param options.config - Path to the Nargo.toml file.
+     * @param options.outputDir - Directory to save reports.
+     * @param options.suffix - Optional suffix for report filenames.
+     */
+    .action(async (options) => {
+    const nargoTomlPath = path.resolve(process.cwd(), options.config);
+    const outputDir = path.resolve(process.cwd(), options.outputDir);
+    const specifiedContractNames = options.contracts || [];
+    const suffix = options.suffix || '';
+    if (!fs.existsSync(nargoTomlPath)) {
+        console.error(`Error: Nargo.toml not found at ${nargoTomlPath}`);
+        process.exit(1);
+    }
+    if (!fs.existsSync(outputDir)) {
+        console.log(`Creating output directory: ${outputDir}`);
+        fs.mkdirSync(outputDir, { recursive: true });
+    }
+    let nargoConfig;
+    try {
+        const tomlContent = fs.readFileSync(nargoTomlPath, 'utf-8');
+        nargoConfig = toml.parse(tomlContent);
+    }
+    catch (error) {
+        console.error(`Error parsing Nargo.toml at ${nargoTomlPath}:`, error.message);
+        process.exit(1);
+    }
+    const availableBenchmarks = nargoConfig.benchmark || {};
+    const availableContractNames = Object.keys(availableBenchmarks);
+    if (availableContractNames.length === 0) {
+        console.error('No contracts found in the [benchmark] section of Nargo.toml.');
+        process.exit(1);
+    }
+    // Filter contracts to run based on CLI option
+    const contractsToRunNames = specifiedContractNames.length > 0
+        ? availableContractNames.filter((name) => specifiedContractNames.includes(name))
+        : availableContractNames;
+    if (contractsToRunNames.length === 0) {
+        if (specifiedContractNames.length > 0) {
+            console.error(`Error: None of the specified contracts found in the [benchmark] section: ${specifiedContractNames.join(', ')}`);
+        }
+        else {
+            console.error('Error: No benchmarks specified via --contracts flag or found in the [benchmark] section of Nargo.toml.');
+        }
+        program.outputHelp();
+        process.exit(1);
+    }
+    console.log(`Found ${contractsToRunNames.length} benchmark(s) to run: ${contractsToRunNames.join(', ')}`);
+    // Iterate over the filtered contract names
+    for (const contractName of contractsToRunNames) {
+        const benchmarkFileName = availableBenchmarks[contractName];
+        const benchmarkFilePath = path.resolve(path.dirname(nargoTomlPath), benchmarkFileName);
+        const outputFilename = `${contractName}${suffix}.benchmark.json`;
+        const outputJsonPath = path.join(outputDir, outputFilename);
+        console.log(`--- Running benchmark for ${contractName}${suffix ? ` (suffix: ${suffix})` : ''} ---`);
+        console.log(` -> Benchmark file: ${benchmarkFilePath}`);
+        console.log(` -> Output report: ${outputJsonPath}`);
+        if (!fs.existsSync(benchmarkFilePath)) {
+            console.error(`Error: Benchmark file not found: ${benchmarkFilePath}`);
+            process.exit(1);
+        }
+        try {
+            const module = await import(benchmarkFilePath);
+            const BenchmarkClass = module.default;
+            if (!BenchmarkClass ||
+                !(typeof BenchmarkClass === 'function') ||
+                !(typeof BenchmarkClass.prototype.getMethods === 'function')) {
+                console.error(`Error: ${benchmarkFilePath} does not export a default class with a getMethods method.`);
+                process.exit(1);
+            }
+            const benchmarkInstance = new BenchmarkClass();
+            let runContext = {};
+            if (typeof benchmarkInstance.setup === 'function') {
+                console.log(`Running setup for ${contractName}...`);
+                runContext = await benchmarkInstance.setup();
+                console.log(`Setup complete for ${contractName}.`);
+            }
+            if (!options.skipProving && !runContext.wallet) {
+                console.error(`Error: setup() must return a context with a 'wallet' property when proving is enabled.`);
+                process.exit(1);
+            }
+            const profiler = new Profiler(runContext.wallet, {
+                skipProving: options.skipProving,
+                feePaymentMethod: runContext.feePaymentMethod,
+            });
+            console.log(`Getting methods to benchmark for ${contractName}...`);
+            const interactionsToBenchmark = benchmarkInstance.getMethods(runContext);
+            if (!Array.isArray(interactionsToBenchmark) || interactionsToBenchmark.length === 0) {
+                console.warn(`No benchmark methods returned by getMethods for ${contractName}. Saving empty report.`);
+                await profiler.saveResults([], outputJsonPath);
+            }
+            else {
+                console.log(`Profiling ${interactionsToBenchmark.length} methods for ${contractName}...`);
+                const results = await profiler.profile(interactionsToBenchmark);
+                await profiler.saveResults(results, outputJsonPath);
+            }
+            if (typeof benchmarkInstance.teardown === 'function') {
+                console.log(`Running teardown for ${contractName}...`);
+                await benchmarkInstance.teardown(runContext);
+                console.log(`Teardown complete for ${contractName}.`);
+            }
+            // Workaround: PXE.stop() doesn't release all resources
+            // @see https://github.com/AztecProtocol/aztec-packages/issues/20446
+            if (runContext.wallet) {
+                const pxe = runContext.wallet.pxe;
+                if (pxe?.blockStateSynchronizer) {
+                    await pxe.blockStateSynchronizer.blockStream?.stop();
+                    await pxe.blockStateSynchronizer.store?.close();
+                }
+                await runContext.wallet.stop();
+                // Close leftover HTTP keep-alive sockets
+                for (const h of process._getActiveHandles()) {
+                    if (h?.constructor?.name === 'Socket' && !h.destroyed)
+                        h.destroy();
+                }
+            }
+            console.log(`--- Benchmark finished for ${contractName} ---`);
+        }
+        catch (error) {
+            console.error(`Failed to run benchmark for ${contractName} from ${benchmarkFilePath}:`, error);
+            process.exit(1);
+        }
+    }
+    console.log('All specified benchmarks completed successfully.');
+});
+program.parse(process.argv);

package/dist/feeWrappedInteraction.d.ts

@@ -0,0 +1,35 @@
+import type { AztecAddress } from '@aztec/aztec.js/addresses';
+import type { ContractFunctionInteraction, GasSettingsOption, ProfileInteractionOptions, RequestInteractionOptions, SendInteractionOptions, SimulateInteractionOptions } from '@aztec/aztec.js/contracts';
+import type { FeePaymentMethod } from '@aztec/aztec.js/fee';
+import type { NamedBenchmarkedInteraction } from './types.js';
+/** Partial gas settings that can be injected into every profiler call. */
+export type FeeGasSettings = NonNullable<GasSettingsOption['gasSettings']>;
+/** Fee configuration injected by FeeWrappedInteraction and namedMethod. */
+export interface FeeOptions {
+    paymentMethod?: FeePaymentMethod;
+    gasSettings?: FeeGasSettings;
+}
+/**
+ * Wraps a ContractFunctionInteraction so the benchmark profiler always uses a
+ * per-interaction FeePaymentMethod and gas settings.
+ *
+ * The profiler only supports a single global feePaymentMethod, but benchmarks
+ * often require different methods per interaction. This class intercepts every
+ * profiler call and injects the configured method and settings.
+ */
+export declare class FeeWrappedInteraction {
+    private readonly inner;
+    private readonly paymentMethod?;
+    private readonly gasSettings?;
+    constructor(inner: ContractFunctionInteraction, paymentMethod?: FeePaymentMethod | undefined, gasSettings?: FeeGasSettings | undefined);
+    request(options?: RequestInteractionOptions): ReturnType<ContractFunctionInteraction['request']>;
+    simulate(options?: SimulateInteractionOptions): Promise<import("@aztec/aztec.js/contracts").SimulationResult>;
+    profile(options?: ProfileInteractionOptions): ReturnType<ContractFunctionInteraction['profile']>;
+    send(options?: SendInteractionOptions): ReturnType<ContractFunctionInteraction['send']>;
+    private withFee;
+}
+/**
+ * Creates a NamedBenchmarkedInteraction that wraps `inner` with an optional
+ * FeePaymentMethod and gas settings.
+ */
+export declare function namedMethod(name: string, caller: AztecAddress, inner: ContractFunctionInteraction, fee?: FeeOptions): NamedBenchmarkedInteraction;

package/dist/feeWrappedInteraction.js

@@ -0,0 +1,62 @@
+/**
+ * Wraps a ContractFunctionInteraction so the benchmark profiler always uses a
+ * per-interaction FeePaymentMethod and gas settings.
+ *
+ * The profiler only supports a single global feePaymentMethod, but benchmarks
+ * often require different methods per interaction. This class intercepts every
+ * profiler call and injects the configured method and settings.
+ */
+export class FeeWrappedInteraction {
+    constructor(inner, paymentMethod, gasSettings) {
+        this.inner = inner;
+        this.paymentMethod = paymentMethod;
+        this.gasSettings = gasSettings;
+    }
+    async request(options = {}) {
+        // `RequestInteractionOptions.fee` is `FeePaymentMethodOption` — it only carries
+        // `paymentMethod`, not `gasSettings`. Gas settings are injected by `withFee` in
+        // simulate/profile/send where the fee type supports them.
+        const paymentMethod = options.fee?.paymentMethod ?? this.paymentMethod;
+        return paymentMethod
+            ? this.inner.request({
+                ...options,
+                fee: { ...(options.fee ?? {}), paymentMethod },
+            })
+            : this.inner.request(options);
+    }
+    async simulate(options) {
+        return this.inner.simulate(this.withFee(options));
+    }
+    async profile(options) {
+        return this.inner.profile(this.withFee(options));
+    }
+    async send(options) {
+        return this.inner.send(this.withFee(options));
+    }
+    withFee(options) {
+        const paymentMethod = options?.fee?.paymentMethod ?? this.paymentMethod;
+        if (!paymentMethod)
+            return (options ?? {});
+        return {
+            ...(options ?? {}),
+            fee: {
+                ...(options?.fee ?? {}),
+                paymentMethod,
+                ...(this.gasSettings && { gasSettings: this.gasSettings }),
+            },
+        };
+    }
+}
+/**
+ * Creates a NamedBenchmarkedInteraction that wraps `inner` with an optional
+ * FeePaymentMethod and gas settings.
+ */
+export function namedMethod(name, caller, inner, fee) {
+    return {
+        name,
+        interaction: {
+            caller,
+            action: new FeeWrappedInteraction(inner, fee?.paymentMethod, fee?.gasSettings),
+        },
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export type { FeeGasSettings, FeeOptions } from './feeWrappedInteraction.js';
+export { FeeWrappedInteraction, namedMethod } from './feeWrappedInteraction.js';
+export { Profiler } from './profiler.js';
+export { getSystemInfo } from './systemInfo.js';
+export type { GateCount, NamedBenchmarkedInteraction, ProfileReport, ProfileResult, SystemInfo } from './types.js';
+export { BenchmarkBase as Benchmark, BenchmarkContext } from './types.js';

package/dist/index.js

@@ -0,0 +1,8 @@
+// Export the base class and types for users
+// Export fee payment helpers
+export { FeeWrappedInteraction, namedMethod } from './feeWrappedInteraction.js';
+// Also export the Profiler for potential advanced use (or internal use by CLI)
+export { Profiler } from './profiler.js';
+// Export system info utilities
+export { getSystemInfo } from './systemInfo.js';
+export { BenchmarkBase as Benchmark } from './types.js'; // Alias BenchmarkBase to Benchmark for user convenience

package/dist/profiler.d.ts

@@ -0,0 +1,32 @@
+import type { ContractFunctionInteractionCallIntent } from '@aztec/aztec.js/authorization';
+import type { FeePaymentMethod } from '@aztec/aztec.js/fee';
+import type { EmbeddedWallet } from '@aztec/wallets/embedded';
+import type { NamedBenchmarkedInteraction, ProfileResult } from './types.js';
+interface ProfilerOptions {
+    skipProving?: boolean;
+    /** Fee payment method to use when sending transactions. */
+    feePaymentMethod?: FeePaymentMethod;
+}
+/**
+ * Profiles Aztec contract functions to measure gate counts, gas usage and proving time.
+ */
+export declare class Profiler {
+    #private;
+    /** @param _wallet - Unused, kept for backward compatibility with existing callers. */
+    constructor(_wallet?: EmbeddedWallet, options?: ProfilerOptions);
+    /**
+     * Profiles a list of contract function interactions.
+     * Items can be plain interactions or objects with an interaction and a custom name.
+     * @param fsToProfile - An array of items to profile.
+     * @returns A promise that resolves to an array of profile results.
+     */
+    profile(fsToProfile: Array<ContractFunctionInteractionCallIntent | NamedBenchmarkedInteraction>): Promise<ProfileResult[]>;
+    /**
+     * Saves the profiling results to a JSON file.
+     * If no results are provided, an empty report is saved.
+     * @param results - An array of profile results to save.
+     * @param filename - The name of the file to save the results to.
+     */
+    saveResults(results: ProfileResult[], filename: string): Promise<void>;
+}
+export {};

package/dist/profiler.js

@@ -0,0 +1,197 @@
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _Profiler_instances, _Profiler_skipProving, _Profiler_feePaymentMethod, _Profiler_profileOne;
+import fs from 'node:fs';
+import { getSystemInfo } from './systemInfo.js';
+/**
+ * Sums all numbers in an array.
+ * @param arr - The array of numbers to sum.
+ * @returns The sum of the numbers.
+ */
+function sumArray(arr) {
+    return arr.reduce((a, b) => a + b, 0);
+}
+/**
+ * Sums DA and L2 gas components.
+ * @param gas - The gas object.
+ * @returns The total gas (DA + L2).
+ */
+function sumGas(gas) {
+    return (gas?.daGas ?? 0) + (gas?.l2Gas ?? 0);
+}
+/**
+ * Profiles Aztec contract functions to measure gate counts, gas usage and proving time.
+ */
+export class Profiler {
+    /** @param _wallet - Unused, kept for backward compatibility with existing callers. */
+    constructor(_wallet, options) {
+        _Profiler_instances.add(this);
+        _Profiler_skipProving.set(this, void 0);
+        _Profiler_feePaymentMethod.set(this, void 0);
+        __classPrivateFieldSet(this, _Profiler_skipProving, options?.skipProving ?? false, "f");
+        __classPrivateFieldSet(this, _Profiler_feePaymentMethod, options?.feePaymentMethod, "f");
+    }
+    /**
+     * Profiles a list of contract function interactions.
+     * Items can be plain interactions or objects with an interaction and a custom name.
+     * @param fsToProfile - An array of items to profile.
+     * @returns A promise that resolves to an array of profile results.
+     */
+    async profile(fsToProfile) {
+        const results = [];
+        for (const item of fsToProfile) {
+            if ('interaction' in item && 'name' in item) {
+                // This is a NamedBenchmarkedInteraction object
+                results.push(await __classPrivateFieldGet(this, _Profiler_instances, "m", _Profiler_profileOne).call(this, item.interaction, item.name, item.additionalScopes));
+            }
+            else {
+                // This is a plain ContractFunctionInteractionCallIntent
+                results.push(await __classPrivateFieldGet(this, _Profiler_instances, "m", _Profiler_profileOne).call(this, item)); // Pass undefined for customName
+            }
+        }
+        return results;
+    }
+    /**
+     * Saves the profiling results to a JSON file.
+     * If no results are provided, an empty report is saved.
+     * @param results - An array of profile results to save.
+     * @param filename - The name of the file to save the results to.
+     */
+    async saveResults(results, filename) {
+        const systemInfo = getSystemInfo();
+        if (!results.length) {
+            console.log(`No results to save for ${filename}. Saving empty report.`);
+            fs.writeFileSync(filename, JSON.stringify({ summary: {}, results: [], gasSummary: {}, provingTimeSummary: {}, systemInfo }, null, 2));
+            return;
+        }
+        const summary = results.reduce((acc, result) => ({
+            ...acc,
+            [result.name]: result.totalGateCount,
+        }), {});
+        const gasSummary = results.reduce((acc, result) => ({
+            ...acc,
+            [result.name]: result.gas ? sumGas(result.gas.gasLimits) + sumGas(result.gas.teardownGasLimits) : 0,
+        }), {});
+        const provingTimeSummary = results.reduce((acc, result) => ({
+            ...acc,
+            [result.name]: result.provingTime ?? 0,
+        }), {});
+        const report = {
+            summary,
+            results: results,
+            gasSummary,
+            provingTimeSummary,
+            systemInfo,
+        };
+        console.log(`Saving results for ${results.length} methods in ${filename}`);
+        try {
+            fs.writeFileSync(filename, JSON.stringify(report, null, 2));
+        }
+        catch (error) {
+            console.error(`Error writing results to ${filename}:`, error.message);
+            throw error;
+        }
+    }
+}
+_Profiler_skipProving = new WeakMap(), _Profiler_feePaymentMethod = new WeakMap(), _Profiler_instances = new WeakSet(), _Profiler_profileOne = 
+/**
+ * Profiles a single contract function interaction.
+ * @param f - The contract function interaction to profile.
+ * @param customName - Optional user-defined name for this benchmark entry. If not provided, name is derived.
+ * @returns A promise that resolves to a profile result for the function.
+ *          Returns a result with FAILED in the name and zero counts/gas if profiling errors.
+ * @private
+ */
+async function _Profiler_profileOne(f, customName, additionalScopes) {
+    let name;
+    if (customName) {
+        name = customName;
+    }
+    else {
+        // Name discovery logic (reinstated)
+        try {
+            const executionPayload = await f.action.request(); // Note: f.request() might be an issue if f is already a PxeSimoneResponse - check aztec.js docs
+            if (executionPayload.calls && executionPayload.calls.length > 0) {
+                const firstCall = executionPayload.calls[0];
+                // Attempt to get a meaningful name
+                name = firstCall?.name ?? firstCall?.selector?.toString() ?? 'unknown_function';
+            }
+            else {
+                name = 'unknown_function_no_calls';
+                console.warn('No calls found in execution payload for name discovery.');
+            }
+        }
+        catch (e) {
+            // Fallback if request() fails or doesn't yield a name
+            const potentialMethodName = f.methodName; // methodName is not a standard prop, but might exist on some wrapped objects
+            if (potentialMethodName) {
+                name = potentialMethodName;
+                console.warn(`Could not simulate request for name discovery (${e.message}), using interaction.methodName as fallback: ${name}`);
+            }
+            else {
+                name = 'unknown_function_request_failed';
+                console.warn(`Could not determine function name from request simulation: ${e.message}`);
+            }
+        }
+    }
+    console.log(`Profiling ${name}...`);
+    try {
+        const origin = f.caller;
+        const feeOpts = __classPrivateFieldGet(this, _Profiler_feePaymentMethod, "f") ? { paymentMethod: __classPrivateFieldGet(this, _Profiler_feePaymentMethod, "f") } : undefined;
+        // `includeMetadata` returns `gasUsed`: the raw gas the simulation consumed, with no padding.
+        const simResult = await f.action.simulate({
+            from: origin,
+            additionalScopes,
+            includeMetadata: true,
+            fee: feeOpts,
+        });
+        const gas = simResult.gasUsed
+            ? {
+                gasLimits: simResult.gasUsed.totalGas,
+                teardownGasLimits: simResult.gasUsed.teardownGas,
+            }
+            : undefined;
+        // Profile the tx to get gate counts and optionally proving time.
+        const profileResults = await f.action.profile({
+            profileMode: 'full',
+            from: origin,
+            additionalScopes,
+            skipProofGeneration: __classPrivateFieldGet(this, _Profiler_skipProving, "f"),
+            fee: feeOpts,
+        });
+        const provingTime = !__classPrivateFieldGet(this, _Profiler_skipProving, "f") ? profileResults.stats?.timings?.proving : undefined;
+        // Send the tx (this proves again internally).
+        await f.action.send({ from: origin, additionalScopes, fee: feeOpts });
+        const result = {
+            name,
+            totalGateCount: sumArray(profileResults.executionSteps
+                .map((step) => step.gateCount)
+                .filter((count) => count !== undefined)),
+            gateCounts: profileResults.executionSteps.map((step) => ({
+                circuitName: step.functionName,
+                gateCount: step.gateCount || 0,
+                witgenMs: step.timings?.witgen,
+            })),
+            gas,
+            provingTime,
+        };
+        const daGas = gas?.gasLimits?.daGas ?? 'N/A';
+        const l2Gas = gas?.gasLimits?.l2Gas ?? 'N/A';
+        const provingDisplay = provingTime !== undefined ? `${provingTime}ms` : 'skipped';
+        console.log(` -> ${name}: ${result.totalGateCount} gates, Gas (DA: ${daGas}, L2: ${l2Gas}), Proving: ${provingDisplay}`);
+        return result;
+    }
+    catch (error) {
+        console.error(`Error profiling ${name}:`, error.message);
+        throw error;
+    }
+};

package/dist/systemInfo.d.ts

@@ -0,0 +1,15 @@
+export interface SystemInfo {
+    /** CPU model name */
+    cpuModel: string;
+    /** Number of available CPU cores */
+    cpuCores: number;
+    /** Total system memory in GiB */
+    totalMemoryGiB: number;
+    /** CPU architecture (e.g., 'x64', 'arm64') */
+    arch: string;
+}
+/**
+ * Collects system information for benchmark reports.
+ * Returns N/A values if information cannot be determined.
+ */
+export declare function getSystemInfo(): SystemInfo;