@aztec/simulator 0.0.0-test.1 → 0.0.1-commit.24de95ac

package/src/public/test_executor_metrics.ts

@@ -0,0 +1,395 @@
+import { sum } from '@aztec/foundation/collection';
+import { type Logger, createLogger } from '@aztec/foundation/log';
+import { Timer } from '@aztec/foundation/timer';
+import type { RevertCode } from '@aztec/stdlib/avm';
+
+import { strict as assert } from 'assert';
+
+import type { ExecutorMetricsInterface } from './executor_metrics_interface.js';
+
+export interface PublicEnqueuedCallMetrics {
+  fnName: string;
+  durationMs: number;
+  manaUsed: number;
+  totalInstructionsExecuted: number;
+  reverted: boolean;
+}
+
+export interface PublicTxMetrics {
+  // TS simulation
+  totalDurationMs: number;
+  manaUsed: number;
+  totalInstructionsExecuted: number;
+  nonRevertiblePrivateInsertionsUs: number | undefined;
+  revertiblePrivateInsertionsUs: number | undefined;
+  enqueuedCalls: PublicEnqueuedCallMetrics[];
+  revertedCode: RevertCode | undefined;
+  // Proving
+  proverSimulationStepMs: number | undefined;
+  proverProvingStepMs: number | undefined;
+  proverTraceGenerationStepMs: number | undefined;
+  // Proving (detail)
+  traceGenerationInteractionsMs: number | undefined;
+  traceGenerationTracesMs: number | undefined;
+  provingSumcheckMs: number | undefined;
+  provingPcsMs: number | undefined;
+  provingLogDerivativeInverseMs: number | undefined;
+  provingLogDerivativeInverseCommitmentsMs: number | undefined;
+  provingWireCommitmentsMs: number | undefined;
+}
+
+const NUM_SPACES = 4;
+const H1 = '# ';
+const H2 = '\n## ';
+const INDENT = ' '.repeat(NUM_SPACES);
+const INDENT0 = '- ';
+const INDENT1 = INDENT + '- ';
+const INDENT2 = INDENT + INDENT + '- ';
+const H_LINE = '\n---------------------------------------------------------------------';
+
+export enum PublicTxMetricsFilter {
+  ALL,
+  TOTALS,
+  DURATIONS,
+  INSTRUCTIONS,
+  PROVING,
+}
+
+function createEmptyTxMetrics(): PublicTxMetrics {
+  return {
+    // TS simulation
+    totalDurationMs: 0,
+    manaUsed: 0,
+    totalInstructionsExecuted: 0,
+    nonRevertiblePrivateInsertionsUs: undefined,
+    revertiblePrivateInsertionsUs: undefined,
+    enqueuedCalls: [],
+    revertedCode: undefined,
+    // Proving
+    proverSimulationStepMs: undefined,
+    proverProvingStepMs: undefined,
+    proverTraceGenerationStepMs: undefined,
+    // Proving (detail)
+    traceGenerationInteractionsMs: undefined,
+    traceGenerationTracesMs: undefined,
+    provingSumcheckMs: undefined,
+    provingPcsMs: undefined,
+    provingLogDerivativeInverseMs: undefined,
+    provingLogDerivativeInverseCommitmentsMs: undefined,
+    provingWireCommitmentsMs: undefined,
+  };
+}
+
+export class TestExecutorMetrics implements ExecutorMetricsInterface {
+  private logger: Logger;
+  // tx label -> tx metrics
+  private txMetrics: Map<string, PublicTxMetrics> = new Map();
+  private currentTxLabel: string | undefined;
+  private txTimer: Timer | undefined;
+
+  constructor() {
+    this.logger = createLogger(`simulator:test_executor_metrics`);
+  }
+
+  startRecordingTxSimulation(txLabel: string) {
+    assert(!this.currentTxLabel, 'Cannot start recording tx simulation when another is live');
+    assert(!this.txMetrics.has(txLabel), 'Cannot start recording metrics for tx with duplicate label');
+    this.txMetrics.set(txLabel, createEmptyTxMetrics());
+    this.currentTxLabel = txLabel;
+    this.txTimer = new Timer();
+  }
+
+  stopRecordingTxSimulation(txLabel: string, revertedCode?: RevertCode) {
+    assert(this.currentTxLabel === txLabel, 'Cannot stop recording metrics for tx when another is live');
+
+    const txMetrics = this.txMetrics.get(txLabel)!;
+
+    // total duration of tx
+    txMetrics.totalDurationMs = this.txTimer!.ms();
+    this.logger.debug(`Public TX simulation of ${txLabel} took ${txMetrics.totalDurationMs}ms`);
+
+    // add manaUsed across all enqueued calls
+    txMetrics.manaUsed = sum(txMetrics.enqueuedCalls.map(call => call.manaUsed));
+    // add totalInstructionsExecuted across all enqueued calls
+    txMetrics.totalInstructionsExecuted = sum(txMetrics.enqueuedCalls.map(call => call.totalInstructionsExecuted));
+    txMetrics.revertedCode = revertedCode;
+
+    this.currentTxLabel = undefined;
+  }
+
+  recordEnqueuedCallSimulation(
+    fnName: string,
+    durationMs: number,
+    manaUsed: number,
+    totalInstructionsExecuted: number,
+  ) {
+    this.#recordEnqueuedCallSimulation(fnName, durationMs, manaUsed, totalInstructionsExecuted, false);
+  }
+
+  recordEnqueuedCallSimulationFailure(
+    fnName: string,
+    durationMs: number,
+    manaUsed: number,
+    totalInstructionsExecuted: number,
+  ) {
+    this.#recordEnqueuedCallSimulation(fnName, durationMs, manaUsed, totalInstructionsExecuted, true);
+  }
+
+  #recordEnqueuedCallSimulation(
+    fnName: string,
+    durationMs: number,
+    manaUsed: number,
+    totalInstructionsExecuted: number,
+    reverted: boolean,
+  ) {
+    assert(this.currentTxLabel, 'Cannot record enqueued call simulation when no tx is live');
+    const txMetrics = this.txMetrics.get(this.currentTxLabel)!;
+    txMetrics.enqueuedCalls.push({
+      fnName,
+      durationMs,
+      manaUsed,
+      totalInstructionsExecuted: totalInstructionsExecuted,
+      reverted,
+    });
+  }
+
+  recordPrivateEffectsInsertion(durationUs: number, type: 'revertible' | 'non-revertible') {
+    assert(this.currentTxLabel, 'Cannot record private effects insertion when no tx is live');
+    const txMetrics = this.txMetrics.get(this.currentTxLabel)!;
+    if (type === 'revertible') {
+      assert(
+        txMetrics.revertiblePrivateInsertionsUs === undefined,
+        'Cannot RE-record revertible insertions of private effects',
+      );
+      txMetrics.revertiblePrivateInsertionsUs = durationUs;
+    } else {
+      assert(
+        txMetrics.nonRevertiblePrivateInsertionsUs === undefined,
+        'Cannot RE-record non-revertible insertions of private effects',
+      );
+      txMetrics.nonRevertiblePrivateInsertionsUs = durationUs;
+    }
+  }
+
+  recordProverMetrics(txLabel: string, metrics: Partial<PublicTxMetrics>) {
+    if (!this.txMetrics.has(txLabel)) {
+      this.txMetrics.set(txLabel, createEmptyTxMetrics());
+    }
+    const txMetrics = this.txMetrics.get(txLabel)!;
+    for (const [key, value] of Object.entries(metrics)) {
+      if (key in txMetrics) {
+        txMetrics[key as keyof PublicTxMetrics] = value as any;
+      }
+    }
+  }
+
+  prettyPrint(filter: PublicTxMetricsFilter = PublicTxMetricsFilter.ALL) {
+    this.logger.info(this.toPrettyString(filter));
+  }
+
+  toPrettyString(filter: PublicTxMetricsFilter = PublicTxMetricsFilter.ALL) {
+    let pretty = '';
+    //pretty += H_LINE + '\n';
+    pretty += `${H1}Public TX Simulation Metrics (${PublicTxMetricsFilter[filter]})\n`;
+    for (const [txLabel, txMetrics] of this.txMetrics.entries()) {
+      //pretty += H_LINE + '\n';
+      pretty += `${H2}TX Label: ${txLabel}\n`;
+      if (
+        filter == PublicTxMetricsFilter.DURATIONS ||
+        filter === PublicTxMetricsFilter.TOTALS ||
+        filter === PublicTxMetricsFilter.ALL
+      ) {
+        pretty += `${INDENT0}Total duration: ${fmtNum(txMetrics.totalDurationMs, 'ms')}\n`;
+      }
+      if (filter === PublicTxMetricsFilter.TOTALS || filter === PublicTxMetricsFilter.ALL) {
+        pretty += `${INDENT0}Total mana used: ${fmtNum(txMetrics.manaUsed)}\n`;
+        const manaPerSecond = Math.round((txMetrics.manaUsed * 1000) / txMetrics.totalDurationMs);
+        pretty += `${INDENT0}Mana per second: ${fmtNum(manaPerSecond)}\n`;
+      }
+
+      if (
+        filter === PublicTxMetricsFilter.INSTRUCTIONS ||
+        filter === PublicTxMetricsFilter.TOTALS ||
+        filter === PublicTxMetricsFilter.ALL
+      ) {
+        pretty += `${INDENT0}Total instructions executed: ${fmtNum(txMetrics.totalInstructionsExecuted)}\n`;
+      }
+      if (filter === PublicTxMetricsFilter.DURATIONS || filter === PublicTxMetricsFilter.ALL) {
+        pretty += `${INDENT0}Private insertions:\n`;
+        pretty += `${INDENT1}Non-revertible: ${fmtNum(txMetrics.nonRevertiblePrivateInsertionsUs! / 1_000, 'ms')}\n`;
+        pretty += `${INDENT1}Revertible: ${fmtNum(txMetrics.revertiblePrivateInsertionsUs! / 1_000, 'ms')}\n`;
+      }
+      if (filter === PublicTxMetricsFilter.PROVING || filter === PublicTxMetricsFilter.ALL) {
+        let provingPretty = '';
+        if (txMetrics.proverSimulationStepMs !== undefined) {
+          provingPretty += `${INDENT1}Simulation (all): ${fmtNum(txMetrics.proverSimulationStepMs, 'ms')}\n`;
+        }
+        if (txMetrics.proverProvingStepMs !== undefined) {
+          provingPretty += `${INDENT1}Proving (all): ${fmtNum(txMetrics.proverProvingStepMs, 'ms')}\n`;
+        }
+        if (txMetrics.proverTraceGenerationStepMs !== undefined) {
+          provingPretty += `${INDENT1}Trace generation (all): ${fmtNum(txMetrics.proverTraceGenerationStepMs, 'ms')}\n`;
+        }
+        if (txMetrics.traceGenerationInteractionsMs !== undefined) {
+          provingPretty += `${INDENT1}Trace generation interactions: ${fmtNum(txMetrics.traceGenerationInteractionsMs, 'ms')}\n`;
+        }
+        if (txMetrics.traceGenerationTracesMs !== undefined) {
+          provingPretty += `${INDENT1}Trace generation traces: ${fmtNum(txMetrics.traceGenerationTracesMs, 'ms')}\n`;
+        }
+        if (txMetrics.provingSumcheckMs !== undefined) {
+          provingPretty += `${INDENT1}Sumcheck: ${fmtNum(txMetrics.provingSumcheckMs, 'ms')}\n`;
+        }
+        if (txMetrics.provingPcsMs !== undefined) {
+          provingPretty += `${INDENT1}PCS: ${fmtNum(txMetrics.provingPcsMs, 'ms')}\n`;
+        }
+        if (txMetrics.provingLogDerivativeInverseMs !== undefined) {
+          provingPretty += `${INDENT1}Log derivative inverse: ${fmtNum(txMetrics.provingLogDerivativeInverseMs, 'ms')}\n`;
+        }
+        if (txMetrics.provingLogDerivativeInverseCommitmentsMs !== undefined) {
+          provingPretty += `${INDENT1}Log derivative inverse commitments: ${fmtNum(txMetrics.provingLogDerivativeInverseCommitmentsMs, 'ms')}\n`;
+        }
+        if (txMetrics.provingWireCommitmentsMs !== undefined) {
+          provingPretty += `${INDENT1}Wire commitments: ${fmtNum(txMetrics.provingWireCommitmentsMs, 'ms')}\n`;
+        }
+        if (provingPretty.length > 0) {
+          pretty += `${INDENT0}Proving:\n${provingPretty}`;
+        }
+      }
+      if (filter !== PublicTxMetricsFilter.TOTALS) {
+        // totals exclude enqueued calls
+        pretty += this.#enqueuedCallsToPrettyString(txMetrics, filter);
+      }
+      if (txMetrics.revertedCode !== undefined && !txMetrics.revertedCode.isOK()) {
+        pretty += `${INDENT0}Reverted code: ${txMetrics.revertedCode?.getDescription()}\n`;
+      }
+      pretty += H_LINE + '\n';
+    }
+    return pretty;
+  }
+
+  #enqueuedCallsToPrettyString(txMetrics: PublicTxMetrics, filter: PublicTxMetricsFilter) {
+    let pretty = '';
+    pretty += `${INDENT0}Enqueued public calls:\n`;
+    for (const enqueuedCall of txMetrics.enqueuedCalls) {
+      pretty += `${INDENT1}**Fn: ${enqueuedCall.fnName}**\n`;
+      if (filter === PublicTxMetricsFilter.DURATIONS || filter === PublicTxMetricsFilter.ALL) {
+        pretty += `${INDENT2}Duration: ${fmtNum(enqueuedCall.durationMs, 'ms')}\n`;
+      }
+      if (filter === PublicTxMetricsFilter.ALL) {
+        pretty += `${INDENT2}Mana used: ${fmtNum(enqueuedCall.manaUsed)}\n`;
+        const manaPerSecond = Math.round((enqueuedCall.manaUsed * 1000) / enqueuedCall.durationMs);
+        pretty += `${INDENT2}Mana per second: ${fmtNum(manaPerSecond)}\n`;
+      }
+
+      if (filter === PublicTxMetricsFilter.INSTRUCTIONS || filter === PublicTxMetricsFilter.ALL) {
+        pretty += `${INDENT2}Instructions executed: ${fmtNum(enqueuedCall.totalInstructionsExecuted)}\n`;
+      }
+      if (enqueuedCall.reverted) {
+        pretty += `${INDENT2}Reverted!\n`;
+      }
+    }
+    return pretty;
+  }
+
+  toJSON(indent = 2) {
+    return JSON.stringify(Object.fromEntries(this.txMetrics.entries()), null, indent);
+  }
+
+  toGithubActionBenchmarkJSON(indent = 2) {
+    const metricsInfo = {
+      totalInstructionsExecuted: {
+        name: 'totalInstructionsExecuted',
+        unit: '#instructions',
+        category: PublicTxMetricsFilter.INSTRUCTIONS,
+      },
+      totalDurationMs: {
+        name: 'totalDurationMs',
+        unit: 'ms',
+        category: PublicTxMetricsFilter.DURATIONS,
+      },
+      manaUsed: {
+        name: 'manaUsed',
+        unit: 'mana',
+        category: PublicTxMetricsFilter.TOTALS,
+      },
+      nonRevertiblePrivateInsertionsUs: {
+        name: 'nonRevertiblePrivateInsertionsUs',
+        unit: 'us',
+        category: PublicTxMetricsFilter.DURATIONS,
+      },
+      revertiblePrivateInsertionsUs: {
+        name: 'revertiblePrivateInsertionsUs',
+        unit: 'us',
+        category: PublicTxMetricsFilter.DURATIONS,
+      },
+      proverSimulationStepMs: {
+        name: 'proverSimulationStepMs',
+        unit: 'ms',
+        category: PublicTxMetricsFilter.PROVING,
+      },
+      proverProvingStepMs: {
+        name: 'proverProvingStepMs',
+        unit: 'ms',
+        category: PublicTxMetricsFilter.PROVING,
+      },
+      proverTraceGenerationStepMs: {
+        name: 'proverTraceGenerationStepMs',
+        unit: 'ms',
+        category: PublicTxMetricsFilter.PROVING,
+      },
+      traceGenerationInteractionsMs: {
+        name: 'traceGenerationInteractionsMs',
+        unit: 'ms',
+        category: PublicTxMetricsFilter.PROVING,
+      },
+      traceGenerationTracesMs: {
+        name: 'traceGenerationTracesMs',
+        unit: 'ms',
+        category: PublicTxMetricsFilter.PROVING,
+      },
+      provingSumcheckMs: {
+        name: 'provingSumcheckMs',
+        unit: 'ms',
+        category: PublicTxMetricsFilter.PROVING,
+      },
+      provingPcsMs: {
+        name: 'provingPcsMs',
+        unit: 'ms',
+        category: PublicTxMetricsFilter.PROVING,
+      },
+      provingLogDerivativeInverseMs: {
+        name: 'provingLogDerivativeInverseMs',
+        unit: 'ms',
+        category: PublicTxMetricsFilter.PROVING,
+      },
+      provingLogDerivativeInverseCommitmentsMs: {
+        name: 'provingLogDerivativeInverseCommitmentsMs',
+        unit: 'ms',
+        category: PublicTxMetricsFilter.PROVING,
+      },
+      provingWireCommitmentsMs: {
+        name: 'provingWireCommitmentsMs',
+        unit: 'ms',
+        category: PublicTxMetricsFilter.PROVING,
+      },
+    };
+
+    const data = [];
+    for (const [txLabel, txMetrics] of this.txMetrics.entries()) {
+      for (const [key, value] of Object.entries(txMetrics)) {
+        if (value !== undefined && key in metricsInfo) {
+          data.push({
+            name: `${txLabel}/${metricsInfo[key as keyof typeof metricsInfo].name}`,
+            value: value,
+            unit: metricsInfo[key as keyof typeof metricsInfo].unit,
+          });
+        }
+      }
+    }
+    return JSON.stringify(data, null, indent);
+  }
+}
+
+function fmtNum(num: number, unit?: string) {
+  return `\`${num.toLocaleString()}${unit ? ` ${unit}` : ''}\``;
+}

package/src/public/utils.ts

@@ -1,29 +1,13 @@
-import type { PublicCallRequest } from '@aztec/stdlib/kernel';
-import { type PublicExecutionRequest, type Tx, TxExecutionPhase } from '@aztec/stdlib/tx';
+import { PublicCallRequestWithCalldata, type Tx, TxExecutionPhase } from '@aztec/stdlib/tx';
 
-export function getExecutionRequestsByPhase(tx: Tx, phase: TxExecutionPhase): PublicExecutionRequest[] {
+export function getCallRequestsWithCalldataByPhase(tx: Tx, phase: TxExecutionPhase): PublicCallRequestWithCalldata[] {
   switch (phase) {
     case TxExecutionPhase.SETUP:
-      return tx.getNonRevertiblePublicExecutionRequests();
+      return tx.getNonRevertiblePublicCallRequestsWithCalldata();
     case TxExecutionPhase.APP_LOGIC:
-      return tx.getRevertiblePublicExecutionRequests();
+      return tx.getRevertiblePublicCallRequestsWithCalldata();
     case TxExecutionPhase.TEARDOWN: {
-      const request = tx.getPublicTeardownExecutionRequest();
-      return request ? [request] : [];
-    }
-    default:
-      throw new Error(`Unknown phase: ${phase}`);
-  }
-}
-
-export function getCallRequestsByPhase(tx: Tx, phase: TxExecutionPhase): PublicCallRequest[] {
-  switch (phase) {
-    case TxExecutionPhase.SETUP:
-      return tx.data.getNonRevertiblePublicCallRequests();
-    case TxExecutionPhase.APP_LOGIC:
-      return tx.data.getRevertiblePublicCallRequests();
-    case TxExecutionPhase.TEARDOWN: {
-      const request = tx.data.getTeardownPublicCallRequest();
+      const request = tx.getTeardownPublicCallRequestWithCalldata();
       return request ? [request] : [];
     }
     default:

package/src/server.ts

@@ -1,5 +1,8 @@
 export * from './public/index.js';
-export { WASMSimulatorWithBlobs } from './private/providers/acvm_wasm_with_blobs.js';
-export { NativeACVMSimulator } from './private/providers/acvm_native.js';
-export { type SimulationProvider } from './private/providers/simulation_provider.js';
+export * from './private/acvm/index.js';
+export { WASMSimulatorWithBlobs } from './private/acvm_wasm_with_blobs.js';
+export { NativeACVMSimulator } from './private/acvm_native.js';
+export { SimulatorRecorderWrapper } from './private/circuit_recording/simulator_recorder_wrapper.js';
+export { MemoryCircuitRecorder } from './private/circuit_recording/memory_circuit_recorder.js';
+export { type CircuitSimulator, type DecodedError } from './private/circuit_simulator.js';
 export * from './common/index.js';

package/src/testing.ts

@@ -0,0 +1 @@
+export { FileCircuitRecorder } from './private/circuit_recording/file_circuit_recorder.js';

package/dest/common/db_interfaces.d.ts

@@ -1,80 +0,0 @@
-import type { L1_TO_L2_MSG_TREE_HEIGHT } from '@aztec/constants';
-import type { Fr } from '@aztec/foundation/fields';
-import type { FunctionSelector } from '@aztec/stdlib/abi';
-import type { AztecAddress } from '@aztec/stdlib/aztec-address';
-import type { ContractInstanceWithAddress } from '@aztec/stdlib/contract';
-import type { NullifierMembershipWitness } from '@aztec/stdlib/trees';
-import type { MessageLoadOracleInputs } from './message_load_oracle_inputs.js';
-/**
- * Database interface for providing access to public state.
- */
-export interface PublicStateDB {
-    /**
-     * Reads a value from public storage, returning zero if none.
-     * @param contract - Owner of the storage.
-     * @param slot - Slot to read in the contract storage.
-     * @returns The current value in the storage slot.
-     */
-    storageRead(contract: AztecAddress, slot: Fr): Promise<Fr>;
-    /**
-     * Records a write to public storage.
-     * @param contract - Owner of the storage.
-     * @param slot - Slot to read in the contract storage.
-     * @param newValue - The new value to store.
-     */
-    storageWrite(contract: AztecAddress, slot: Fr, newValue: Fr): Promise<void>;
-}
-/**
- * Database interface for providing access to public contract data.
- */
-export interface PublicContractsDB {
-    /**
-     * Returns a publicly deployed contract instance.
-     * @param address - Address of the contract.
-     * @returns The contract instance or undefined if not found.
-     */
-    getContractInstance(address: AztecAddress): Promise<ContractInstanceWithAddress | undefined>;
-    getDebugFunctionName(contractAddress: AztecAddress, selector: FunctionSelector): Promise<string | undefined>;
-}
-/** Database interface for providing access to commitment tree, l1 to l2 message tree, and nullifier tree. */
-export interface CommitmentsDB {
-    /**
-     * Fetches a message from the db, given its key.
-     * @param contractAddress - Address of a contract by which the message was emitted.
-     * @param messageHash - Hash of the message.
-     * @param secret - Secret used to compute a nullifier.
-     * @dev Contract address and secret are only used to compute the nullifier to get non-nullified messages
-     * @returns The l1 to l2 membership witness (index of message in the tree and sibling path).
-     */
-    getL1ToL2MembershipWitness(contractAddress: AztecAddress, messageHash: Fr, secret: Fr): Promise<MessageLoadOracleInputs<typeof L1_TO_L2_MSG_TREE_HEIGHT>>;
-    /**
-     * @param leafIndex the leaf to look up
-     * @returns The l1 to l2 leaf value or undefined if not found.
-     */
-    getL1ToL2LeafValue(leafIndex: bigint): Promise<Fr | undefined>;
-    /**
-     * Gets the index of a commitment in the note hash tree.
-     * @param commitment - The commitment.
-     * @returns - The index of the commitment. Undefined if it does not exist in the tree.
-     */
-    getCommitmentIndex(commitment: Fr): Promise<bigint | undefined>;
-    /**
-     * Gets commitment in the note hash tree given a leaf index.
-     * @param leafIndex - the leaf to look up.
-     * @returns - The commitment at that index. Undefined if leaf index is not found.
-     */
-    getCommitmentValue(leafIndex: bigint): Promise<Fr | undefined>;
-    /**
-     * Gets the index of a nullifier in the nullifier tree.
-     * @param nullifier - The nullifier.
-     * @returns - The index of the nullifier. Undefined if it does not exist in the tree.
-     */
-    getNullifierIndex(nullifier: Fr): Promise<bigint | undefined>;
-    /**
-     * Returns a nullifier membership witness for the given nullifier or undefined if not found.
-     * REFACTOR: Same as getL1ToL2MembershipWitness, can be combined with aztec-node method that does almost the same thing.
-     * @param nullifier - Nullifier we're looking for.
-     */
-    getNullifierMembershipWitnessAtLatestBlock(nullifier: Fr): Promise<NullifierMembershipWitness | undefined>;
-}
-//# sourceMappingURL=db_interfaces.d.ts.map

package/dest/common/db_interfaces.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"db_interfaces.d.ts","sourceRoot":"","sources":["../../src/common/db_interfaces.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,kBAAkB,CAAC;AACjE,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AACnD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAC1D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAChE,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,wBAAwB,CAAC;AAC1E,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,qBAAqB,CAAC;AAEtE,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,iCAAiC,CAAC;AAE/E;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B;;;;;OAKG;IACH,WAAW,CAAC,QAAQ,EAAE,YAAY,EAAE,IAAI,EAAE,EAAE,GAAG,OAAO,CAAC,EAAE,CAAC,CAAC;IAE3D;;;;;OAKG;IACH,YAAY,CAAC,QAAQ,EAAE,YAAY,EAAE,IAAI,EAAE,EAAE,EAAE,QAAQ,EAAE,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CAC7E;AAED;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC;;;;OAIG;IACH,mBAAmB,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,2BAA2B,GAAG,SAAS,CAAC,CAAC;IAE7F,oBAAoB,CAAC,eAAe,EAAE,YAAY,EAAE,QAAQ,EAAE,gBAAgB,GAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAAC;CAC9G;AAED,6GAA6G;AAC7G,MAAM,WAAW,aAAa;IAC5B;;;;;;;OAOG;IACH,0BAA0B,CACxB,eAAe,EAAE,YAAY,EAC7B,WAAW,EAAE,EAAE,EACf,MAAM,EAAE,EAAE,GACT,OAAO,CAAC,uBAAuB,CAAC,OAAO,wBAAwB,CAAC,CAAC,CAAC;IAErE;;;OAGG;IACH,kBAAkB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,EAAE,GAAG,SAAS,CAAC,CAAC;IAE/D;;;;OAIG;IACH,kBAAkB,CAAC,UAAU,EAAE,EAAE,GAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAAC;IAEhE;;;;OAIG;IACH,kBAAkB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,EAAE,GAAG,SAAS,CAAC,CAAC;IAE/D;;;;OAIG;IACH,iBAAiB,CAAC,SAAS,EAAE,EAAE,GAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAAC;IAE9D;;;;OAIG;IACH,0CAA0C,CAAC,SAAS,EAAE,EAAE,GAAG,OAAO,CAAC,0BAA0B,GAAG,SAAS,CAAC,CAAC;CAC5G"}

package/dest/common/db_interfaces.js

@@ -1 +0,0 @@
-/** Database interface for providing access to commitment tree, l1 to l2 message tree, and nullifier tree. */ export { };

package/dest/common/debug_fn_name.d.ts

@@ -1,5 +0,0 @@
-import type { Fr } from '@aztec/foundation/fields';
-import type { AztecAddress } from '@aztec/stdlib/aztec-address';
-import type { WorldStateDB } from '../public/public_db_sources.js';
-export declare function getPublicFunctionDebugName(db: WorldStateDB, contractAddress: AztecAddress, calldata: Fr[]): Promise<string>;
-//# sourceMappingURL=debug_fn_name.d.ts.map

package/dest/common/debug_fn_name.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"debug_fn_name.d.ts","sourceRoot":"","sources":["../../src/common/debug_fn_name.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAEnD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAEhE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gCAAgC,CAAC;AAEnE,wBAAsB,0BAA0B,CAC9C,EAAE,EAAE,YAAY,EAChB,eAAe,EAAE,YAAY,EAC7B,QAAQ,EAAE,EAAE,EAAE,GACb,OAAO,CAAC,MAAM,CAAC,CAOjB"}

package/dest/common/debug_fn_name.js

@@ -1,6 +0,0 @@
-import { FunctionSelector } from '@aztec/stdlib/abi';
-export async function getPublicFunctionDebugName(db, contractAddress, calldata) {
-    // Public function is dispatched and therefore the target function is passed in the first argument.
-    const targetFunction = calldata[0] !== undefined ? await db.getDebugFunctionName(contractAddress, FunctionSelector.fromField(calldata[0])) : `<calldata[0] undefined> (Contract Address: ${contractAddress})`;
-    return `${targetFunction}`;
-}

package/dest/common/message_load_oracle_inputs.d.ts

@@ -1,15 +0,0 @@
-import { Fr } from '@aztec/foundation/fields';
-import type { SiblingPath } from '@aztec/foundation/trees';
-export declare class MessageLoadOracleInputs<N extends number> {
-    /** The index of the message commitment in the merkle tree. */
-    index: bigint;
-    /** The path in the merkle tree to the message. */
-    siblingPath: SiblingPath<N>;
-    constructor(
-    /** The index of the message commitment in the merkle tree. */
-    index: bigint, 
-    /** The path in the merkle tree to the message. */
-    siblingPath: SiblingPath<N>);
-    toFields(): Fr[];
-}
-//# sourceMappingURL=message_load_oracle_inputs.d.ts.map

package/dest/common/message_load_oracle_inputs.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"message_load_oracle_inputs.d.ts","sourceRoot":"","sources":["../../src/common/message_load_oracle_inputs.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAC9C,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAE3D,qBAAa,uBAAuB,CAAC,CAAC,SAAS,MAAM;IAEjD,8DAA8D;IACvD,KAAK,EAAE,MAAM;IACpB,kDAAkD;IAC3C,WAAW,EAAE,WAAW,CAAC,CAAC,CAAC;;IAHlC,8DAA8D;IACvD,KAAK,EAAE,MAAM;IACpB,kDAAkD;IAC3C,WAAW,EAAE,WAAW,CAAC,CAAC,CAAC;IAGpC,QAAQ,IAAI,EAAE,EAAE;CAGjB"}

package/dest/common/message_load_oracle_inputs.js

@@ -1,15 +0,0 @@
-import { Fr } from '@aztec/foundation/fields';
-export class MessageLoadOracleInputs {
-    index;
-    siblingPath;
-    constructor(/** The index of the message commitment in the merkle tree. */ index, /** The path in the merkle tree to the message. */ siblingPath){
-        this.index = index;
-        this.siblingPath = siblingPath;
-    }
-    toFields() {
-        return [
-            new Fr(this.index),
-            ...this.siblingPath.toFields()
-        ];
-    }
-}

package/dest/private/acvm/oracle/index.d.ts

@@ -1,14 +0,0 @@
-import type { Oracle } from './oracle.js';
-export * from './oracle.js';
-export * from './typed_oracle.js';
-/**
- * A conditional type that takes a type `T` and returns a union of its method names.
- */
-type MethodNames<T> = {
-    [K in keyof T]: T[K] extends (...args: any[]) => any ? K : never;
-}[keyof T];
-/**
- * Available oracle function names.
- */
-export type ORACLE_NAMES = MethodNames<Oracle>;
-//# sourceMappingURL=index.d.ts.map

package/dest/private/acvm/oracle/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/private/acvm/oracle/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAE1C,cAAc,aAAa,CAAC;AAC5B,cAAc,mBAAmB,CAAC;AAElC;;GAEG;AACH,KAAK,WAAW,CAAC,CAAC,IAAI;KACnB,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,GAAG,CAAC,GAAG,KAAK;CACjE,CAAC,MAAM,CAAC,CAAC,CAAC;AAEX;;GAEG;AACH,MAAM,MAAM,YAAY,GAAG,WAAW,CAAC,MAAM,CAAC,CAAC"}

package/dest/private/acvm/oracle/index.js

@@ -1,2 +0,0 @@
-export * from './oracle.js';
-export * from './typed_oracle.js';

package/dest/private/acvm/oracle/oracle.d.ts

@@ -1,49 +0,0 @@
-import type { ACVMField } from '../acvm_types.js';
-import type { TypedOracle } from './typed_oracle.js';
-/**
- * A data source that has all the apis required by Aztec.nr.
- */
-export declare class Oracle {
-    private typedOracle;
-    constructor(typedOracle: TypedOracle);
-    getRandomField(): ACVMField;
-    storeInExecutionCache(_length: ACVMField[], values: ACVMField[]): Promise<ACVMField>;
-    loadFromExecutionCache([returnsHash]: ACVMField[]): Promise<ACVMField[]>;
-    getBlockNumber(): Promise<ACVMField>;
-    getContractAddress(): Promise<ACVMField>;
-    getVersion(): Promise<ACVMField>;
-    getChainId(): Promise<ACVMField>;
-    getKeyValidationRequest([pkMHash]: ACVMField[]): Promise<ACVMField[]>;
-    getContractInstance([address]: ACVMField[]): Promise<string[]>;
-    getMembershipWitness([blockNumber]: ACVMField[], [treeId]: ACVMField[], [leafValue]: ACVMField[]): Promise<ACVMField[]>;
-    getNullifierMembershipWitness([blockNumber]: ACVMField[], [nullifier]: ACVMField[]): Promise<ACVMField[]>;
-    getLowNullifierMembershipWitness([blockNumber]: ACVMField[], [nullifier]: ACVMField[]): Promise<ACVMField[]>;
-    getPublicDataTreeWitness([blockNumber]: ACVMField[], [leafSlot]: ACVMField[]): Promise<ACVMField[]>;
-    getBlockHeader([blockNumber]: ACVMField[]): Promise<ACVMField[]>;
-    getAuthWitness([messageHash]: ACVMField[]): Promise<ACVMField[]>;
-    getPublicKeysAndPartialAddress([address]: ACVMField[]): Promise<ACVMField[]>;
-    getNotes([storageSlot]: ACVMField[], [numSelects]: ACVMField[], selectByIndexes: ACVMField[], selectByOffsets: ACVMField[], selectByLengths: ACVMField[], selectValues: ACVMField[], selectComparators: ACVMField[], sortByIndexes: ACVMField[], sortByOffsets: ACVMField[], sortByLengths: ACVMField[], sortOrder: ACVMField[], [limit]: ACVMField[], [offset]: ACVMField[], [status]: ACVMField[], [returnSize]: ACVMField[]): Promise<ACVMField[]>;
-    notifyCreatedNote([storageSlot]: ACVMField[], [noteTypeId]: ACVMField[], note: ACVMField[], [noteHash]: ACVMField[], [counter]: ACVMField[]): ACVMField;
-    notifyNullifiedNote([innerNullifier]: ACVMField[], [noteHash]: ACVMField[], [counter]: ACVMField[]): Promise<ACVMField>;
-    notifyCreatedNullifier([innerNullifier]: ACVMField[]): Promise<ACVMField>;
-    checkNullifierExists([innerNullifier]: ACVMField[]): Promise<ACVMField>;
-    getL1ToL2MembershipWitness([contractAddress]: ACVMField[], [messageHash]: ACVMField[], [secret]: ACVMField[]): Promise<ACVMField[]>;
-    storageRead([contractAddress]: ACVMField[], [startStorageSlot]: ACVMField[], [blockNumber]: ACVMField[], [numberOfElements]: ACVMField[]): Promise<ACVMField[]>;
-    storageWrite([startStorageSlot]: ACVMField[], values: ACVMField[]): Promise<ACVMField[]>;
-    notifyCreatedContractClassLog([contractAddress]: ACVMField[], message: ACVMField[], [counter]: ACVMField[]): void;
-    debugLog(message: ACVMField[], _ignoredFieldsSize: ACVMField[], fields: ACVMField[]): void;
-    callPrivateFunction([contractAddress]: ACVMField[], [functionSelector]: ACVMField[], [argsHash]: ACVMField[], [sideEffectCounter]: ACVMField[], [isStaticCall]: ACVMField[]): Promise<ACVMField[]>;
-    enqueuePublicFunctionCall([contractAddress]: ACVMField[], [functionSelector]: ACVMField[], [argsHash]: ACVMField[], [sideEffectCounter]: ACVMField[], [isStaticCall]: ACVMField[]): Promise<ACVMField>;
-    setPublicTeardownFunctionCall([contractAddress]: ACVMField[], [functionSelector]: ACVMField[], [argsHash]: ACVMField[], [sideEffectCounter]: ACVMField[], [isStaticCall]: ACVMField[]): Promise<ACVMField>;
-    notifySetMinRevertibleSideEffectCounter([minRevertibleSideEffectCounter]: ACVMField[]): void;
-    getIndexedTaggingSecretAsSender([sender]: ACVMField[], [recipient]: ACVMField[]): Promise<ACVMField[]>;
-    incrementAppTaggingSecretIndexAsSender([sender]: ACVMField[], [recipient]: ACVMField[]): Promise<void>;
-    syncNotes(): Promise<void>;
-    deliverNote([contractAddress]: ACVMField[], [storageSlot]: ACVMField[], [nonce]: ACVMField[], content: ACVMField[], [contentLength]: ACVMField[], [noteHash]: ACVMField[], [nullifier]: ACVMField[], [txHash]: ACVMField[], [recipient]: ACVMField[]): Promise<ACVMField>;
-    getLogByTag([tag]: ACVMField[]): Promise<(ACVMField | ACVMField[])[]>;
-    storeCapsule([contractAddress]: ACVMField[], [slot]: ACVMField[], capsule: ACVMField[]): Promise<void>;
-    loadCapsule([contractAddress]: ACVMField[], [slot]: ACVMField[], [tSize]: ACVMField[]): Promise<(ACVMField | ACVMField[])[]>;
-    deleteCapsule([contractAddress]: ACVMField[], [slot]: ACVMField[]): Promise<void>;
-    copyCapsule([contractAddress]: ACVMField[], [srcSlot]: ACVMField[], [dstSlot]: ACVMField[], [numEntries]: ACVMField[]): Promise<void>;
-}
-//# sourceMappingURL=oracle.d.ts.map