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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aztec/end-to-end",
-  "version": "0.0.0-test.1",
+  "version": "0.0.1-commit.b655e406",
   "type": "module",
   "exports": "./dest/index.js",
   "inherits": [
@@ -11,7 +11,6 @@
     "build": "yarn clean && tsc -b",
     "build:dev": "tsc -b --watch",
     "clean": "rm -rf ./dest .tsbuildinfo",
-    "formatting:fix": "run -T eslint --fix ./src && run -T prettier -w ./src",
     "test:with-alerts": "./scripts/test-with-alerts.sh",
     "test:e2e": "LOG_LEVEL=${LOG_LEVEL:-verbose} NODE_NO_WARNINGS=1 node --experimental-vm-modules ../node_modules/.bin/jest --testTimeout=300000 --forceExit",
     "test:e2e-docker": "./scripts/run_test.sh simple",
@@ -26,89 +25,93 @@
     "formatting": "run -T prettier --check ./src && run -T eslint ./src"
   },
   "dependencies": {
-    "@aztec/accounts": "0.0.0-test.1",
-    "@aztec/archiver": "0.0.0-test.1",
-    "@aztec/aztec": "0.0.0-test.1",
-    "@aztec/aztec-node": "0.0.0-test.1",
-    "@aztec/aztec.js": "0.0.0-test.1",
-    "@aztec/bb-prover": "0.0.0-test.1",
-    "@aztec/blob-lib": "0.0.0-test.1",
-    "@aztec/blob-sink": "0.0.0-test.1",
-    "@aztec/bot": "0.0.0-test.1",
-    "@aztec/constants": "0.0.0-test.1",
-    "@aztec/entrypoints": "0.0.0-test.1",
-    "@aztec/epoch-cache": "0.0.0-test.1",
-    "@aztec/ethereum": "0.0.0-test.1",
-    "@aztec/foundation": "0.0.0-test.1",
-    "@aztec/kv-store": "0.0.0-test.1",
-    "@aztec/l1-artifacts": "0.0.0-test.1",
-    "@aztec/merkle-tree": "0.0.0-test.1",
-    "@aztec/noir-contracts.js": "0.0.0-test.1",
-    "@aztec/noir-protocol-circuits-types": "0.0.0-test.1",
-    "@aztec/p2p": "0.0.0-test.1",
-    "@aztec/protocol-contracts": "0.0.0-test.1",
-    "@aztec/prover-client": "0.0.0-test.1",
-    "@aztec/prover-node": "0.0.0-test.1",
-    "@aztec/pxe": "0.0.0-test.1",
-    "@aztec/sequencer-client": "0.0.0-test.1",
-    "@aztec/simulator": "0.0.0-test.1",
-    "@aztec/stdlib": "0.0.0-test.1",
-    "@aztec/telemetry-client": "0.0.0-test.1",
-    "@aztec/validator-client": "0.0.0-test.1",
-    "@aztec/world-state": "0.0.0-test.1",
+    "@aztec/accounts": "0.0.1-commit.b655e406",
+    "@aztec/archiver": "0.0.1-commit.b655e406",
+    "@aztec/aztec": "0.0.1-commit.b655e406",
+    "@aztec/aztec-node": "0.0.1-commit.b655e406",
+    "@aztec/aztec.js": "0.0.1-commit.b655e406",
+    "@aztec/bb-prover": "0.0.1-commit.b655e406",
+    "@aztec/blob-lib": "0.0.1-commit.b655e406",
+    "@aztec/blob-sink": "0.0.1-commit.b655e406",
+    "@aztec/bot": "0.0.1-commit.b655e406",
+    "@aztec/cli": "0.0.1-commit.b655e406",
+    "@aztec/constants": "0.0.1-commit.b655e406",
+    "@aztec/entrypoints": "0.0.1-commit.b655e406",
+    "@aztec/epoch-cache": "0.0.1-commit.b655e406",
+    "@aztec/ethereum": "0.0.1-commit.b655e406",
+    "@aztec/foundation": "0.0.1-commit.b655e406",
+    "@aztec/kv-store": "0.0.1-commit.b655e406",
+    "@aztec/l1-artifacts": "0.0.1-commit.b655e406",
+    "@aztec/merkle-tree": "0.0.1-commit.b655e406",
+    "@aztec/node-keystore": "0.0.1-commit.b655e406",
+    "@aztec/noir-contracts.js": "0.0.1-commit.b655e406",
+    "@aztec/noir-noirc_abi": "0.0.1-commit.b655e406",
+    "@aztec/noir-protocol-circuits-types": "0.0.1-commit.b655e406",
+    "@aztec/noir-test-contracts.js": "0.0.1-commit.b655e406",
+    "@aztec/p2p": "0.0.1-commit.b655e406",
+    "@aztec/protocol-contracts": "0.0.1-commit.b655e406",
+    "@aztec/prover-client": "0.0.1-commit.b655e406",
+    "@aztec/prover-node": "0.0.1-commit.b655e406",
+    "@aztec/pxe": "0.0.1-commit.b655e406",
+    "@aztec/sequencer-client": "0.0.1-commit.b655e406",
+    "@aztec/simulator": "0.0.1-commit.b655e406",
+    "@aztec/slasher": "0.0.1-commit.b655e406",
+    "@aztec/stdlib": "0.0.1-commit.b655e406",
+    "@aztec/telemetry-client": "0.0.1-commit.b655e406",
+    "@aztec/test-wallet": "0.0.1-commit.b655e406",
+    "@aztec/validator-client": "0.0.1-commit.b655e406",
+    "@aztec/world-state": "0.0.1-commit.b655e406",
     "@iarna/toml": "^2.2.5",
-    "@jest/globals": "^29.5.0",
-    "@noble/curves": "^1.0.0",
+    "@jest/globals": "^30.0.0",
+    "@noble/curves": "=1.0.0",
     "@swc/core": "^1.4.11",
     "@swc/jest": "^0.2.36",
     "@types/fs-extra": "^11.0.2",
-    "@types/jest": "^29.5.0",
-    "@types/koa": "^2.13.9",
+    "@types/jest": "^30.0.0",
+    "@types/koa": "^2.15.0",
     "@types/koa-static": "^4.0.2",
-    "@types/levelup": "^5.1.2",
     "@types/lodash.every": "^4.6.7",
-    "@types/memdown": "^3.0.3",
-    "@types/node": "^18.7.23",
+    "@types/node": "^22.15.17",
     "@viem/anvil": "^0.0.9",
     "buffer": "^6.0.3",
-    "crypto-browserify": "^3.12.0",
+    "crypto-browserify": "^3.12.1",
     "fs-extra": "^11.2.0",
     "get-port": "^7.1.0",
     "glob": "^10.3.10",
-    "jest": "^29.5.0",
-    "jest-extended": "^4.0.2",
-    "jest-mock-extended": "^3.0.5",
-    "koa": "^2.14.2",
+    "jest": "^30.0.0",
+    "jest-extended": "^6.0.0",
+    "jest-mock-extended": "^4.0.0",
+    "koa": "^2.16.1",
     "koa-static": "^5.0.0",
-    "levelup": "^5.1.1",
     "lodash.chunk": "^4.2.0",
     "lodash.compact": "^3.0.1",
     "lodash.every": "^4.6.0",
     "lodash.omit": "^4.5.0",
-    "memdown": "^6.1.1",
+    "msgpackr": "^1.11.2",
     "process": "^0.11.10",
+    "snappy": "^7.2.2",
     "stream-browserify": "^3.0.0",
     "string-argv": "^0.3.2",
-    "ts-loader": "^9.4.4",
+    "ts-loader": "^9.5.4",
     "ts-node": "^10.9.1",
     "tslib": "^2.4.0",
-    "typescript": "^5.0.4",
+    "typescript": "^5.3.3",
     "util": "^0.12.5",
-    "viem": "2.22.8",
+    "viem": "npm:@spalladino/viem@2.38.2-eip7594.0",
     "zod": "^3.23.8"
   },
   "devDependencies": {
     "0x": "^5.7.0",
-    "@jest/globals": "^29.5.0",
-    "@types/jest": "^29.5.0",
+    "@jest/globals": "^30.0.0",
+    "@types/jest": "^30.0.0",
     "@types/js-yaml": "^4.0.9",
     "@types/lodash.chunk": "^4.2.9",
     "concurrently": "^7.6.0",
-    "jest": "^29.5.0",
-    "jest-extended": "^4.0.2",
+    "jest": "^30.0.0",
+    "jest-extended": "^6.0.0",
     "js-yaml": "^4.1.0",
     "ts-node": "^10.9.1",
-    "typescript": "^5.0.4"
+    "typescript": "^5.3.3"
   },
   "files": [
     "dest",
@@ -117,11 +120,12 @@
   ],
   "types": "./dest/index.d.ts",
   "engines": {
-    "node": ">=18"
+    "node": ">=20.10"
   },
   "jest": {
     "slowTestThreshold": 300,
     "setupFilesAfterEnv": [
+      "../../foundation/src/jest/setupAfterEnv.mjs",
       "jest-extended/all",
       "./shared/jest_setup.ts"
     ],
@@ -155,6 +159,7 @@
     "testTimeout": 120000,
     "setupFiles": [
       "../../foundation/src/jest/setup.mjs"
-    ]
+    ],
+    "testEnvironment": "../../foundation/src/jest/env.mjs"
   }
 }

package/src/bench/client_flows/benchmark.ts

@@ -0,0 +1,341 @@
+import {
+  ContractFunctionInteraction,
+  DeployMethod,
+  type DeployOptions,
+  type ProfileInteractionOptions,
+} from '@aztec/aztec.js/contracts';
+import type { Logger } from '@aztec/aztec.js/log';
+import { createLogger } from '@aztec/foundation/log';
+import { type PrivateExecutionStep, serializePrivateExecutionSteps } from '@aztec/stdlib/kernel';
+import type { ProvingStats, ProvingTimings, SimulationStats, SimulationTimings } from '@aztec/stdlib/tx';
+
+import assert from 'node:assert';
+import { mkdir, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+
+import type { GithubActionBenchmarkResult } from '../utils.js';
+
+const logger = createLogger('bench:profile_capture');
+
+const logLevel = ['silent', 'fatal', 'error', 'warn', 'info', 'verbose', 'debug', 'trace'] as const;
+type LogLevel = (typeof logLevel)[number];
+
+export 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',
+  'memory',
+  'nnf',
+  '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;
+  }
+}
+
+export type ProverType = 'wasm' | 'native';
+
+type CallRecording = {
+  // Number of times the function has been called
+  calls: number;
+  // Maximum time taken by the function (in ms)
+  max: number;
+  // Minimum time taken by the function (in ms)
+  min: number;
+  // Average time taken by the function (in ms)
+  avg: number;
+  // Total time spent in the function, computed as sum of all calls (in ms)
+  total: number;
+};
+
+type Step = Pick<PrivateExecutionStep, 'functionName' | 'gateCount'> & {
+  time: number;
+  accGateCount?: number;
+  oracles: Record<string, CallRecording>;
+};
+
+type ClientFlowBenchmark = {
+  name: string;
+  timings: Omit<ProvingTimings & SimulationTimings, 'perFunction'> & { witgen: number };
+  maxMemory: number;
+  rpc: Record<string, CallRecording>;
+  proverType: ProverType;
+  minimumTrace: StructuredTrace;
+  totalGateCount: number;
+  steps: Step[];
+  error: string | undefined;
+};
+
+function getMinimumTrace(logs: Log[]): StructuredTrace {
+  const LOG_MESSAGE_CANDIDATE_PADDING = 5;
+  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 + LOG_MESSAGE_CANDIDATE_PADDING,
+  );
+
+  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;
+}
+
+function getMaxMemory(logs: Log[]): number {
+  const candidateLogs = logs.slice(0, 100).filter(log => /\(mem: .*MiB\)/.test(log.message));
+  const usage = candidateLogs.map(log => {
+    const memStr = log ? log.message.slice(log.message.indexOf('(mem: ') + 6, log.message.indexOf('MiB') - 3) : '';
+    return memStr ? parseInt(memStr) : 0;
+  });
+  return Math.max(...usage);
+}
+
+export function generateBenchmark(
+  flow: string,
+  logs: Log[],
+  stats: ProvingStats | SimulationStats,
+  privateExecutionSteps: PrivateExecutionStep[],
+  proverType: ProverType,
+  error: string | undefined,
+): ClientFlowBenchmark {
+  let maxMemory = 0;
+  let minimumTrace: StructuredTrace;
+  try {
+    minimumTrace = getMinimumTrace(logs);
+    maxMemory = getMaxMemory(logs);
+  } catch {
+    logger.warn(`Failed obtain minimum trace and max memory for ${flow}. Did you run with REAL_PROOFS=1?`);
+  }
+
+  const steps = privateExecutionSteps.reduce<Step[]>((acc, step, i) => {
+    const previousAccGateCount = i === 0 ? 0 : acc[i - 1].accGateCount!;
+    return [
+      ...acc,
+      {
+        functionName: step.functionName,
+        gateCount: step.gateCount,
+        accGateCount: previousAccGateCount + step.gateCount!,
+        time: step.timings.witgen,
+        oracles: Object.entries(step.timings.oracles ?? {}).reduce(
+          (acc, [oracleName, oracleData]) => {
+            const total = oracleData.times.reduce((sum, time) => sum + time, 0);
+            const calls = oracleData.times.length;
+            acc[oracleName] = {
+              calls,
+              max: Math.max(...oracleData.times),
+              min: Math.min(...oracleData.times),
+              total,
+              avg: total / calls,
+            };
+            return acc;
+          },
+          {} as Record<string, CallRecording>,
+        ),
+      },
+    ];
+  }, []);
+  const timings = stats.timings;
+  const totalGateCount = steps[steps.length - 1].accGateCount;
+  return {
+    name: flow,
+    timings: {
+      total: timings.total,
+      sync: timings.sync!,
+      proving: (timings as ProvingTimings).proving,
+      unaccounted: timings.unaccounted,
+      witgen: timings.perFunction.reduce((acc, fn) => acc + fn.time, 0),
+    },
+    rpc: Object.entries(stats.nodeRPCCalls ?? {}).reduce(
+      (acc, [RPCName, RPCCalls]) => {
+        const total = RPCCalls.times.reduce((sum, time) => sum + time, 0);
+        const calls = RPCCalls.times.length;
+        acc[RPCName] = {
+          calls,
+          max: Math.max(...RPCCalls.times),
+          min: Math.min(...RPCCalls.times),
+          total,
+          avg: total / calls,
+        };
+        return acc;
+      },
+      {} as Record<string, CallRecording>,
+    ),
+    maxMemory,
+    proverType,
+    minimumTrace: minimumTrace!,
+    totalGateCount: totalGateCount!,
+    steps,
+    error,
+  };
+}
+
+export function convertProfileToGHBenchmark(benchmark: ClientFlowBenchmark): GithubActionBenchmarkResult[] {
+  const totalRPCCalls = Object.values(benchmark.rpc).reduce((acc, call) => acc + call.calls, 0);
+  const benches = [
+    {
+      name: `${benchmark.name}/witgen`,
+      value: benchmark.timings.witgen,
+      unit: 'ms',
+    },
+
+    {
+      name: `${benchmark.name}/total`,
+      value: benchmark.timings.total,
+      unit: 'ms',
+    },
+    {
+      name: `${benchmark.name}/sync`,
+      value: benchmark.timings.sync!,
+      unit: 'ms',
+    },
+    {
+      name: `${benchmark.name}/unaccounted`,
+      value: benchmark.timings.unaccounted,
+      unit: 'ms',
+    },
+
+    {
+      name: `${benchmark.name}/total_gate_count`,
+      value: benchmark.totalGateCount,
+      unit: 'gates',
+    },
+    {
+      name: `${benchmark.name}/rpc`,
+      value: totalRPCCalls,
+      unit: 'calls',
+    },
+  ];
+  if (benchmark.timings.proving) {
+    benches.push({
+      name: `${benchmark.name}/proving`,
+      value: benchmark.timings.proving,
+      unit: 'ms',
+    });
+  }
+  if (benchmark.maxMemory) {
+    benches.push({
+      name: `${benchmark.name}/max_memory`,
+      value: benchmark.maxMemory,
+      unit: 'MiB',
+    });
+  }
+  return benches;
+}
+
+export async function captureProfile(
+  label: string,
+  interaction: ContractFunctionInteraction | DeployMethod,
+  opts: Omit<ProfileInteractionOptions & DeployOptions, 'profileMode'>,
+  expectedSteps?: number,
+) {
+  // Make sure the proxy logger starts from a clean slate
+  ProxyLogger.getInstance().flushLogs();
+  const result = await interaction.profile({ ...opts, profileMode: 'full', skipProofGeneration: false });
+  const logs = ProxyLogger.getInstance().getLogs();
+  if (expectedSteps !== undefined && result.executionSteps.length !== expectedSteps) {
+    throw new Error(`Expected ${expectedSteps} execution steps, got ${result.executionSteps.length}`);
+  }
+  const benchmark = generateBenchmark(label, logs, result.stats, result.executionSteps, 'wasm', undefined);
+
+  const ivcFolder = process.env.CAPTURE_IVC_FOLDER;
+  if (ivcFolder) {
+    logger.info(`Capturing chonk execution profile for ${label}`);
+
+    const resultsDirectory = join(ivcFolder, label);
+    logger.info(`Writing private execution steps to ${resultsDirectory}`);
+    await mkdir(resultsDirectory, { recursive: true });
+    // Write the chonk files read by the prover.
+    const ivcInputsPath = join(resultsDirectory, 'ivc-inputs.msgpack');
+    await writeFile(ivcInputsPath, serializePrivateExecutionSteps(result.executionSteps));
+    await writeFile(join(resultsDirectory, 'logs.json'), JSON.stringify(logs, null, 2));
+    await writeFile(join(resultsDirectory, 'benchmark.json'), JSON.stringify(benchmark, null, 2));
+    logger.info(`Wrote private execution steps to ${resultsDirectory}`);
+  }
+
+  const benchOutput = process.env.BENCH_OUTPUT;
+  if (benchOutput) {
+    await mkdir(benchOutput, { recursive: true });
+    const ghBenchmark = convertProfileToGHBenchmark(benchmark);
+    const benchFile = join(benchOutput, `${label}.bench.json`);
+    await writeFile(benchFile, JSON.stringify(ghBenchmark));
+    logger.info(`Wrote benchmark to ${benchFile}`);
+  }
+
+  return result;
+}