@aztec/simulator 0.69.1 → 0.71.0

package/src/providers/acvm_wasm.ts

@@ -1,25 +1,52 @@
 import { foreignCallHandler } from '@aztec/noir-protocol-circuits-types/client';
 import { type NoirCompiledCircuit } from '@aztec/types/noir';
 
-import { executeCircuit } from '@noir-lang/acvm_js';
+import initACVM, { type ExecutionError, executeCircuit } from '@noir-lang/acvm_js';
+import initAbi from '@noir-lang/noirc_abi';
 import { type WitnessMap } from '@noir-lang/types';
 
-import { type SimulationProvider } from './simulation_provider.js';
+import { type ACIRCallback, acvm } from '../acvm/acvm.js';
+import { type ACVMWitness } from '../acvm/acvm_types.js';
+import { type SimulationProvider, parseErrorPayload } from '../common/simulation_provider.js';
 
 export class WASMSimulator implements SimulationProvider {
-  async simulateCircuit(input: WitnessMap, compiledCircuit: NoirCompiledCircuit): Promise<WitnessMap> {
+  async init(): Promise<void> {
+    // If these are available, then we are in the
+    // web environment. For the node environment, this
+    // is a no-op.
+    if (typeof initAbi === 'function') {
+      /** @ts-expect-error The node bundle doesn't include these default imports, so TS complains */
+      await Promise.all([initAbi(), initACVM()]);
+    }
+  }
+
+  async executeProtocolCircuit(input: WitnessMap, compiledCircuit: NoirCompiledCircuit): Promise<WitnessMap> {
+    await this.init();
     // Execute the circuit on those initial witness values
     //
     // Decode the bytecode from base64 since the acvm does not know about base64 encoding
     const decodedBytecode = Buffer.from(compiledCircuit.bytecode, 'base64');
     //
     // Execute the circuit
-    const _witnessMap = await executeCircuit(
-      decodedBytecode,
-      input,
-      foreignCallHandler, // handle calls to debug_log
-    );
+    try {
+      const _witnessMap = await executeCircuit(
+        decodedBytecode,
+        input,
+        foreignCallHandler, // handle calls to debug_log
+      );
+
+      return _witnessMap;
+    } catch (err) {
+      // Typescript types catched errors as unknown or any, so we need to narrow its type to check if it has raw assertion payload.
+      if (typeof err === 'object' && err !== null && 'rawAssertionPayload' in err) {
+        throw parseErrorPayload(compiledCircuit.abi, err as ExecutionError);
+      }
+      throw new Error(`Circuit execution failed: ${err}`);
+    }
+  }
 
-    return _witnessMap;
+  async executeUserCircuit(acir: Buffer, initialWitness: ACVMWitness, callback: ACIRCallback) {
+    await this.init();
+    return acvm(acir, initialWitness, callback);
   }
 }

package/src/providers/acvm_wasm_with_blobs.ts

@@ -1,25 +1,50 @@
-import { foreignCallHandler } from '@aztec/noir-protocol-circuits-types';
+import { foreignCallHandler } from '@aztec/noir-protocol-circuits-types/server';
 import { type NoirCompiledCircuit } from '@aztec/types/noir';
 
-import { executeCircuit } from '@noir-lang/acvm_js';
+import { type ExecutionError, executeCircuit } from '@noir-lang/acvm_js';
 import { type WitnessMap } from '@noir-lang/types';
 
-import { type SimulationProvider } from './simulation_provider.js';
+import { type ACIRCallback, type ACIRExecutionResult } from '../acvm/acvm.js';
+import { type ACVMWitness } from '../acvm/acvm_types.js';
+import { type SimulationProvider, parseErrorPayload } from '../common/simulation_provider.js';
 
+/**
+ * A simulation provider that uses the WASM simulator with the ability to handle blobs via the foreign call handler.
+ * This class is temporary while brillig cannot handle the blob math, and it is kept separate
+ * because the zkg commitment library used in the blob code is not browser compatible.
+ *
+ * It is only used in the context of server-side code executing simulated protocol circuits.
+ */
 export class WASMSimulatorWithBlobs implements SimulationProvider {
-  async simulateCircuit(input: WitnessMap, compiledCircuit: NoirCompiledCircuit): Promise<WitnessMap> {
+  async executeProtocolCircuit(input: WitnessMap, compiledCircuit: NoirCompiledCircuit): Promise<WitnessMap> {
     // Execute the circuit on those initial witness values
     //
     // Decode the bytecode from base64 since the acvm does not know about base64 encoding
     const decodedBytecode = Buffer.from(compiledCircuit.bytecode, 'base64');
     //
     // Execute the circuit
-    const _witnessMap = await executeCircuit(
-      decodedBytecode,
-      input,
-      foreignCallHandler, // handle calls to debug_log and evaluate_blobs mock
-    );
+    try {
+      const _witnessMap = await executeCircuit(
+        decodedBytecode,
+        input,
+        foreignCallHandler, // handle calls to debug_log and evaluate_blobs mock
+      );
 
-    return _witnessMap;
+      return _witnessMap;
+    } catch (err) {
+      // Typescript types catched errors as unknown or any, so we need to narrow its type to check if it has raw assertion payload.
+      if (typeof err === 'object' && err !== null && 'rawAssertionPayload' in err) {
+        throw parseErrorPayload(compiledCircuit.abi, err as ExecutionError);
+      }
+      throw new Error(`Circuit execution failed: ${err}`);
+    }
+  }
+
+  executeUserCircuit(
+    _acir: Buffer,
+    _initialWitness: ACVMWitness,
+    _callback: ACIRCallback,
+  ): Promise<ACIRExecutionResult> {
+    throw new Error('Not implemented');
   }
 }

package/src/providers/factory.ts

@@ -2,9 +2,9 @@ import { type Logger, createLogger } from '@aztec/foundation/log';
 
 import { promises as fs } from 'fs';
 
+import { type SimulationProvider } from '../common/simulation_provider.js';
 import { NativeACVMSimulator } from './acvm_native.js';
 import { WASMSimulator } from './acvm_wasm.js';
-import { type SimulationProvider } from './simulation_provider.js';
 
 export type SimulationProviderConfig = {
   acvmBinaryPath?: string;

package/src/providers/index.ts

@@ -1,4 +1,4 @@
 export * from './acvm_native.js';
 export * from './acvm_wasm_with_blobs.js';
-export * from './simulation_provider.js';
+export * from '../common/simulation_provider.js';
 export * from './factory.js';

package/src/public/db_interfaces.ts

@@ -7,7 +7,7 @@ import {
 import { type AztecAddress } from '@aztec/foundation/aztec-address';
 import { type Fr } from '@aztec/foundation/fields';
 
-import { type MessageLoadOracleInputs } from '../acvm/index.js';
+import { type MessageLoadOracleInputs } from '../common/message_load_oracle_inputs.js';
 
 /**
  * Database interface for providing access to public state.

package/src/public/fixtures/index.ts

@@ -32,25 +32,25 @@ import { AztecAddress } from '@aztec/foundation/aztec-address';
 import { Fr, Point } from '@aztec/foundation/fields';
 import { openTmpStore } from '@aztec/kv-store/lmdb';
 import { AvmTestContractArtifact } from '@aztec/noir-contracts.js/AvmTest';
-import {
-  AvmEphemeralForest,
-  AvmSimulator,
-  PublicEnqueuedCallSideEffectTrace,
-  PublicTxSimulator,
-  WorldStateDB,
-} from '@aztec/simulator';
-import { NoopTelemetryClient } from '@aztec/telemetry-client/noop';
 import { MerkleTrees } from '@aztec/world-state';
 
 import { strict as assert } from 'assert';
 
 import { initContext, initExecutionEnvironment, initPersistableStateManager } from '../../avm/fixtures/index.js';
+import { AvmEphemeralForest, AvmSimulator } from '../../server.js';
+import { PublicEnqueuedCallSideEffectTrace } from '../enqueued_call_side_effect_trace.js';
+import { WorldStateDB } from '../public_db_sources.js';
+import { PublicTxSimulator } from '../public_tx_simulator.js';
 
 const TIMESTAMP = new Fr(99833);
 
 export async function simulateAvmTestContractGenerateCircuitInputs(
-  functionName: string,
-  args: Fr[] = [],
+  setupFunctionNames: string[],
+  setupArgs: Fr[][] = [],
+  appFunctionNames: string[],
+  appArgs: Fr[][] = [],
+  teardownFunctionName?: string,
+  teardownArgs: Fr[] = [],
   expectRevert: boolean = false,
   contractDataSource = new MockedAvmTestContractDataSource(),
   assertionErrString?: string,
@@ -58,30 +58,42 @@ export async function simulateAvmTestContractGenerateCircuitInputs(
   const globals = GlobalVariables.empty();
   globals.timestamp = TIMESTAMP;
 
-  const merkleTrees = await (await MerkleTrees.new(openTmpStore(), new NoopTelemetryClient())).fork();
+  const merkleTrees = await (await MerkleTrees.new(openTmpStore())).fork();
   await contractDataSource.deployContracts(merkleTrees);
   const worldStateDB = new WorldStateDB(merkleTrees, contractDataSource);
 
-  const simulator = new PublicTxSimulator(
-    merkleTrees,
-    worldStateDB,
-    new NoopTelemetryClient(),
-    globals,
-    /*doMerkleOperations=*/ true,
-  );
+  const simulator = new PublicTxSimulator(merkleTrees, worldStateDB, globals, /*doMerkleOperations=*/ true);
 
   const sender = AztecAddress.random();
-  const functionSelector = getAvmTestContractFunctionSelector(functionName);
-  args = [functionSelector.toField(), ...args];
   const callContext = new CallContext(
     sender,
     contractDataSource.firstContractInstance.address,
     contractDataSource.fnSelector,
     /*isStaticCall=*/ false,
   );
-  const executionRequest = new PublicExecutionRequest(callContext, args);
+  const setupExecutionRequests: PublicExecutionRequest[] = [];
+  for (let i = 0; i < setupFunctionNames.length; i++) {
+    const functionSelector = getAvmTestContractFunctionSelector(setupFunctionNames[i]);
+    const fnArgs = [functionSelector.toField(), ...setupArgs[i]];
+    const executionRequest = new PublicExecutionRequest(callContext, fnArgs);
+    setupExecutionRequests.push(executionRequest);
+  }
+  const appExecutionRequests: PublicExecutionRequest[] = [];
+  for (let i = 0; i < appFunctionNames.length; i++) {
+    const functionSelector = getAvmTestContractFunctionSelector(appFunctionNames[i]);
+    const fnArgs = [functionSelector.toField(), ...appArgs[i]];
+    const executionRequest = new PublicExecutionRequest(callContext, fnArgs);
+    appExecutionRequests.push(executionRequest);
+  }
 
-  const tx: Tx = createTxForPublicCall(executionRequest);
+  let teardownExecutionRequest: PublicExecutionRequest | undefined = undefined;
+  if (teardownFunctionName) {
+    const functionSelector = getAvmTestContractFunctionSelector(teardownFunctionName);
+    const fnArgs = [functionSelector.toField(), ...teardownArgs];
+    teardownExecutionRequest = new PublicExecutionRequest(callContext, fnArgs);
+  }
+
+  const tx: Tx = createTxForPublicCalls(setupExecutionRequests, appExecutionRequests, teardownExecutionRequest);
 
   const avmResult = await simulator.simulate(tx);
 
@@ -109,7 +121,7 @@ export async function simulateAvmTestContractCall(
   const globals = GlobalVariables.empty();
   globals.timestamp = TIMESTAMP;
 
-  const merkleTrees = await (await MerkleTrees.new(openTmpStore(), new NoopTelemetryClient())).fork();
+  const merkleTrees = await (await MerkleTrees.new(openTmpStore())).fork();
   await contractDataSource.deployContracts(merkleTrees);
   const worldStateDB = new WorldStateDB(merkleTrees, contractDataSource);
 
@@ -141,27 +153,39 @@ export async function simulateAvmTestContractCall(
 }
 
 /**
- * Craft a carrier transaction for a public call for simulation by PublicTxSimulator.
+ * Craft a carrier transaction for some public calls for simulation by PublicTxSimulator.
  */
-export function createTxForPublicCall(
-  executionRequest: PublicExecutionRequest,
+export function createTxForPublicCalls(
+  setupExecutionRequests: PublicExecutionRequest[],
+  appExecutionRequests: PublicExecutionRequest[],
+  teardownExecutionRequest?: PublicExecutionRequest,
   gasUsedByPrivate: Gas = Gas.empty(),
-  isTeardown: boolean = false,
 ): Tx {
-  const callRequest = executionRequest.toCallRequest();
+  assert(
+    setupExecutionRequests.length > 0 || appExecutionRequests.length > 0 || teardownExecutionRequest !== undefined,
+    "Can't create public tx with no enqueued calls",
+  );
+  const setupCallRequests = setupExecutionRequests.map(er => er.toCallRequest());
+  const appCallRequests = appExecutionRequests.map(er => er.toCallRequest());
   // use max limits
   const gasLimits = new Gas(DEFAULT_GAS_LIMIT, MAX_L2_GAS_PER_TX_PUBLIC_PORTION);
 
   const forPublic = PartialPrivateTailPublicInputsForPublic.empty();
   // TODO(#9269): Remove this fake nullifier method as we move away from 1st nullifier as hash.
   forPublic.nonRevertibleAccumulatedData.nullifiers[0] = Fr.random(); // fake tx nullifier
-  if (isTeardown) {
-    forPublic.publicTeardownCallRequest = callRequest;
-  } else {
-    forPublic.revertibleAccumulatedData.publicCallRequests[0] = callRequest;
+
+  // We reverse order because the simulator expects it to be like a "stack" of calls to pop from
+  for (let i = setupCallRequests.length - 1; i >= 0; i--) {
+    forPublic.nonRevertibleAccumulatedData.publicCallRequests[i] = setupCallRequests[i];
+  }
+  for (let i = appCallRequests.length - 1; i >= 0; i--) {
+    forPublic.revertibleAccumulatedData.publicCallRequests[i] = appCallRequests[i];
+  }
+  if (teardownExecutionRequest) {
+    forPublic.publicTeardownCallRequest = teardownExecutionRequest.toCallRequest();
   }
 
-  const teardownGasLimits = isTeardown ? gasLimits : Gas.empty();
+  const teardownGasLimits = teardownExecutionRequest ? gasLimits : Gas.empty();
   const gasSettings = new GasSettings(gasLimits, teardownGasLimits, GasFees.empty(), GasFees.empty());
   const txContext = new TxContext(Fr.zero(), Fr.zero(), gasSettings);
   const constantData = new TxConstantData(BlockHeader.empty(), txContext, Fr.zero(), Fr.zero());
@@ -173,9 +197,15 @@ export function createTxForPublicCall(
     AztecAddress.zero(),
     forPublic,
   );
-  const tx = isTeardown ? Tx.newWithTxData(txData, executionRequest) : Tx.newWithTxData(txData);
-  if (!isTeardown) {
-    tx.enqueuedPublicFunctionCalls[0] = executionRequest;
+  const tx = Tx.newWithTxData(txData, teardownExecutionRequest);
+
+  // Reverse order because the simulator expects it to be like a "stack" of calls to pop from.
+  // Also push app calls before setup calls for this reason.
+  for (let i = appExecutionRequests.length - 1; i >= 0; i--) {
+    tx.enqueuedPublicFunctionCalls.push(appExecutionRequests[i]);
+  }
+  for (let i = setupExecutionRequests.length - 1; i >= 0; i--) {
+    tx.enqueuedPublicFunctionCalls.push(setupExecutionRequests[i]);
   }
 
   return tx;

package/src/public/public_db_sources.ts

@@ -24,12 +24,9 @@ import { createLogger } from '@aztec/foundation/log';
 import { Timer } from '@aztec/foundation/timer';
 import { ContractClassRegisteredEvent } from '@aztec/protocol-contracts/class-registerer';
 import { ContractInstanceDeployedEvent } from '@aztec/protocol-contracts/instance-deployer';
-import {
-  type CommitmentsDB,
-  MessageLoadOracleInputs,
-  type PublicContractsDB,
-  type PublicStateDB,
-} from '@aztec/simulator';
+
+import { MessageLoadOracleInputs } from '../common/message_load_oracle_inputs.js';
+import { type CommitmentsDB, type PublicContractsDB, type PublicStateDB } from './db_interfaces.js';
 
 /**
  * Implements the PublicContractsDB using a ContractDataSource.

package/src/public/public_processor.ts

@@ -27,7 +27,14 @@ import { createLogger } from '@aztec/foundation/log';
 import { type DateProvider, Timer, elapsed, executeTimeout } from '@aztec/foundation/timer';
 import { ProtocolContractAddress } from '@aztec/protocol-contracts';
 import { ContractClassRegisteredEvent } from '@aztec/protocol-contracts/class-registerer';
-import { Attributes, type TelemetryClient, type Traceable, type Tracer, trackSpan } from '@aztec/telemetry-client';
+import {
+  Attributes,
+  type TelemetryClient,
+  type Traceable,
+  type Tracer,
+  getTelemetryClient,
+  trackSpan,
+} from '@aztec/telemetry-client';
 
 import { computeFeePayerBalanceLeafSlot, computeFeePayerBalanceStorageSlot } from './fee_payment.js';
 import { WorldStateDB } from './public_db_sources.js';
@@ -41,7 +48,7 @@ export class PublicProcessorFactory {
   constructor(
     private contractDataSource: ContractDataSource,
     private dateProvider: DateProvider,
-    private telemetryClient: TelemetryClient,
+    private telemetryClient: TelemetryClient = getTelemetryClient(),
   ) {}
 
   /**
@@ -63,10 +70,10 @@ export class PublicProcessorFactory {
     const publicTxSimulator = this.createPublicTxSimulator(
       merkleTree,
       worldStateDB,
-      this.telemetryClient,
       globalVariables,
       /*doMerkleOperations=*/ true,
       enforceFeePayment,
+      this.telemetryClient,
     );
 
     return new PublicProcessor(
@@ -83,18 +90,18 @@ export class PublicProcessorFactory {
   protected createPublicTxSimulator(
     db: MerkleTreeWriteOperations,
     worldStateDB: WorldStateDB,
-    telemetryClient: TelemetryClient,
     globalVariables: GlobalVariables,
     doMerkleOperations: boolean,
     enforceFeePayment: boolean,
+    telemetryClient: TelemetryClient,
   ) {
     return new PublicTxSimulator(
       db,
       worldStateDB,
-      telemetryClient,
       globalVariables,
       doMerkleOperations,
       enforceFeePayment,
+      telemetryClient,
     );
   }
 }
@@ -119,7 +126,7 @@ export class PublicProcessor implements Traceable {
     protected worldStateDB: WorldStateDB,
     protected publicTxSimulator: PublicTxSimulator,
     private dateProvider: DateProvider,
-    telemetryClient: TelemetryClient,
+    telemetryClient: TelemetryClient = getTelemetryClient(),
     private log = createLogger('simulator:public-processor'),
   ) {
     this.metrics = new PublicProcessorMetrics(telemetryClient, 'PublicProcessor');
@@ -290,7 +297,7 @@ export class PublicProcessor implements Traceable {
     return [result, failed, returns];
   }
 
-  @trackSpan('PublicProcessor.processTx', tx => ({ [Attributes.TX_HASH]: tx.tryGetTxHash()?.toString() }))
+  @trackSpan('PublicProcessor.processTx', tx => ({ [Attributes.TX_HASH]: tx.getTxHash().toString() }))
   private async processTx(tx: Tx, deadline?: Date): Promise<[ProcessedTx, NestedProcessReturnValues[]]> {
     const [time, [processedTx, returnValues]] = await elapsed(() => this.processTxWithinDeadline(tx, deadline));
 

package/src/public/public_tx_context.ts

@@ -7,7 +7,7 @@ import {
   type SimulationError,
   type Tx,
   TxExecutionPhase,
-  TxHash,
+  type TxHash,
 } from '@aztec/circuit-types';
 import {
   AvmCircuitInputs,
@@ -61,6 +61,7 @@ export class PublicTxContext {
   public avmProvingRequest: AvmProvingRequest | undefined; // FIXME(dbanks12): remove
 
   constructor(
+    public readonly txHash: TxHash,
     public readonly state: PhaseStateManager,
     private readonly globalVariables: GlobalVariables,
     private readonly startStateReference: StateReference,
@@ -103,12 +104,14 @@ export class PublicTxContext {
       previousAccumulatedDataArrayLengths,
     );
 
+    const firstNullifier = nonRevertibleAccumulatedDataFromPrivate.nullifiers[0];
+
     // Transaction level state manager that will be forked for revertible phases.
     const txStateManager = await AvmPersistableStateManager.create(
       worldStateDB,
       enqueuedCallTrace,
       doMerkleOperations,
-      fetchTxHash(nonRevertibleAccumulatedDataFromPrivate),
+      firstNullifier,
     );
 
     const gasSettings = tx.data.constants.txContext.gasSettings;
@@ -117,6 +120,7 @@ export class PublicTxContext {
     const gasAllocatedToPublic = applyMaxToAvailableGas(gasSettings.gasLimits.sub(gasUsedByPrivate));
 
     return new PublicTxContext(
+      tx.getTxHash(),
       new PhaseStateManager(txStateManager),
       globalVariables,
       await db.getStateReference(),
@@ -188,14 +192,6 @@ export class PublicTxContext {
     return this.revertCode;
   }
 
-  /**
-   * Construct & return transaction hash.
-   * @returns The transaction's hash.
-   */
-  getTxHash(): TxHash {
-    return fetchTxHash(this.nonRevertibleAccumulatedDataFromPrivate);
-  }
-
   /**
    * Are there any call requests for the speciiied phase?
    */
@@ -452,12 +448,3 @@ function applyMaxToAvailableGas(availableGas: Gas) {
     /*l2Gas=*/ Math.min(availableGas.l2Gas, MAX_L2_GAS_PER_TX_PUBLIC_PORTION),
   );
 }
-
-function fetchTxHash(nonRevertibleAccumulatedData: PrivateToPublicAccumulatedData): TxHash {
-  // Private kernel functions are executed client side and for this reason tx hash is already set as first nullifier
-  const firstNullifier = nonRevertibleAccumulatedData.nullifiers[0];
-  if (!firstNullifier || firstNullifier.isZero()) {
-    throw new Error(`Cannot get tx hash since first nullifier is missing`);
-  }
-  return new TxHash(firstNullifier);
-}

package/src/public/public_tx_simulator.ts

@@ -14,7 +14,7 @@ import { type Fr, type Gas, type GlobalVariables, type PublicCallRequest, type R
 import { type Logger, createLogger } from '@aztec/foundation/log';
 import { Timer } from '@aztec/foundation/timer';
 import { ProtocolContractAddress } from '@aztec/protocol-contracts';
-import { Attributes, type TelemetryClient, type Tracer, trackSpan } from '@aztec/telemetry-client';
+import { Attributes, type TelemetryClient, type Tracer, getTelemetryClient, trackSpan } from '@aztec/telemetry-client';
 
 import { strict as assert } from 'assert';
 
@@ -53,10 +53,10 @@ export class PublicTxSimulator {
   constructor(
     private db: MerkleTreeReadOperations,
     private worldStateDB: WorldStateDB,
-    telemetryClient: TelemetryClient,
     private globalVariables: GlobalVariables,
     private doMerkleOperations: boolean = false,
     private enforceFeePayment: boolean = true,
+    telemetryClient: TelemetryClient = getTelemetryClient(),
   ) {
     this.log = createLogger(`simulator:public_tx_simulator`);
     this.metrics = new ExecutorMetrics(telemetryClient, 'PublicTxSimulator');
@@ -219,8 +219,8 @@ export class PublicTxSimulator {
     const callRequests = context.getCallRequestsForPhase(phase);
     const executionRequests = context.getExecutionRequestsForPhase(phase);
 
-    this.log.debug(`Processing phase ${TxExecutionPhase[phase]} for tx ${context.getTxHash()}`, {
-      txHash: context.getTxHash().toString(),
+    this.log.debug(`Processing phase ${TxExecutionPhase[phase]} for tx ${context.txHash}`, {
+      txHash: context.txHash.toString(),
       phase: TxExecutionPhase[phase],
       callRequests: callRequests.length,
       executionRequests: executionRequests.length,
@@ -266,7 +266,7 @@ export class PublicTxSimulator {
    * @returns The result of execution.
    */
   @trackSpan('PublicTxSimulator.simulateEnqueuedCall', (phase, context, _callRequest, executionRequest) => ({
-    [Attributes.TX_HASH]: context.getTxHash().toString(),
+    [Attributes.TX_HASH]: context.txHash.toString(),
     [Attributes.TARGET_ADDRESS]: executionRequest.callContext.contractAddress.toString(),
     [Attributes.SENDER_ADDRESS]: executionRequest.callContext.msgSender.toString(),
     [Attributes.SIMULATOR_PHASE]: TxExecutionPhase[phase].toString(),
@@ -294,7 +294,7 @@ export class PublicTxSimulator {
     const gasUsed = allocatedGas.sub(result.gasLeft); // by enqueued call
     context.consumeGas(phase, gasUsed);
     this.log.debug(
-      `Simulated enqueued public call consumed ${gasUsed.l2Gas} L2 gas ending with ${result.gasLeft.l2Gas} L2 gas left.`,
+      `Simulated enqueued public call (${fnName}) consumed ${gasUsed.l2Gas} L2 gas ending with ${result.gasLeft.l2Gas} L2 gas left.`,
     );
 
     stateManager.traceEnqueuedCall(callRequest, executionRequest.args, result.reverted);

package/{dest/index.d.ts → src/server.ts}

@@ -1,8 +1,5 @@
-export * from './acvm/index.js';
 export * from './avm/index.js';
-export * from './client/index.js';
 export * from './common/index.js';
 export * from './public/index.js';
 export * from './providers/index.js';
 export * from './stats/index.js';
-//# sourceMappingURL=index.d.ts.map

package/dest/common/packed_values_cache.d.ts

@@ -1,28 +0,0 @@
-import { PackedValues } from '@aztec/circuit-types';
-import { Fr } from '@aztec/circuits.js';
-/**
- * A cache for packed values (arguments, returns) during transaction execution.
- */
-export declare class PackedValuesCache {
-    private cache;
-    constructor(initialArguments?: PackedValues[]);
-    /**
-     * Creates a new packed values cache.
-     * @param initialArguments - The initial arguments to add to the cache.
-     * @returns The new packed values cache.
-     */
-    static create(initialArguments?: PackedValues[]): PackedValuesCache;
-    /**
-     * Unpacks packed values.
-     * @param hash - The hash of the packed values.
-     * @returns The unpacked values.
-     */
-    unpack(hash: Fr): Fr[];
-    /**
-     * Packs values.
-     * @param values - The values to pack.
-     * @returns The hash of the packed values.
-     */
-    pack(values: Fr[]): Fr;
-}
-//# sourceMappingURL=packed_values_cache.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"packed_values_cache.d.ts","sourceRoot":"","sources":["../../src/common/packed_values_cache.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AACpD,OAAO,EAAE,EAAE,EAAE,MAAM,oBAAoB,CAAC;AAExC;;GAEG;AACH,qBAAa,iBAAiB;IAC5B,OAAO,CAAC,KAAK,CAAoB;gBAErB,gBAAgB,GAAE,YAAY,EAAO;IAOjD;;;;OAIG;WACW,MAAM,CAAC,gBAAgB,GAAE,YAAY,EAAO;IAI1D;;;;OAIG;IACI,MAAM,CAAC,IAAI,EAAE,EAAE,GAAG,EAAE,EAAE;IAW7B;;;;OAIG;IACI,IAAI,CAAC,MAAM,EAAE,EAAE,EAAE;CAQzB"}

package/dest/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAC;AAChC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,mBAAmB,CAAC;AAClC,cAAc,mBAAmB,CAAC;AAClC,cAAc,mBAAmB,CAAC;AAClC,cAAc,sBAAsB,CAAC;AACrC,cAAc,kBAAkB,CAAC"}

package/dest/index.js

@@ -1,8 +0,0 @@
-export * from './acvm/index.js';
-export * from './avm/index.js';
-export * from './client/index.js';
-export * from './common/index.js';
-export * from './public/index.js';
-export * from './providers/index.js';
-export * from './stats/index.js';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxpQkFBaUIsQ0FBQztBQUNoQyxjQUFjLGdCQUFnQixDQUFDO0FBQy9CLGNBQWMsbUJBQW1CLENBQUM7QUFDbEMsY0FBYyxtQkFBbUIsQ0FBQztBQUNsQyxjQUFjLG1CQUFtQixDQUFDO0FBQ2xDLGNBQWMsc0JBQXNCLENBQUM7QUFDckMsY0FBYyxrQkFBa0IsQ0FBQyJ9

package/dest/providers/simulation_provider.d.ts

@@ -1,9 +0,0 @@
-import { type NoirCompiledCircuit } from '@aztec/types/noir';
-import { type WitnessMap } from '@noir-lang/types';
-/**
- * Low level simulation interface
- */
-export interface SimulationProvider {
-    simulateCircuit(input: WitnessMap, compiledCircuit: NoirCompiledCircuit): Promise<WitnessMap>;
-}
-//# sourceMappingURL=simulation_provider.d.ts.map

package/dest/providers/simulation_provider.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"simulation_provider.d.ts","sourceRoot":"","sources":["../../src/providers/simulation_provider.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AAE7D,OAAO,EAAE,KAAK,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAEnD;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC,eAAe,CAAC,KAAK,EAAE,UAAU,EAAE,eAAe,EAAE,mBAAmB,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;CAC/F"}

package/dest/providers/simulation_provider.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2ltdWxhdGlvbl9wcm92aWRlci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9wcm92aWRlcnMvc2ltdWxhdGlvbl9wcm92aWRlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIn0=

package/src/common/packed_values_cache.ts

@@ -1,55 +0,0 @@
-import { PackedValues } from '@aztec/circuit-types';
-import { Fr } from '@aztec/circuits.js';
-
-/**
- * A cache for packed values (arguments, returns) during transaction execution.
- */
-export class PackedValuesCache {
-  private cache: Map<bigint, Fr[]>;
-
-  constructor(initialArguments: PackedValues[] = []) {
-    this.cache = new Map();
-    for (const initialArg of initialArguments) {
-      this.cache.set(initialArg.hash.toBigInt(), initialArg.values);
-    }
-  }
-
-  /**
-   * Creates a new packed values cache.
-   * @param initialArguments - The initial arguments to add to the cache.
-   * @returns The new packed values cache.
-   */
-  public static create(initialArguments: PackedValues[] = []) {
-    return new PackedValuesCache(initialArguments);
-  }
-
-  /**
-   * Unpacks packed values.
-   * @param hash - The hash of the packed values.
-   * @returns The unpacked values.
-   */
-  public unpack(hash: Fr): Fr[] {
-    if (hash.equals(Fr.ZERO)) {
-      return [];
-    }
-    const packedValues = this.cache.get(hash.value);
-    if (!packedValues) {
-      throw new Error(`Packed values for hash ${hash.toString()} not found in cache`);
-    }
-    return packedValues;
-  }
-
-  /**
-   * Packs values.
-   * @param values - The values to pack.
-   * @returns The hash of the packed values.
-   */
-  public pack(values: Fr[]) {
-    if (values.length === 0) {
-      return Fr.ZERO;
-    }
-    const packedValues = PackedValues.fromValues(values);
-    this.cache.set(packedValues.hash.value, packedValues.values);
-    return packedValues.hash;
-  }
-}