@aztec/pxe 0.0.1-commit.3100065 → 0.0.1-commit.330febf

package/src/bin/oracle_version_helpers.ts

@@ -1,75 +1,11 @@
-/* eslint-disable import-x/no-named-as-default-member */
-import { readFileSync } from 'fs';
-import ts from 'typescript';
+import type { OracleRegistryEntry } from '../contract_function_simulator/index.js';
 
 /**
- * Extracts method signatures from TypeScript classes or interfaces and returns a deterministic string representation.
+ * Extracts a deterministic signature string from an oracle registry (e.g. PXE's `ORACLE_REGISTRY`).
  *
- * This is used to detect when an oracle interface changes so that the oracle version can be bumped. It works with both
- * class declarations (e.g. PXE's `Oracle` class) and interface declarations (e.g. TXE's `IAvmExecutionOracle`).
- *
- * @param sourcePath - Absolute path to the TypeScript source file to parse.
- * @param targets - Names of classes or interfaces to extract methods from.
- * @param excludedMembers - Method names to skip (e.g. non-oracle helpers like `constructor`).
- */
-export function getOracleInterfaceSignature(sourcePath: string, targets: string[], excludedMembers: string[]): string {
-  const sourceCode = readFileSync(sourcePath, 'utf-8');
-  const sourceFile = ts.createSourceFile(sourcePath, sourceCode, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
-
-  const methodSignatures: string[] = [];
-
-  function visit(node: ts.Node) {
-    const isTarget =
-      (ts.isClassDeclaration(node) || ts.isInterfaceDeclaration(node)) && targets.includes(node.name?.text ?? '');
-
-    if (isTarget) {
-      node.members.forEach(member => {
-        if (
-          (ts.isMethodDeclaration(member) || ts.isMethodSignature(member)) &&
-          member.name &&
-          ts.isIdentifier(member.name)
-        ) {
-          const methodName = member.name.text;
-
-          if (excludedMembers.includes(methodName)) {
-            return;
-          }
-
-          const paramSignatures: string[] = [];
-          member.parameters.forEach(param => {
-            const paramName = extractParameterName(param, sourceFile);
-            const paramType = extractTypeString(param.type, sourceFile);
-            paramSignatures.push(`${paramName}: ${paramType}`);
-          });
-
-          const returnType = extractTypeString(member.type, sourceFile);
-
-          const signature = `${methodName}(${paramSignatures.join(', ')}): ${returnType}`;
-          methodSignatures.push(signature);
-        }
-      });
-    }
-
-    ts.forEachChild(node, visit);
-  }
-
-  visit(sourceFile);
-
-  methodSignatures.sort();
-
-  return methodSignatures.join('');
-}
-
-/**
- * Extracts a deterministic signature string from an oracle registry object literal (e.g. PXE's `ORACLE_REGISTRY`).
- *
- * Reads the registry declaration where each oracle's wire ABI lives: the ordered parameter names with their
- * `TypeMapping` expressions and the return type. The resulting hash is sensitive to parameter, type, and return
- * changes, not just oracle additions and removals.
- *
- * Type expressions are captured as their source text (e.g. `OPTION(AZTEC_ADDRESS)`, `BOUNDED_VEC(NOTE)`), so the
- * signature tracks the composition of types. However, if the internal serialization logic of a `TypeMapping` constant
- * (e.g. `FIELD`) changes without the constant being renamed, the hash will not change.
+ * Reads the registry where each oracle's wire ABI lives: the ordered parameter names with their `TypeMapping` labels
+ * and the return type. The resulting hash is sensitive to parameter, type, and return changes, not just oracle
+ * additions and removals.
  *
  * @example
  * // Given a registry like:
@@ -79,233 +15,16 @@ export function getOracleInterfaceSignature(sourcePath: string, targets: string[
  * //   } satisfies Record<string, OracleRegistryEntry>;
  * //
  * // Returns (sorted, newline-joined):
- * //   "aztec_prv_bar(): void\naztec_utl_foo(a: U32): BOOL"
- *
- * @param sourcePath - Absolute path to the TypeScript source file declaring the registry.
- * @param registryName - Name of the registry constant to read (e.g. `ORACLE_REGISTRY`).
+ * //   "aztec_prv_bar(): void\naztec_utl_foo(a: u32): bool"
  */
-export function getOracleRegistrySignature(sourcePath: string, registryName: string): string {
-  const sourceCode = readFileSync(sourcePath, 'utf-8');
-  const sourceFile = ts.createSourceFile(sourcePath, sourceCode, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
-
-  const registry = findObjectLiteral(sourceFile, registryName);
-  if (!registry) {
-    throw new Error(`Could not find oracle registry '${registryName}' in ${sourcePath}.`);
-  }
-
-  const oracleSignatures = registry.properties.map(property => {
-    if (!ts.isPropertyAssignment(property)) {
-      throw new Error(
-        `Unexpected member in oracle registry '${registryName}': ${property.getText(sourceFile)}. Spread elements ` +
-          `are not supported.`,
-      );
-    }
-
-    const oracleName = getPropertyName(property.name, sourceFile);
-    const { params, returnType } = extractRegistryEntry(property.initializer, sourceFile);
-    const paramSignatures = params.map(param => `${param.name}: ${param.type}`);
-    return `${oracleName}(${paramSignatures.join(', ')}): ${returnType}`;
+export function getOracleRegistrySignature(registry: Record<string, OracleRegistryEntry>): string {
+  const oracleSignatures = Object.entries(registry).map(([name, entry]) => {
+    const paramSignatures = entry.params.map(p => `${p.name}: ${p.type.label}`);
+    const returnType = entry.returnType === undefined ? 'void' : entry.returnType.label;
+    return `${name}(${paramSignatures.join(', ')}): ${returnType}`;
   });
 
   oracleSignatures.sort();
 
   return oracleSignatures.join('\n');
 }
-
-/**
- * Reads an integer-valued global constant from a Noir or TypeScript source file.
- *
- * Matches both the Noir form (`pub global NAME: Field = N;`) and the TypeScript form (`export const NAME = N;`). This
- * lets us compare a version constant that is hand-duplicated across the TS and Noir layers (which can't import each
- * other) without depending on either compiler. Only the assignment form `NAME = N` matches, so later usages of the
- * constant are ignored regardless of their order in the file.
- *
- * @param sourcePath - Absolute path to the source file to read.
- * @param name - Name of the global constant whose integer value should be extracted.
- * @returns The integer value assigned to the constant.
- * @throws If the constant's declaration is not found in the file.
- */
-export function readNumericGlobal(sourcePath: string, name: string): number {
-  const sourceCode = readFileSync(sourcePath, 'utf-8');
-  const match = sourceCode.match(new RegExp(`\\b${name}\\s*(?::\\s*\\w+\\s*)?=\\s*(\\d+)`));
-  if (!match) {
-    throw new Error(`Could not find numeric global '${name}' in ${sourcePath}.`);
-  }
-  return Number(match[1]);
-}
-
-function extractParameterName(param: ts.ParameterDeclaration, sourceFile: ts.SourceFile): string {
-  const name = param.name;
-
-  if (ts.isIdentifier(name)) {
-    return name.text;
-  }
-
-  if (ts.isArrayBindingPattern(name)) {
-    if (name.elements.length > 0) {
-      const element = name.elements[0];
-      if (ts.isBindingElement(element)) {
-        const elementName = element.name;
-        if (ts.isIdentifier(elementName)) {
-          return elementName.text;
-        }
-        if (ts.isArrayBindingPattern(elementName) || ts.isObjectBindingPattern(elementName)) {
-          return elementName.getText(sourceFile);
-        }
-      }
-    }
-    return name.getText(sourceFile);
-  }
-
-  if (ts.isObjectBindingPattern(name)) {
-    return name.getText(sourceFile);
-  }
-
-  return (name as ts.Node).getText(sourceFile);
-}
-
-/** Returns the source text of a type annotation, or `'void'` if absent. */
-function extractTypeString(typeNode: ts.TypeNode | undefined, sourceFile: ts.SourceFile): string {
-  if (!typeNode) {
-    return 'void';
-  }
-
-  return typeNode.getText(sourceFile).replace(/\s+/g, ' ').trim();
-}
-
-/**
- * Finds a top-level object-literal-valued constant by name, unwrapping `satisfies`/`as`/parenthesized wrappers.
- *
- * @example
- * // `const REGISTRY = { ... } satisfies Record<string, Entry>` => the `{ ... }` ObjectLiteralExpression
- */
-function findObjectLiteral(sourceFile: ts.SourceFile, name: string): ts.ObjectLiteralExpression | undefined {
-  let result: ts.ObjectLiteralExpression | undefined;
-
-  function visit(node: ts.Node) {
-    if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name) && node.name.text === name && node.initializer) {
-      result = unwrapObjectLiteral(node.initializer);
-    }
-    ts.forEachChild(node, visit);
-  }
-
-  visit(sourceFile);
-  return result;
-}
-
-/** Peels `satisfies`, `as`, and parenthesized wrappers off an expression to reach the underlying object literal. */
-function unwrapObjectLiteral(node: ts.Expression): ts.ObjectLiteralExpression | undefined {
-  let current = node;
-  while (ts.isSatisfiesExpression(current) || ts.isAsExpression(current) || ts.isParenthesizedExpression(current)) {
-    current = current.expression;
-  }
-  return ts.isObjectLiteralExpression(current) ? current : undefined;
-}
-
-/**
- * Extracts the ordered `params` (names + type expressions) and `returnType` from a `makeEntry({ ... })` call.
- *
- * @example
- * // makeEntry({ params: [{ name: 'a', type: OPTION(FIELD) }], returnType: BOOL })
- * // => { params: [{ name: 'a', type: 'OPTION(FIELD)' }], returnType: 'BOOL' }
- * //
- * // makeEntry()
- * // => { params: [], returnType: 'void' }
- */
-function extractRegistryEntry(
-  initializer: ts.Expression,
-  sourceFile: ts.SourceFile,
-): { params: { name: string; type: string }[]; returnType: string } {
-  if (!ts.isCallExpression(initializer)) {
-    throw new Error(`Expected a makeEntry(...) call but got: ${initializer.getText(sourceFile)}`);
-  }
-
-  const [arg] = initializer.arguments;
-  if (arg === undefined) {
-    return { params: [], returnType: 'void' };
-  }
-  if (!ts.isObjectLiteralExpression(arg)) {
-    throw new Error(`Expected a makeEntry object argument but got: ${arg.getText(sourceFile)}`);
-  }
-
-  let params: { name: string; type: string }[] = [];
-  let returnType = 'void';
-
-  arg.properties.forEach(property => {
-    if (!ts.isPropertyAssignment(property)) {
-      throw new Error(`Unexpected makeEntry property: ${property.getText(sourceFile)}`);
-    }
-    const key = getPropertyName(property.name, sourceFile);
-    if (key === 'params') {
-      params = extractRegistryParams(property.initializer, sourceFile);
-    } else if (key === 'returnType') {
-      returnType = normalizeExpressionText(property.initializer, sourceFile);
-    } else {
-      throw new Error(`Unexpected makeEntry property '${key}'.`);
-    }
-  });
-
-  return { params, returnType };
-}
-
-/**
- * Extracts `{ name, type }` pairs from the `params` array literal inside a `makeEntry` call.
- */
-function extractRegistryParams(
-  initializer: ts.Expression,
-  sourceFile: ts.SourceFile,
-): { name: string; type: string }[] {
-  if (!ts.isArrayLiteralExpression(initializer)) {
-    throw new Error(`Expected a params array but got: ${initializer.getText(sourceFile)}`);
-  }
-
-  return initializer.elements.map(element => {
-    if (!ts.isObjectLiteralExpression(element)) {
-      throw new Error(`Expected a param object but got: ${element.getText(sourceFile)}`);
-    }
-
-    let name: string | undefined;
-    let type: string | undefined;
-    element.properties.forEach(property => {
-      if (!ts.isPropertyAssignment(property)) {
-        throw new Error(`Unexpected param property: ${property.getText(sourceFile)}`);
-      }
-      const key = getPropertyName(property.name, sourceFile);
-      if (key === 'name') {
-        if (!ts.isStringLiteralLike(property.initializer)) {
-          throw new Error(`Expected a string literal param name but got: ${property.initializer.getText(sourceFile)}`);
-        }
-        name = property.initializer.text;
-      } else if (key === 'type') {
-        type = normalizeExpressionText(property.initializer, sourceFile);
-      } else {
-        throw new Error(`Unexpected param property '${key}'.`);
-      }
-    });
-
-    if (name === undefined || type === undefined) {
-      throw new Error(`Param missing 'name' or 'type': ${element.getText(sourceFile)}`);
-    }
-    return { name, type };
-  });
-}
-
-/** Returns the text of an identifier or string-literal property name, throwing on computed or numeric names. */
-function getPropertyName(name: ts.PropertyName, sourceFile: ts.SourceFile): string {
-  if (ts.isIdentifier(name) || ts.isStringLiteralLike(name)) {
-    return name.text;
-  }
-  throw new Error(`Unsupported property name: ${name.getText(sourceFile)}`);
-}
-
-/**
- * Returns the source text of an expression with all whitespace stripped for format-insensitive comparison.
- *
- * @example
- * // `OPTION(\n  AZTEC_ADDRESS\n)` => `"OPTION(AZTEC_ADDRESS)"`
- */
-function normalizeExpressionText(node: ts.Expression, sourceFile: ts.SourceFile): string {
-  // Type expressions are TypeMapping references and calls (identifiers, parentheses, commas, numbers) with no
-  // meaningful whitespace, so we strip it entirely to keep the signature stable across reformatting.
-  return node.getText(sourceFile).replace(/\s+/g, '');
-}

package/src/block_synchronizer/block_synchronizer.ts

@@ -4,12 +4,11 @@ import { SerialQueue } from '@aztec/foundation/queue';
 import type { AztecAsyncKVStore } from '@aztec/kv-store';
 import type { L2TipsKVStore } from '@aztec/kv-store/stores';
 import { BlockHash, L2BlockStream, type L2BlockStreamEvent, type L2BlockStreamEventHandler } from '@aztec/stdlib/block';
-import type { AztecNode } from '@aztec/stdlib/interfaces/client';
 import type { BlockHeader } from '@aztec/stdlib/tx';
 
 import type { BlockSynchronizerConfig } from '../config/index.js';
-import type { ContractClassService } from '../contract/contract_class_service.js';
 import type { ContractSyncService } from '../contract/contract_sync_service.js';
+import type { CachingAztecNode } from '../node/caching_aztec_node.js';
 import type { AnchorBlockStore } from '../storage/anchor_block_store/index.js';
 import type { FactStore } from '../storage/fact_store/fact_store.js';
 import type { NoteStore } from '../storage/note_store/index.js';
@@ -28,7 +27,7 @@ export class BlockSynchronizer implements L2BlockStreamEventHandler {
   protected readonly blockStream: L2BlockStream;
 
   constructor(
-    private readonly node: AztecNode,
+    private readonly node: CachingAztecNode,
     private readonly store: AztecAsyncKVStore,
     private readonly anchorBlockStore: AnchorBlockStore,
     private readonly noteStore: NoteStore,
@@ -36,7 +35,6 @@ export class BlockSynchronizer implements L2BlockStreamEventHandler {
     private readonly factStore: FactStore,
     private readonly l2TipsStore: L2TipsKVStore,
     private readonly contractSyncService: ContractSyncService,
-    private readonly contractClassService: ContractClassService,
     private readonly config: Partial<BlockSynchronizerConfig> = {},
     bindings?: LoggerBindings,
   ) {
@@ -68,21 +66,7 @@ export class BlockSynchronizer implements L2BlockStreamEventHandler {
     switch (event.type) {
       case 'chain-proposed': {
         if (this.config.syncChainTip === undefined || this.config.syncChainTip === 'proposed') {
-          // Fetch the proposed tip header by hash. By-hash is safer than by-number against a same-height reorg.
-          const block = await this.node.getBlockData(BlockHash.fromString(event.block.hash));
-          if (!block) {
-            // The node served a proposed tip whose block data it cannot return — a node inconsistency, since the
-            // stream events and the block data come from the same node (same reasoning as the chain-pruned throw
-            // below). Throwing here propagates before the tips-store cursor advances, so the cursor stays put and the
-            // next sync re-emits chain-proposed (at-least-once). Were we to warn-and-skip, the cursor would advance and
-            // a quiet chain would never re-emit, leaving the anchor stale indefinitely.
-            throw new Error(
-              `Block header for proposed block ${event.block.number} and hash ${event.block.hash} not found. This ` +
-                `likely indicates a bug in the node, as we receive block stream events and fetch block headers from ` +
-                `the same node.`,
-            );
-          }
-          await this.updateAnchorBlockHeader(block.header);
+          await this.updateAnchorBlockHeader(event.header);
         }
         break;
       }
@@ -180,10 +164,9 @@ export class BlockSynchronizer implements L2BlockStreamEventHandler {
     // execution.
     this.contractSyncService.wipe();
 
-    // The contract class service keeps a per-block cache - since updating our anchor means it is very unlikely we'd
-    // ever re-simulate at past anchors, we wipe its cache to prevent runaway memory growth on very long-lived PXE
-    // instances.
-    this.contractClassService.wipe();
+    // Cached node reads stay correct indefinitely, so this wipe is only about bounding memory growth. An anchor
+    // update is the recurring trigger PXE already has.
+    this.node.wipeCache();
 
     this.log.verbose(`Updated pxe last block to ${blockHeader.getBlockNumber()}`, blockHeader.toInspect());
     await this.anchorBlockStore.setHeader(blockHeader);

package/src/config/package_info.ts

@@ -1,3 +1,3 @@
 export function getPackageInfo() {
-  return { version: '5.0.0', name: '@aztec/pxe' };
+  return { version: '6.0.0', name: '@aztec/pxe' };
 }

package/src/contract/contract_class_service.ts

@@ -14,14 +14,6 @@ import type { ContractStore } from '../storage/contract_store/contract_store.js'
  * falling back to a local instance if no upgrades were scheduled.
  */
 export class ContractClassService {
-  /**
-   * Class ids are cached per `(address, anchorHash)`. This avoid unnecessary network roundtrips in scenarios where
-   * multiple executions are done on the same anchor block (e.g. simulation followed by witgen), or when the same
-   * contract is invoked multiple times in an execution (e.g. authwit checks).
-   * It also means the callers don't need to worry about caching this service's return values, simplifying callsites.
-   */
-  #cache: Map<string, Promise<Fr | undefined>> = new Map();
-
   constructor(
     private node: AztecNode,
     private contractStore: ContractStore,
@@ -40,44 +32,14 @@ export class ContractClassService {
       return instance?.originalContractClassId;
     }
 
-    const key = `${address.toString()}:${(await anchorBlockHeader.hash()).toString()}`;
-    let promise = this.#cache.get(key);
-    if (!promise) {
-      promise = (async () => {
-        // The node resolves the current class from the same scheduled value change the AVM enforces against the public
-        // data tree. If the contract was upgraded the node returns a non-undefined instance; an undefined result means
-        // no upgrade happened (or the node has no record of it, e.g. it was never publicly deployed), so the original
-        // class is current.
-
-        const nodeInstance = await this.node.getContract(address, await anchorBlockHeader.hash());
-
-        if (nodeInstance) {
-          return nodeInstance.currentContractClassId;
-        } else {
-          return (await this.contractStore.getContractInstance(address))?.originalContractClassId;
-        }
-      })().catch(err => {
-        this.#cache.delete(key);
-        throw err;
-      });
-      this.#cache.set(key, promise);
-    }
-
-    const classId = await promise;
-    if (classId === undefined) {
-      // Don't memoize a missing instance: it may be registered later in this PXE (e.g. via contract sync
-      // mid-execution), and a cached miss would then hide it. Only successful resolutions stay cached.
-      this.#cache.delete(key);
+    // The node resolves the current class from the same scheduled value change the AVM enforces against the public
+    // data tree. If the contract was upgraded the node returns a non-undefined instance; an undefined result means no
+    // upgrade happened (or the node has no record of it, e.g. it was never publicly deployed), so the original class
+    // is current.
+    const nodeInstance = await this.node.getContract(address, await anchorBlockHeader.hash());
+    if (nodeInstance) {
+      return nodeInstance.currentContractClassId;
     }
-    return classId;
-  }
-
-  /**
-   * Clears the cache.
-   *
-   * This is not required for correctness, only to limit how much memory the cache uses. The cache is resilient against
-   * reorgs etc. as it is based on block hashes, not block numbers. */
-  wipe(): void {
-    this.#cache.clear();
+    return (await this.contractStore.getContractInstance(address))?.originalContractClassId;
   }
 }

package/src/contract/helpers.ts

@@ -1,10 +1,10 @@
-import { isProtocolContract } from '@aztec/protocol-contracts';
 import type { FunctionCall, FunctionSelector } from '@aztec/stdlib/abi';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 import type { BlockHeader } from '@aztec/stdlib/tx';
 
 import type { ContractStore } from '../storage/contract_store/contract_store.js';
 import type { ContractClassService } from './contract_class_service.js';
+import { isSkipSyncContract } from './skip_sync_contracts.js';
 
 export async function syncScope(
   contractAddress: AztecAddress,
@@ -15,8 +15,8 @@ export async function syncScope(
   utilityExecutor: (privateSyncCall: FunctionCall, scopes: AztecAddress[]) => Promise<any>,
   scope: AztecAddress,
 ) {
-  // Protocol contracts don't have private state to sync
-  if (isProtocolContract(contractAddress)) {
+  // Some canonical contracts hold no private state, so there is nothing to sync (see `skipSyncContracts`).
+  if (isSkipSyncContract(contractAddress)) {
     return;
   }
 

package/src/contract/skip_sync_contracts.ts

@@ -0,0 +1,23 @@
+import { ProtocolContractAddress } from '@aztec/protocol-contracts';
+import { STANDARD_AUTH_REGISTRY_ADDRESS } from '@aztec/standard-contracts/auth-registry/constants';
+import { STANDARD_MULTI_CALL_ENTRYPOINT_ADDRESS } from '@aztec/standard-contracts/multi-call-entrypoint/constants';
+import { STANDARD_PUBLIC_CHECKS_ADDRESS } from '@aztec/standard-contracts/public-checks/constants';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+
+/**
+ * Canonical contracts that hold no private state and are therefore never synced.
+ *
+ * The protocol contracts (registries, fee juice) plus the standard AuthRegistry, MultiCallEntrypoint and PublicChecks
+ * declare no notes and no events, so their macro-generated `sync_state` has nothing to discover.
+ */
+export const skipSyncContracts: AztecAddress[] = [
+  ...Object.values(ProtocolContractAddress),
+  STANDARD_AUTH_REGISTRY_ADDRESS,
+  STANDARD_MULTI_CALL_ENTRYPOINT_ADDRESS,
+  STANDARD_PUBLIC_CHECKS_ADDRESS,
+];
+
+/** Returns whether the given contract should be skipped during private state synchronization. */
+export function isSkipSyncContract(address: AztecAddress): boolean {
+  return skipSyncContracts.some(a => a.equals(address));
+}

package/src/contract_function_simulator/contract_function_simulator.ts

@@ -1,3 +1,4 @@
+import { CircuitKind } from '@aztec/bb.js';
 import {
   AVM_EMITNOTEHASH_BASE_L2_GAS,
   AVM_EMITNULLIFIER_BASE_L2_GAS,
@@ -108,7 +109,6 @@ import type { RecipientTaggingStore } from '../storage/tagging_store/recipient_t
 import type { SenderTaggingStore } from '../storage/tagging_store/sender_tagging_store.js';
 import type { TaggingSecretSourcesStore } from '../storage/tagging_store/tagging_secret_sources_store.js';
 import { AnchoredContractData } from './anchored_contract_data.js';
-import type { BenchmarkedNode } from './benchmarked_node.js';
 import { ExecutionNoteCache } from './execution_note_cache.js';
 import { ExecutionTaggingIndexCache } from './execution_tagging_index_cache.js';
 import { HashedValuesCache } from './hashed_values_cache.js';
@@ -314,7 +314,7 @@ export class ContractFunctionSimulator {
       );
       const simulatorTeardownTimer = new Timer();
 
-      const firstNullifier = noteCache.getNonceGenerator();
+      const firstNullifierHint = noteCache.getNonceGenerator();
 
       const publicCallRequests = collectNested([executionResult], r =>
         r.publicInputs.publicCallRequests
@@ -337,9 +337,9 @@ export class ContractFunctionSimulator {
       }
 
       // Not to be confused with a PrivateCallExecutionResult. This is a superset
-      // of the PrivateCallExecutionResult, containing also firstNullifier
+      // of the PrivateCallExecutionResult, containing also firstNullifierHint
       // and publicFunctionsCalldata.
-      return new PrivateExecutionResult(executionResult, firstNullifier, publicFunctionsCalldata);
+      return new PrivateExecutionResult(executionResult, firstNullifierHint, publicFunctionsCalldata);
     } catch (err) {
       throw createSimulationError(err instanceof Error ? err : new Error('Unknown error during private execution'));
     }
@@ -443,22 +443,6 @@ export class ContractFunctionSimulator {
       throw createSimulationError(err instanceof Error ? err : new Error('Unknown error during private execution'));
     }
   }
-
-  /**
-   * Returns the execution statistics collected during the simulator run.
-   * @returns The execution statistics.
-   */
-  getStats() {
-    const nodeRPCCalls =
-      typeof (this.aztecNode as BenchmarkedNode).getStats === 'function'
-        ? (this.aztecNode as BenchmarkedNode).getStats()
-        : {
-            perMethod: {},
-            roundTrips: { roundTrips: 0, totalBlockingTime: 0, roundTripDurations: [], roundTripMethods: [] },
-          };
-
-    return { nodeRPCCalls };
-  }
 }
 
 class OrderedSideEffect<T> {
@@ -587,6 +571,7 @@ export async function generateSimulatedProvingResult(
         execution.publicInputs.callContext.functionSelector,
       ),
       timings: execution.profileResult?.timings ?? { witgen: 0, oracles: {} },
+      kind: CircuitKind.App,
       bytecode: execution.acir,
       vk: execution.vk,
       witness: execution.partialWitness,

package/src/contract_function_simulator/index.ts

@@ -6,6 +6,7 @@ export {
   type ParamTypes,
 } from './oracle/oracle_registry.js';
 export {
+  ALIAS,
   ARRAY,
   AZTEC_ADDRESS,
   BIGINT,
@@ -13,8 +14,7 @@ export {
   BLOCK_NUMBER,
   BOOL,
   BOUNDED_VEC,
-  BUFFER,
-  BYTE,
+  U8,
   CONTRACT_INSTANCE,
   DELIVERY_MODE,
   EPHEMERAL_ARRAY,
@@ -23,6 +23,8 @@ export {
   FIELD,
   FIXED_ARRAY,
   FUNCTION_SELECTOR,
+  LEAF,
+  LEAF_INDEX,
   LOG_RETRIEVAL_REQUEST,
   LOG_RETRIEVAL_RESPONSE,
   MEMBERSHIP_WITNESS,
@@ -32,16 +34,34 @@ export {
   PENDING_TAGGED_LOG,
   POINT,
   PROVIDED_SECRET,
+  SCALAR,
   SLOT_NUMBER,
   STR,
   STRUCT,
   U32,
+  U64,
+  U128,
   tryFieldWidth,
+  isArrayMapping,
+  isBoundedVecMapping,
+  isEphemeralArrayMapping,
+  isFixedArrayMapping,
+  isFixedBoundedVecMapping,
+  isOptionMapping,
+  isStructMapping,
+  type ArrayMapping,
+  type BoundedVecMapping,
+  type CompositeMapping,
+  type EphemeralArrayMapping,
+  type FixedArrayMapping,
+  type FixedBoundedVecMapping,
   type InputSlot,
   type MaybePromise,
+  type OptionMapping,
   type OutputSlot,
   type SlotShape,
   type StructField,
+  type StructMapping,
   type TypeMapping,
 } from './oracle/oracle_type_mappings.js';
 export { ExecutionNoteCache } from './execution_note_cache.js';
@@ -74,5 +94,5 @@ export { NoteValidationRequest } from './noir-structs/note_validation_request.js
 export type { PendingTaggedLog } from './noir-structs/pending_tagged_log.js';
 export type { TxEffectData } from './noir-structs/tx_effect_data.js';
 export type { ProvidedSecret } from './noir-structs/provided_secret.js';
-export { ResolvedTx } from './noir-structs/resolved_tx.js';
+export type { ResolvedTx } from './noir-structs/resolved_tx.js';
 export { TransientArrayService } from './transient_array_service.js';