@aztec-labs/simulator 6.0.0-nightly.20260829

package/package.json

@@ -0,0 +1,109 @@
+{
+  "name": "@aztec-labs/simulator",
+  "version": "6.0.0-nightly.20260829",
+  "type": "module",
+  "exports": {
+    "./server": "./dest/server.js",
+    "./client": "./dest/client.js",
+    "./public/fixtures": "./dest/public/fixtures/index.js"
+  },
+  "typedocOptions": {
+    "entryPoints": [
+      "./src/index.ts"
+    ],
+    "name": "Simulator",
+    "tsconfig": "./tsconfig.json"
+  },
+  "scripts": {
+    "build": "yarn clean && ../scripts/tsc.sh",
+    "build:dev": "../scripts/tsc.sh --watch",
+    "clean": "rm -rf ./dest .tsbuildinfo",
+    "test": "NODE_NO_WARNINGS=1 node --experimental-vm-modules ../node_modules/.bin/jest --passWithNoTests --maxWorkers=${JEST_MAX_WORKERS:-8}",
+    "build:fuzzer": "yarn clean && ../scripts/tsc.sh"
+  },
+  "inherits": [
+    "../package.common.json"
+  ],
+  "jest": {
+    "moduleNameMapper": {
+      "^(\\.{1,2}/.*)\\.[cm]?js$": "$1"
+    },
+    "testRegex": "./src/.*\\.test\\.(js|mjs|ts)$",
+    "rootDir": "./src",
+    "transform": {
+      "^.+\\.tsx?$": [
+        "@swc/jest",
+        {
+          "jsc": {
+            "parser": {
+              "syntax": "typescript",
+              "decorators": true
+            },
+            "transform": {
+              "decoratorVersion": "2022-03"
+            }
+          }
+        }
+      ]
+    },
+    "extensionsToTreatAsEsm": [
+      ".ts"
+    ],
+    "reporters": [
+      "default"
+    ],
+    "testTimeout": 120000,
+    "setupFiles": [
+      "../../foundation/src/jest/setup.mjs"
+    ],
+    "testEnvironment": "../../foundation/src/jest/env.mjs",
+    "setupFilesAfterEnv": [
+      "../../foundation/src/jest/setupAfterEnv.mjs"
+    ]
+  },
+  "dependencies": {
+    "@aztec-labs/constants": "6.0.0-nightly.20260829",
+    "@aztec-labs/foundation": "6.0.0-nightly.20260829",
+    "@aztec-labs/protocol-contracts": "6.0.0-nightly.20260829",
+    "@aztec-labs/standard-contracts": "6.0.0-nightly.20260829",
+    "@aztec-labs/stdlib": "6.0.0-nightly.20260829",
+    "@aztec-labs/telemetry-client": "6.0.0-nightly.20260829",
+    "@aztec-labs/world-state": "6.0.0-nightly.20260829",
+    "@aztec/bb-avm-sim": "6.0.0-nightly.20260826",
+    "@aztec/cdb": "6.0.0-nightly.20260826",
+    "@aztec/ipc-runtime": "6.0.0-nightly.20260826",
+    "@aztec/noir-acvm_js": "6.0.0-nightly.20260826",
+    "@aztec/noir-noirc_abi": "6.0.0-nightly.20260826",
+    "@aztec/noir-types": "6.0.0-nightly.20260826",
+    "lodash.clonedeep": "^4.5.0",
+    "lodash.merge": "^4.6.2",
+    "msgpackr": "^1.11.2",
+    "tslib": "^2.4.0"
+  },
+  "devDependencies": {
+    "@aztec-labs/noir-contracts.js": "6.0.0-nightly.20260829",
+    "@aztec-labs/noir-test-contracts.js": "6.0.0-nightly.20260829",
+    "@jest/globals": "^30.0.0",
+    "@types/jest": "^30.0.0",
+    "@types/lodash.clonedeep": "^4.5.7",
+    "@types/lodash.merge": "^4.6.9",
+    "@types/node": "^22.15.17",
+    "@typescript/native-preview": "7.0.0-dev.20260113.1",
+    "istanbul-lib-hook": "^3.0.0",
+    "istanbul-lib-instrument": "^6.0.3",
+    "jest": "^30.0.0",
+    "jest-mock-extended": "^4.0.0",
+    "ts-node": "^10.9.1",
+    "typescript": "^5.3.3",
+    "viem": "npm:@aztec/viem@2.38.2"
+  },
+  "files": [
+    "dest",
+    "src",
+    "!*.test.*"
+  ],
+  "types": "./dest/index.d.ts",
+  "engines": {
+    "node": ">=20.10"
+  }
+}

package/src/client.ts

@@ -0,0 +1,5 @@
+export * from './private/acvm/index.js';
+export { WASMSimulator } from './private/acvm_wasm.js';
+export type { ACVMSuccess } from './private/acvm_native.js';
+export { type CircuitSimulator, type DecodedError } from './private/circuit_simulator.js';
+export * from './common/index.js';

package/src/common/errors.ts

@@ -0,0 +1,219 @@
+import type { RawAssertionPayload } from '@aztec/noir-acvm_js';
+import { abiDecodeError } from '@aztec/noir-noirc_abi';
+
+import type { Fr } from '@aztec-labs/foundation/curves/bn254';
+import { jsonStringify } from '@aztec-labs/foundation/json-rpc';
+import type {
+  BrilligFunctionId,
+  DebugFileMap,
+  DebugInfo,
+  FunctionAbi,
+  LocationNodeDebugInfo,
+  OpcodeLocation,
+} from '@aztec-labs/stdlib/abi';
+import {
+  type FailingFunction,
+  type NoirCallStack,
+  SimulationError,
+  type SourceCodeLocation,
+} from '@aztec-labs/stdlib/errors';
+
+/**
+ * An error that occurred during the execution of a function.
+ * @param message - the error message
+ * @param failingFunction - the Aztec function that failed
+ * @param noirCallStack - the internal call stack of the function that failed (within the failing Aztec function)
+ * @param options - additional error options (an optional "cause" entry allows for a recursive error stack where
+ *                  an error's cause may be an ExecutionError itself)
+ */
+export class ExecutionError extends Error {
+  constructor(
+    message: string,
+    /**
+     * The function that failed.
+     */
+    public failingFunction: FailingFunction,
+    /**
+     * The noir call stack of the function that failed.
+     */
+    public noirCallStack?: NoirCallStack,
+    options?: ErrorOptions,
+  ) {
+    super(message, options);
+  }
+}
+
+/**
+ * Traverses the cause chain of an error.
+ * @param error - The error to start from.
+ * @param callback - A callback on every error, including the first one.
+ */
+export function traverseCauseChain(error: Error, callback: (error: Error) => void) {
+  let currentError: Error | undefined = error;
+  while (currentError) {
+    callback(currentError);
+    if (currentError.cause && currentError.cause instanceof Error) {
+      currentError = currentError.cause;
+    } else {
+      currentError = undefined;
+    }
+  }
+}
+
+/**
+ * Creates a simulation error from an error chain generated during the execution of a function.
+ * @param error - The error thrown during execution.
+ * @returns - A simulation error.
+ */
+export function createSimulationError(error: Error, revertData?: Fr[]): SimulationError {
+  let rootCause = error;
+  let noirCallStack: NoirCallStack | undefined = undefined;
+  const aztecCallStack: FailingFunction[] = [];
+
+  traverseCauseChain(error, cause => {
+    rootCause = cause;
+    if (cause instanceof ExecutionError) {
+      aztecCallStack.push(cause.failingFunction);
+      if (cause.noirCallStack) {
+        noirCallStack = cause.noirCallStack;
+      }
+    }
+  });
+
+  return new SimulationError(rootCause.message, aztecCallStack, revertData, noirCallStack, { cause: rootCause });
+}
+
+/**
+ * Resolves the source code locations from an array of opcode locations
+ */
+export function resolveOpcodeLocations(
+  opcodeLocations: OpcodeLocation[],
+  debug: DebugInfo,
+  files: DebugFileMap,
+  brilligFunctionId?: BrilligFunctionId,
+): SourceCodeLocation[] {
+  let locations = opcodeLocations.flatMap(opcodeLocation =>
+    getSourceCodeLocationsFromOpcodeLocation(opcodeLocation, debug, files, brilligFunctionId),
+  );
+
+  // Adds the acir call stack if the last location is a brillig opcode
+  if (locations.length > 0) {
+    const decomposedOpcodeLocation = opcodeLocations[opcodeLocations.length - 1].split('.');
+    if (decomposedOpcodeLocation.length === 2) {
+      const acirCallstackId = debug.acir_locations[decomposedOpcodeLocation[0]];
+      if (acirCallstackId !== undefined) {
+        const callStack = debug.location_tree.locations[acirCallstackId];
+        const acirCallstack = getCallStackFromLocationNode(callStack, debug.location_tree.locations, files);
+        locations = acirCallstack.concat(locations);
+      }
+    }
+  }
+  return locations;
+}
+
+function getCallStackFromLocationNode(
+  callStack: LocationNodeDebugInfo,
+  locationTree: LocationNodeDebugInfo[],
+  files: DebugFileMap,
+): SourceCodeLocation[] {
+  const result: SourceCodeLocation[] = [];
+
+  while (callStack.parent !== null) {
+    const { file: fileId, span } = callStack.value;
+
+    const { path, source } = files[fileId];
+
+    const locationText = source.substring(span.start, span.end);
+    const precedingText = source.substring(0, span.start);
+    const previousLines = precedingText.split('\n');
+    // Lines and columns in stacks are one indexed.
+    const line = previousLines.length;
+    const column = previousLines[previousLines.length - 1].length + 1;
+
+    // Unshift since we are exploring child nodes first
+    result.unshift({
+      filePath: path,
+      line,
+      column,
+      fileSource: source,
+      locationText,
+    });
+
+    callStack = locationTree[callStack.parent];
+  }
+
+  return result;
+}
+/**
+ * Extracts the call stack from the location of a failing opcode and the debug metadata.
+ * One opcode can point to multiple calls due to inlining.
+ */
+function getSourceCodeLocationsFromOpcodeLocation(
+  opcodeLocation: string,
+  debug: DebugInfo,
+  files: DebugFileMap,
+  brilligFunctionId?: BrilligFunctionId,
+): SourceCodeLocation[] {
+  let callStackID = debug.acir_locations[opcodeLocation];
+  const brilligLocation = extractBrilligLocation(opcodeLocation);
+  if (brilligFunctionId !== undefined && brilligLocation !== undefined) {
+    callStackID = debug.brillig_locations[brilligFunctionId][brilligLocation];
+    if (callStackID === undefined) {
+      return [];
+    }
+  }
+
+  if (callStackID === undefined) {
+    return [];
+  }
+  const callStack = debug.location_tree.locations[callStackID];
+  return getCallStackFromLocationNode(callStack, debug.location_tree.locations, files);
+}
+
+/**
+ * Extracts a brillig location from an opcode location.
+ */
+function extractBrilligLocation(opcodeLocation: string): string | undefined {
+  const splitted = opcodeLocation.split('.');
+  if (splitted.length === 2) {
+    return splitted[1];
+  }
+  return undefined;
+}
+
+export function resolveAssertionMessage(errorPayload: RawAssertionPayload, abi: FunctionAbi): string | undefined {
+  const decoded = abiDecodeError(
+    { parameters: [], error_types: abi.errorTypes, return_type: null }, // eslint-disable-line camelcase
+    errorPayload,
+  );
+
+  if (typeof decoded === 'string') {
+    return decoded;
+  } else {
+    return jsonStringify(decoded);
+  }
+}
+
+export function resolveAssertionMessageFromRevertData(revertData: Fr[], abi: FunctionAbi): string | undefined {
+  if (revertData.length == 0) {
+    return undefined;
+  }
+
+  const [errorSelector, ...errorData] = revertData;
+
+  return resolveAssertionMessage(
+    {
+      selector: errorSelector.toBigInt().toString(),
+      data: errorData.map(f => f.toString()),
+    },
+    abi,
+  );
+}
+
+export function resolveAssertionMessageFromError(err: Error, abi: FunctionAbi): string {
+  if (typeof err === 'object' && err !== null && 'rawAssertionPayload' in err && err.rawAssertionPayload) {
+    return `Assertion failed: ${resolveAssertionMessage(err.rawAssertionPayload as RawAssertionPayload, abi)}`;
+  } else {
+    return err.message;
+  }
+}

package/src/common/index.ts

@@ -0,0 +1,2 @@
+export * from './errors.js';
+export * from './stats/index.js';

package/src/common/stats/index.ts

@@ -0,0 +1 @@
+export * from './stats.js';

package/src/common/stats/stats.ts

@@ -0,0 +1,20 @@
+import type { Logger } from '@aztec-labs/foundation/log';
+import type { CircuitName, CircuitSimulationStats } from '@aztec-labs/stdlib/stats';
+
+export function emitCircuitSimulationStats(
+  circuitName: CircuitName,
+  duration: number,
+  inputSize: number,
+  outputSize: number,
+  logger: Logger,
+) {
+  const stats: CircuitSimulationStats = {
+    eventName: 'circuit-simulation',
+    circuitName,
+    inputSize,
+    outputSize,
+    duration,
+  };
+
+  logger.debug('Circuit simulation stats', stats);
+}

package/src/private/acvm/acvm.ts

@@ -0,0 +1,114 @@
+import {
+  type ExecutionError,
+  type ForeignCallInput,
+  type ForeignCallOutput,
+  executeCircuitWithReturnWitness,
+} from '@aztec/noir-acvm_js';
+
+import { type Logger, type LoggerBindings, resolveLogger } from '@aztec-labs/foundation/log';
+import type { FunctionDebugMetadata } from '@aztec-labs/stdlib/abi';
+import type { NoirCallStack } from '@aztec-labs/stdlib/errors';
+
+import { resolveOpcodeLocations, traverseCauseChain } from '../../common/errors.js';
+import type { ACVMWitness } from './acvm_types.js';
+
+/**
+ * The callback interface for the ACIR.
+ */
+export type ACIRCallback = Record<string, (...args: ForeignCallInput[]) => Promise<ForeignCallOutput[]>>;
+
+export type ACIRCallbackStats = { times: number[] };
+
+/**
+ * The result of executing an ACIR.
+ */
+export interface ACIRExecutionResult {
+  /**
+   * An execution result contains two witnesses.
+   * 1. The partial witness of the execution.
+   * 2. The return witness which contains the given public return values within the full witness.
+   */
+  partialWitness: ACVMWitness;
+  returnWitness: ACVMWitness;
+  oracles?: Record<string, ACIRCallbackStats>;
+}
+
+/**
+ * The function call that executes an ACIR.
+ * @param acir - The ACIR circuit bytecode to execute.
+ * @param initialWitness - The initial witness map defining all of the inputs to `circuit`.
+ * @param callback - A callback to process any foreign calls from the circuit.
+ * @param logger - Optional logger for ACVM execution logs.
+ * @returns The solved witness calculated by executing the circuit on the provided inputs, as well as the return
+ * witness indices as specified by the circuit.
+ */
+export async function acvm(
+  acir: Buffer,
+  initialWitness: ACVMWitness,
+  callback: ACIRCallback,
+  loggerOrBindings?: Logger | LoggerBindings,
+): Promise<ACIRExecutionResult> {
+  const logger = resolveLogger('simulator:acvm', loggerOrBindings);
+  const solvedAndReturnWitness = await executeCircuitWithReturnWitness(
+    acir,
+    initialWitness,
+    (name: string, args: ForeignCallInput[]) => {
+      try {
+        logger.debug(`Oracle callback ${name}`);
+        const oracleFunction = callback[name];
+        if (!oracleFunction) {
+          throw new Error(`Oracle callback ${name} not found`);
+        }
+
+        return oracleFunction.call(callback, ...args);
+      } catch (err) {
+        let typedError: Error;
+        if (err instanceof Error) {
+          typedError = err;
+        } else {
+          typedError = new Error(`Error in oracle callback ${err}`);
+        }
+        logger.error(`Error in oracle callback ${name}: ${typedError.message}`);
+        throw typedError;
+      }
+    },
+  ).catch((err: Error) => {
+    // Wasm callbacks act as a boundary for stack traces, so we capture it here and complete the error if it happens.
+    const stack = new Error().stack;
+
+    traverseCauseChain(err, cause => {
+      if (cause.stack) {
+        cause.stack += stack;
+      }
+    });
+
+    throw err;
+  });
+
+  return { partialWitness: solvedAndReturnWitness.solvedWitness, returnWitness: solvedAndReturnWitness.returnWitness };
+}
+
+/**
+ * Extracts the call stack from an thrown by the acvm.
+ * @param error - The error to extract from.
+ * @param debug - The debug metadata of the function called.
+ * @returns The call stack, if available.
+ */
+export function extractCallStack(
+  error: Error | ExecutionError,
+  debug?: FunctionDebugMetadata,
+): NoirCallStack | undefined {
+  if (!('callStack' in error) || !error.callStack) {
+    return undefined;
+  }
+  const { callStack, brilligFunctionId } = error;
+  if (!debug) {
+    return callStack;
+  }
+
+  try {
+    return resolveOpcodeLocations(callStack, debug.debugSymbols, debug.files, brilligFunctionId);
+  } catch {
+    return callStack;
+  }
+}

package/src/private/acvm/acvm_types.ts

@@ -0,0 +1,11 @@
+import type { WitnessMap } from '@aztec/noir-acvm_js';
+
+/**
+ * ACVMField
+ */
+export type ACVMField = string;
+
+/**
+ * The format for witnesses of the ACVM.
+ */
+export type ACVMWitness = WitnessMap;

package/src/private/acvm/deserialize.ts

@@ -0,0 +1,58 @@
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+import { hexToBuffer } from '@aztec-labs/foundation/string';
+
+import type { ACVMField, ACVMWitness } from './acvm_types.js';
+
+/**
+ * Converts a Noir BoundedVec of Fields into an Fr array. Note that BoundedVecs are structs, and therefore translated as
+ * two separate ACVMField values (an array and a single field).
+ *
+ * @param storage The array with the BoundedVec's storage (i.e. BoundedVec::storage())
+ * @param length The length of the BoundedVec (i.e. BoundedVec::len())
+ * @returns An array with the same content as the Noir version. Elements past the length are discarded.
+ */
+export function fromBoundedVec(storage: ACVMField[], length: ACVMField): Fr[] {
+  return storage.slice(0, Fr.fromString(length).toNumber()).map(Fr.fromString);
+}
+
+/**
+ * Converts a Noir BoundedVec of unsigned integers into a Buffer. Note that BoundedVecs are structs, and therefore
+ * translated as two separate ACVMField values (an array and a single field).
+ *
+ * @param storage The array with the BoundedVec's storage (i.e. BoundedVec::storage())
+ * @param length The length of the BoundedVec (i.e. BoundedVec::len())
+ * @param uintBitSize If it's an array of Noir u8's, put `8`, etc.
+ * @returns A buffer containing the unsigned integers tightly packed
+ */
+export function fromUintBoundedVec(storage: ACVMField[], length: ACVMField, uintBitSize: number): Buffer {
+  if (uintBitSize % 8 !== 0) {
+    throw new Error(`u${uintBitSize} is not a supported type in Noir`);
+  }
+  const uintByteSize = uintBitSize / 8;
+  const boundedStorage = storage.slice(0, Fr.fromString(length).toNumber());
+  return Buffer.concat(boundedStorage.map(str => hexToBuffer(str).subarray(-uintByteSize)));
+}
+
+/**
+ * Transforms a witness map to its field elements.
+ * @param witness - The witness to extract from.
+ * @returns The return values.
+ */
+export function witnessMapToFields(witness: ACVMWitness): Fr[] {
+  const sortedKeys = [...witness.keys()].sort((a, b) => a - b);
+  return sortedKeys.map(key => witness.get(key)!).map(Fr.fromString);
+}
+
+/**
+ * Converts an array of Noir unsigned integers to a single tightly-packed buffer.
+ * @param uintBitSize If it's an array of Noir u8's, put `8`, etc.
+ * @returns A buffer where each byte is correctly represented as a single byte in the buffer.
+ * Copy of the function in txe/src/util/encoding.ts.
+ */
+export function fromUintArray(obj: ACVMField[], uintBitSize: number): Buffer {
+  if (uintBitSize % 8 !== 0) {
+    throw new Error(`u${uintBitSize} is not a supported type in Noir`);
+  }
+  const uintByteSize = uintBitSize / 8;
+  return Buffer.concat(obj.map(str => hexToBuffer(str).slice(-uintByteSize)));
+}

package/src/private/acvm/index.ts

@@ -0,0 +1,4 @@
+export { extractCallStack, type ACIRCallback, type ACIRCallbackStats, type ACIRExecutionResult } from './acvm.js';
+export * from './acvm_types.js';
+export * from './deserialize.js';
+export * from './serialize.js';

package/src/private/acvm/serialize.ts

@@ -0,0 +1,123 @@
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+import type { EthAddress } from '@aztec-labs/foundation/eth-address';
+import type { AztecAddress } from '@aztec-labs/stdlib/aztec-address';
+
+import type { ACVMField } from './acvm_types.js';
+
+/**
+ * Adapts the buffer to the field size.
+ * @param originalBuf - The buffer to adapt.
+ * @returns The adapted buffer.
+ */
+function adaptBufferSize(originalBuf: Buffer) {
+  const buffer = Buffer.alloc(Fr.SIZE_IN_BYTES);
+  if (originalBuf.length > buffer.length) {
+    throw new Error('Buffer does not fit in field');
+  }
+  originalBuf.copy(buffer, buffer.length - originalBuf.length);
+  return buffer;
+}
+
+/**
+ * Converts a value to an ACVM field.
+ * @param value - The value to convert.
+ * @returns The ACVM field.
+ */
+export function toACVMField(
+  value: AztecAddress | EthAddress | Fr | Buffer | boolean | number | bigint | ACVMField,
+): ACVMField {
+  let buffer;
+  if (Buffer.isBuffer(value)) {
+    buffer = value;
+  } else if (typeof value === 'boolean' || typeof value === 'number' || typeof value === 'bigint') {
+    buffer = new Fr(value).toBuffer();
+  } else if (typeof value === 'string') {
+    buffer = Fr.fromHexString(value).toBuffer();
+  } else {
+    buffer = value.toBuffer();
+  }
+  return `0x${adaptBufferSize(buffer).toString('hex')}`;
+}
+
+/**
+ * Converts a single value or an array of single values into the equivalent ACVM field representation.
+ */
+export function toACVMFieldSingleOrArray(value: Fr | Fr[]) {
+  return Array.isArray(value) ? value.map(toACVMField) : toACVMField(value);
+}
+
+/**
+ * Inserts a list of ACVM fields to a witness.
+ * @param witnessStartIndex - The index where to start inserting the fields.
+ * @param fields - The fields to insert.
+ * @returns The witness.
+ */
+export function toACVMWitness(witnessStartIndex: number, fields: Parameters<typeof toACVMField>[0][]) {
+  return fields.reduce((witness, field, index) => {
+    witness.set(index + witnessStartIndex, toACVMField(field));
+    return witness;
+  }, new Map<number, ACVMField>());
+}
+
+export function bufferToU8Array(buffer: Buffer): ACVMField[] {
+  return Array.from(buffer).map(byte => toACVMField(BigInt(byte)));
+}
+
+export function bufferToBoundedVec(buffer: Buffer, maxLen: number): [ACVMField[], ACVMField] {
+  const u8Array = bufferToU8Array(buffer);
+  return arrayToBoundedVec(u8Array, maxLen);
+}
+
+/**
+ * Converts a ForeignCallArray into a tuple which represents a nr BoundedVec.
+ * If the input array is shorter than the maxLen, it pads the result with zeros,
+ * so that nr can correctly coerce this result into a BoundedVec.
+ * @param bVecStorage - The array underlying the BoundedVec.
+ * @param maxLen - the max length of the BoundedVec.
+ * @returns a tuple representing a BoundedVec.
+ */
+export function arrayToBoundedVec(bVecStorage: ACVMField[], maxLen: number): [ACVMField[], ACVMField] {
+  if (bVecStorage.length > maxLen) {
+    throw new Error(`Array of length ${bVecStorage.length} larger than maxLen ${maxLen}`);
+  }
+  const lengthDiff = maxLen - bVecStorage.length;
+  const zeroPaddingArray = Array(lengthDiff).fill(toACVMField(BigInt(0)));
+  const storage = bVecStorage.concat(zeroPaddingArray);
+  const len = toACVMField(BigInt(bVecStorage.length));
+  return [storage, len];
+}
+
+/**
+ * Converts an array of arrays representing Noir BoundedVec of nested arrays into its Noir serialized form.
+ * @param bVecStorage - The array underlying the BoundedVec.
+ * @param maxLen - The max length of the BoundedVec (max num of the nested arrays in the BoundedVec).
+ * @param nestedArrayLength - The length of the nested arrays (each nested array has to have the same length).
+ * @returns Serialized BoundedVec following Noir intrinsic serialization.
+ */
+export function arrayOfArraysToBoundedVecOfArrays(
+  bVecStorage: ACVMField[][],
+  maxLen: number,
+  nestedArrayLength: number,
+): [ACVMField[], ACVMField] {
+  if (bVecStorage.length > maxLen) {
+    throw new Error(`Array of length ${bVecStorage.length} larger than maxLen ${maxLen}`);
+  }
+
+  // Check that all nested arrays have length nestedArrayLength
+  if (!bVecStorage.every(nestedArray => nestedArray.length === nestedArrayLength)) {
+    throw new Error(
+      `Nested array length passed in from Noir does not correspond to the length obtained in TS: ${nestedArrayLength} !== ${bVecStorage[0].length}`,
+    );
+  }
+
+  // Flatten the array of arrays
+  const flattenedStorage = bVecStorage.flat();
+
+  // Calculate and add padding
+  const numFieldsToPad = maxLen * nestedArrayLength - flattenedStorage.length;
+  const flattenedStorageWithPadding = flattenedStorage.concat(Array(numFieldsToPad).fill(toACVMField(BigInt(0))));
+
+  // Return flattened array with padding and length
+  const len = toACVMField(BigInt(bVecStorage.length));
+  return [flattenedStorageWithPadding, len];
+}