@aztec/simulator 0.32.1 → 0.33.0

package/src/avm/opcodes/instruction_impl.ts

@@ -1,19 +1,34 @@
+import { type AvmContext } from '../avm_context.js';
+import { type MemoryValue } from '../avm_memory_types.js';
 import { OperandType } from '../serialization/instruction_serialization.js';
 import { Instruction } from './instruction.js';
 
+/** Wire format that informs deserialization for instructions with two operands. */
+export const TwoOperandWireFormat = [
+  OperandType.UINT8,
+  OperandType.UINT8,
+  OperandType.UINT8,
+  OperandType.UINT32,
+  OperandType.UINT32,
+];
+
+/** Wire format that informs deserialization for instructions with three operands. */
+export const ThreeOperandWireFormat = [
+  OperandType.UINT8,
+  OperandType.UINT8,
+  OperandType.UINT8,
+  OperandType.UINT32,
+  OperandType.UINT32,
+  OperandType.UINT32,
+];
+
 /**
  * Covers (de)serialization for an instruction with:
  * indirect, inTag, and two UINT32s.
  */
 export abstract class TwoOperandInstruction extends Instruction {
   // Informs (de)serialization. See Instruction.deserialize.
-  static readonly wireFormat: OperandType[] = [
-    OperandType.UINT8,
-    OperandType.UINT8,
-    OperandType.UINT8,
-    OperandType.UINT32,
-    OperandType.UINT32,
-  ];
+  static readonly wireFormat: OperandType[] = TwoOperandWireFormat;
 
   constructor(
     protected indirect: number,
@@ -31,14 +46,7 @@ export abstract class TwoOperandInstruction extends Instruction {
  */
 export abstract class ThreeOperandInstruction extends Instruction {
   // Informs (de)serialization. See Instruction.deserialize.
-  static readonly wireFormat: OperandType[] = [
-    OperandType.UINT8,
-    OperandType.UINT8,
-    OperandType.UINT8,
-    OperandType.UINT32,
-    OperandType.UINT32,
-    OperandType.UINT32,
-  ];
+  static readonly wireFormat: OperandType[] = ThreeOperandWireFormat;
 
   constructor(
     protected indirect: number,
@@ -50,3 +58,25 @@ export abstract class ThreeOperandInstruction extends Instruction {
     super();
   }
 }
+
+export abstract class GetterInstruction extends Instruction {
+  // Informs (de)serialization. See Instruction.deserialize.
+  static readonly wireFormat: OperandType[] = [OperandType.UINT8, OperandType.UINT8, OperandType.UINT32];
+
+  constructor(protected indirect: number, protected dstOffset: number) {
+    super();
+  }
+
+  public async execute(context: AvmContext): Promise<void> {
+    const memoryOperations = { writes: 1, indirect: this.indirect };
+    const memory = context.machineState.memory.track(this.type);
+    context.machineState.consumeGas(this.gasCost(memoryOperations));
+
+    memory.set(this.dstOffset, this.getValue(context));
+
+    memory.assert(memoryOperations);
+    context.machineState.incrementPc();
+  }
+
+  protected abstract getValue(env: AvmContext): MemoryValue;
+}

package/src/avm/opcodes/memory.ts

@@ -1,6 +1,6 @@
 import type { AvmContext } from '../avm_context.js';
-import { type GasCost, GasCostConstants, getGasCostMultiplierFromTypeTag, makeGasCost } from '../avm_gas_cost.js';
-import { Field, TaggedMemory, TypeTag } from '../avm_memory_types.js';
+import { getBaseGasCost, getMemoryGasCost, mulGas, sumGas } from '../avm_gas.js';
+import { Field, type MemoryOperations, TaggedMemory, TypeTag } from '../avm_memory_types.js';
 import { InstructionExecutionError } from '../errors.js';
 import { BufferCursor } from '../serialization/buffer_cursor.js';
 import { Opcode, OperandType, deserialize, serialize } from '../serialization/instruction_serialization.js';
@@ -69,21 +69,22 @@ export class Set extends Instruction {
     return new this(...args);
   }
 
-  async execute(context: AvmContext): Promise<void> {
+  public async execute(context: AvmContext): Promise<void> {
+    const memoryOperations = { writes: 1, indirect: this.indirect };
+    const memory = context.machineState.memory.track(this.type);
+    context.machineState.consumeGas(this.gasCost(memoryOperations));
+
     // Per the YP, the tag cannot be a field.
     if ([TypeTag.FIELD, TypeTag.UNINITIALIZED, TypeTag.INVALID].includes(this.inTag)) {
       throw new InstructionExecutionError(`Invalid tag ${TypeTag[this.inTag]} for SET.`);
     }
 
     const res = TaggedMemory.integralFromTag(this.value, this.inTag);
-    context.machineState.memory.set(this.dstOffset, res);
+    memory.set(this.dstOffset, res);
 
+    memory.assert(memoryOperations);
     context.machineState.incrementPc();
   }
-
-  protected gasCost(): GasCost {
-    return makeGasCost({ l2Gas: GasCostConstants.SET_COST_PER_BYTE * getGasCostMultiplierFromTypeTag(this.inTag) });
-  }
 }
 
 export class CMov extends Instruction {
@@ -109,14 +110,19 @@ export class CMov extends Instruction {
     super();
   }
 
-  async execute(context: AvmContext): Promise<void> {
-    const a = context.machineState.memory.get(this.aOffset);
-    const b = context.machineState.memory.get(this.bOffset);
-    const cond = context.machineState.memory.get(this.condOffset);
+  public async execute(context: AvmContext): Promise<void> {
+    const memoryOperations = { reads: 3, writes: 1, indirect: this.indirect };
+    const memory = context.machineState.memory.track(this.type);
+    context.machineState.consumeGas(this.gasCost(memoryOperations));
+
+    const a = memory.get(this.aOffset);
+    const b = memory.get(this.bOffset);
+    const cond = memory.get(this.condOffset);
 
     // TODO: reconsider toBigInt() here
-    context.machineState.memory.set(this.dstOffset, cond.toBigInt() > 0 ? a : b);
+    memory.set(this.dstOffset, cond.toBigInt() > 0 ? a : b);
 
+    memory.assert(memoryOperations);
     context.machineState.incrementPc();
   }
 }
@@ -129,15 +135,20 @@ export class Cast extends TwoOperandInstruction {
     super(indirect, dstTag, aOffset, dstOffset);
   }
 
-  async execute(context: AvmContext): Promise<void> {
-    const a = context.machineState.memory.get(this.aOffset);
+  public async execute(context: AvmContext): Promise<void> {
+    const memoryOperations = { reads: 1, writes: 1, indirect: this.indirect };
+    const memory = context.machineState.memory.track(this.type);
+    context.machineState.consumeGas(this.gasCost(memoryOperations));
+
+    const a = memory.get(this.aOffset);
 
     // TODO: consider not using toBigInt()
     const casted =
       this.inTag == TypeTag.FIELD ? new Field(a.toBigInt()) : TaggedMemory.integralFromTag(a.toBigInt(), this.inTag);
 
-    context.machineState.memory.set(this.dstOffset, casted);
+    memory.set(this.dstOffset, casted);
 
+    memory.assert(memoryOperations);
     context.machineState.incrementPc();
   }
 }
@@ -157,16 +168,18 @@ export class Mov extends Instruction {
     super();
   }
 
-  async execute(context: AvmContext): Promise<void> {
-    const [srcOffset, dstOffset] = Addressing.fromWire(this.indirect).resolve(
-      [this.srcOffset, this.dstOffset],
-      context.machineState.memory,
-    );
+  public async execute(context: AvmContext): Promise<void> {
+    const memoryOperations = { reads: 1, writes: 1, indirect: this.indirect };
+    const memory = context.machineState.memory.track(this.type);
+    context.machineState.consumeGas(this.gasCost(memoryOperations));
+
+    const [srcOffset, dstOffset] = Addressing.fromWire(this.indirect).resolve([this.srcOffset, this.dstOffset], memory);
 
-    const a = context.machineState.memory.get(srcOffset);
+    const a = memory.get(srcOffset);
 
-    context.machineState.memory.set(dstOffset, a);
+    memory.set(dstOffset, a);
 
+    memory.assert(memoryOperations);
     context.machineState.incrementPc();
   }
 }
@@ -187,19 +200,26 @@ export class CalldataCopy extends Instruction {
     super();
   }
 
-  async execute(context: AvmContext): Promise<void> {
-    const [dstOffset] = Addressing.fromWire(this.indirect).resolve([this.dstOffset], context.machineState.memory);
+  public async execute(context: AvmContext): Promise<void> {
+    const memoryOperations = { writes: this.copySize, indirect: this.indirect };
+    const memory = context.machineState.memory.track(this.type);
+    context.machineState.consumeGas(this.gasCost(memoryOperations));
+
+    const [dstOffset] = Addressing.fromWire(this.indirect).resolve([this.dstOffset], memory);
 
     const transformedData = context.environment.calldata
       .slice(this.cdOffset, this.cdOffset + this.copySize)
       .map(f => new Field(f));
 
-    context.machineState.memory.setSlice(dstOffset, transformedData);
+    memory.setSlice(dstOffset, transformedData);
 
+    memory.assert(memoryOperations);
     context.machineState.incrementPc();
   }
 
-  protected gasCost(): GasCost {
-    return makeGasCost({ l2Gas: GasCostConstants.CALLDATACOPY_COST_PER_BYTE * this.copySize });
+  protected gasCost(memoryOps: Partial<MemoryOperations & { indirect: number }> = {}) {
+    const baseGasCost = mulGas(getBaseGasCost(this.opcode), this.copySize);
+    const memoryGasCost = getMemoryGasCost(memoryOps);
+    return sumGas(baseGasCost, memoryGasCost);
   }
 }

package/src/avm/opcodes/storage.ts

@@ -1,7 +1,8 @@
 import { Fr } from '@aztec/foundation/fields';
 
 import type { AvmContext } from '../avm_context.js';
-import { Field } from '../avm_memory_types.js';
+import { type Gas, getBaseGasCost, getMemoryGasCost, mulGas, sumGas } from '../avm_gas.js';
+import { Field, type MemoryOperations } from '../avm_memory_types.js';
 import { InstructionExecutionError } from '../errors.js';
 import { Opcode, OperandType } from '../serialization/instruction_serialization.js';
 import { Addressing } from './addressing_mode.js';
@@ -25,6 +26,12 @@ abstract class BaseStorageInstruction extends Instruction {
   ) {
     super();
   }
+
+  protected gasCost(memoryOps: Partial<MemoryOperations & { indirect: number }>): Gas {
+    const baseGasCost = mulGas(getBaseGasCost(this.opcode), this.size);
+    const memoryGasCost = getMemoryGasCost(memoryOps);
+    return sumGas(baseGasCost, memoryGasCost);
+  }
 }
 
 export class SStore extends BaseStorageInstruction {
@@ -35,24 +42,26 @@ export class SStore extends BaseStorageInstruction {
     super(indirect, srcOffset, srcSize, slotOffset);
   }
 
-  async execute(context: AvmContext): Promise<void> {
+  public async execute(context: AvmContext): Promise<void> {
     if (context.environment.isStaticCall) {
       throw new StaticCallStorageAlterError();
     }
 
-    const [srcOffset, slotOffset] = Addressing.fromWire(this.indirect).resolve(
-      [this.aOffset, this.bOffset],
-      context.machineState.memory,
-    );
+    const memoryOperations = { reads: this.size + 1, indirect: this.indirect };
+    const memory = context.machineState.memory.track(this.type);
+    context.machineState.consumeGas(this.gasCost(memoryOperations));
 
-    const slot = context.machineState.memory.get(slotOffset).toFr();
-    const data = context.machineState.memory.getSlice(srcOffset, this.size).map(field => field.toFr());
+    const [srcOffset, slotOffset] = Addressing.fromWire(this.indirect).resolve([this.aOffset, this.bOffset], memory);
+
+    const slot = memory.get(slotOffset).toFr();
+    const data = memory.getSlice(srcOffset, this.size).map(field => field.toFr());
 
     for (const [index, value] of Object.entries(data)) {
       const adjustedSlot = slot.add(new Fr(BigInt(index)));
       context.persistableState.writeStorage(context.environment.storageAddress, adjustedSlot, value);
     }
 
+    memory.assert(memoryOperations);
     context.machineState.incrementPc();
   }
 }
@@ -65,13 +74,17 @@ export class SLoad extends BaseStorageInstruction {
     super(indirect, slotOffset, size, dstOffset);
   }
 
-  async execute(context: AvmContext): Promise<void> {
+  public async execute(context: AvmContext): Promise<void> {
+    const memoryOperations = { writes: this.size, reads: 1, indirect: this.indirect };
+    const memory = context.machineState.memory.track(this.type);
+    context.machineState.consumeGas(this.gasCost(memoryOperations));
+
     const [aOffset, size, bOffset] = Addressing.fromWire(this.indirect).resolve(
       [this.aOffset, this.size, this.bOffset],
-      context.machineState.memory,
+      memory,
     );
 
-    const slot = context.machineState.memory.get(aOffset);
+    const slot = memory.get(aOffset);
 
     // Write each read value from storage into memory
     for (let i = 0; i < size; i++) {
@@ -80,10 +93,11 @@ export class SLoad extends BaseStorageInstruction {
         new Fr(slot.toBigInt() + BigInt(i)),
       );
 
-      context.machineState.memory.set(bOffset + i, new Field(data));
+      memory.set(bOffset + i, new Field(data));
     }
 
     context.machineState.incrementPc();
+    memory.assert(memoryOperations);
   }
 }
 

package/src/avm/serialization/bytecode_serialization.ts

@@ -1,3 +1,4 @@
+import { DAGasLeft, L1GasLeft, L2GasLeft } from '../opcodes/context_getters.js';
 import { Keccak, Pedersen, Poseidon2, Sha256 } from '../opcodes/hashing.js';
 import {
   Add,
@@ -18,6 +19,7 @@ import {
   FeePerL1Gas,
   FeePerL2Gas,
   FieldDiv,
+  GetContractInstance,
   InternalCall,
   InternalReturn,
   Jump,
@@ -101,9 +103,9 @@ const INSTRUCTION_SET = () =>
 
     // Machine State
     // Machine State - Gas
-    //[L1gasleft.opcode, L1gasleft],
-    //[L2gasleft.opcode, L2gasleft],
-    //[Dagasleft.opcode, Dagasleft],
+    [L1GasLeft.opcode, L1GasLeft],
+    [L2GasLeft.opcode, L2GasLeft],
+    [DAGasLeft.opcode, DAGasLeft],
     // Machine State - Internal Control Flow
     [Jump.opcode, Jump],
     [JumpI.opcode, JumpI],
@@ -126,6 +128,7 @@ const INSTRUCTION_SET = () =>
     // Accrued Substate
     [EmitUnencryptedLog.opcode, EmitUnencryptedLog],
     [SendL2ToL1Message.opcode, SendL2ToL1Message],
+    [GetContractInstance.opcode, GetContractInstance],
 
     // Control Flow - Contract Calls
     [Call.opcode, Call],

package/src/avm/serialization/instruction_serialization.ts

@@ -64,6 +64,7 @@ export enum Opcode {
   EMITNULLIFIER,
   L1TOL2MSGEXISTS,
   HEADERMEMBER,
+  GETCONTRACTINSTANCE,
   EMITUNENCRYPTEDLOG,
   SENDL2TOL1MSG,
   // External calls

package/src/avm/temporary_executor_migration.ts

@@ -7,7 +7,7 @@ import {
   L2ToL1Message,
   type ReadRequest,
   SideEffect,
-  type SideEffectLinkedToNoteHash,
+  SideEffectLinkedToNoteHash,
 } from '@aztec/circuits.js';
 import { Fr } from '@aztec/foundation/fields';
 
@@ -16,6 +16,7 @@ import { type PublicExecution, type PublicExecutionResult } from '../public/exec
 import { AvmExecutionEnvironment } from './avm_execution_environment.js';
 import { type AvmContractCallResults } from './avm_message_call_result.js';
 import { type JournalData } from './journal/journal.js';
+import { Mov } from './opcodes/memory.js';
 
 /** Temporary Method
  *
@@ -95,7 +96,9 @@ export function temporaryConvertAvmResults(
   const nestedExecutions: PublicExecutionResult[] = [];
   const nullifierReadRequests: ReadRequest[] = [];
   const nullifierNonExistentReadRequests: ReadRequest[] = [];
-  const newNullifiers: SideEffectLinkedToNoteHash[] = [];
+  const newNullifiers: SideEffectLinkedToNoteHash[] = newWorldState.newNullifiers.map(
+    (nullifier, i) => new SideEffectLinkedToNoteHash(nullifier.toField(), Fr.zero(), new Fr(i + 1)),
+  );
   const unencryptedLogs = UnencryptedFunctionL2Logs.empty();
   const newL2ToL1Messages = newWorldState.newL1Messages.map(() => L2ToL1Message.empty());
   // TODO keep track of side effect counters
@@ -120,3 +123,14 @@ export function temporaryConvertAvmResults(
     revertReason: result.revertReason ? createSimulationError(result.revertReason) : undefined,
   };
 }
+
+export function isAvmBytecode(bytecode: Buffer): boolean {
+  const magicBuf = Buffer.from([
+    Mov.opcode, // opcode
+    0x00, // indirect
+    ...Buffer.from('000018ca', 'hex'), // srcOffset
+    ...Buffer.from('000018ca', 'hex'), // dstOffset
+  ]);
+  const magicSize = magicBuf.length;
+  return bytecode.subarray(-magicSize).equals(magicBuf);
+}

package/src/client/private_execution.ts

@@ -1,5 +1,5 @@
 import { type FunctionData, PrivateCallStackItem, PrivateCircuitPublicInputs } from '@aztec/circuits.js';
-import { type FunctionArtifactWithDebugMetadata, decodeReturnValues } from '@aztec/foundation/abi';
+import { type AbiType, type FunctionArtifactWithDebugMetadata, decodeReturnValues } from '@aztec/foundation/abi';
 import { type AztecAddress } from '@aztec/foundation/aztec-address';
 import { Fr } from '@aztec/foundation/fields';
 import { createDebugLogger } from '@aztec/foundation/log';
@@ -52,7 +52,13 @@ export async function executePrivateFunction(
   publicInputs.unencryptedLogPreimagesLength = new Fr(unencryptedLogs.getSerializedLength());
 
   const callStackItem = new PrivateCallStackItem(contractAddress, functionData, publicInputs);
-  const returnValues = decodeReturnValues(artifact, publicInputs.returnValues);
+
+  // Mocking the return type to be an array of 4 fields
+  // TODO: @LHerskind must be updated as we are progressing with the macros to get the information
+  const returnTypes: AbiType[] = [{ kind: 'array', length: 4, type: { kind: 'field' } }];
+  const mockArtifact = { ...artifact, returnTypes };
+  const returnValues = decodeReturnValues(mockArtifact, publicInputs.returnValues);
+
   const noteHashReadRequestPartialWitnesses = context.getNoteHashReadRequestPartialWitnesses(
     publicInputs.noteHashReadRequests,
   );

package/src/public/executor.ts

@@ -13,6 +13,7 @@ import { AvmSimulator } from '../avm/avm_simulator.js';
 import { HostStorage } from '../avm/journal/host_storage.js';
 import { AvmPersistableStateManager } from '../avm/journal/index.js';
 import {
+  isAvmBytecode,
   temporaryConvertAvmResults,
   temporaryCreateAvmExecutionEnvironment,
 } from '../avm/temporary_executor_migration.js';
@@ -166,6 +167,7 @@ export class PublicExecutor {
     private readonly header: Header,
   ) {}
 
+  private readonly log = createDebugLogger('aztec:simulator:public_executor');
   /**
    * Executes a public execution request.
    * @param execution - The execution to run.
@@ -176,6 +178,30 @@ export class PublicExecutor {
     execution: PublicExecution,
     globalVariables: GlobalVariables,
     sideEffectCounter: number = 0,
+  ): Promise<PublicExecutionResult> {
+    const selector = execution.functionData.selector;
+    const bytecode = await this.contractsDb.getBytecode(execution.contractAddress, selector);
+    if (!bytecode) {
+      throw new Error(`Bytecode not found for ${execution.contractAddress}:${selector}`);
+    }
+
+    if (isAvmBytecode(bytecode)) {
+      return await this.simulateAvm(execution, globalVariables, sideEffectCounter);
+    } else {
+      return await this.simulateAcvm(execution, globalVariables, sideEffectCounter);
+    }
+  }
+
+  /**
+   * Executes a public execution request with the ACVM.
+   * @param execution - The execution to run.
+   * @param globalVariables - The global variables to use.
+   * @returns The result of the run plus all nested runs.
+   */
+  private async simulateAcvm(
+    execution: PublicExecution,
+    globalVariables: GlobalVariables,
+    sideEffectCounter: number = 0,
   ): Promise<PublicExecutionResult> {
     const selector = execution.functionData.selector;
     const acir = await this.contractsDb.getBytecode(execution.contractAddress, selector);
@@ -214,12 +240,12 @@ export class PublicExecutor {
   }
 
   /**
-   * Executes a public execution request in the avm.
+   * Executes a public execution request in the AVM.
    * @param execution - The execution to run.
    * @param globalVariables - The global variables to use.
    * @returns The result of the run plus all nested runs.
    */
-  public async simulateAvm(
+  private async simulateAvm(
     execution: PublicExecution,
     globalVariables: GlobalVariables,
     _sideEffectCounter = 0,
@@ -230,13 +256,14 @@ export class PublicExecutor {
     const worldStateJournal = new AvmPersistableStateManager(hostStorage);
     const executionEnv = temporaryCreateAvmExecutionEnvironment(execution, globalVariables);
     // TODO(@spalladino) Load initial gas from the public execution request
-    const machineState = new AvmMachineState(100_000, 100_000, 100_000);
+    const machineState = new AvmMachineState(1e10, 1e10, 1e10);
 
     const context = new AvmContext(worldStateJournal, executionEnv, machineState);
     const simulator = new AvmSimulator(context);
 
     const result = await simulator.execute();
     const newWorldState = context.persistableState.flush();
+
     // TODO(@spalladino) Read gas left from machineState and return it
     return temporaryConvertAvmResults(execution, newWorldState, result);
   }
@@ -260,6 +287,7 @@ export class PublicExecutor {
     const artifactsPath = path.resolve('target');
 
     // Create the directory if it does not exist
+    await fs.rm(artifactsPath, { recursive: true, force: true });
     await fs.mkdir(artifactsPath, { recursive: true });
 
     const calldataPath = path.join(artifactsPath, 'calldata.bin');
@@ -269,34 +297,54 @@ export class PublicExecutor {
     const { args, functionData, contractAddress } = avmExecution;
     const bytecode = await this.contractsDb.getBytecode(contractAddress, functionData.selector);
     // Write call data and bytecode to files.
-    await Promise.all([
-      fs.writeFile(
-        calldataPath,
-        args.map(c => c.toBuffer()),
-      ),
-      fs.writeFile(bytecodePath, bytecode!),
-    ]);
-
-    const bbBinary = spawn(path.join(bbPath, 'build', 'bin', 'bb'), [
-      'avm_prove',
-      '-b',
-      bytecodePath,
-      '-d',
+    await fs.writeFile(
       calldataPath,
-      '-o',
-      proofPath,
-    ]);
+      args.map(c => c.toBuffer()),
+    );
+    await fs.writeFile(bytecodePath, bytecode!);
+
+    const bbExec = path.join(bbPath, 'build', 'bin', 'bb');
+    const bbArgs = ['avm_prove', '-b', bytecodePath, '-d', calldataPath, '-o', proofPath];
+    this.log(`calling '${bbExec} ${bbArgs.join(' ')}'`);
+    const bbBinary = spawn(bbExec, bbArgs);
+
     // The binary writes the proof and the verification key to the write path.
     return new Promise((resolve, reject) => {
+      let stdout: string = '';
+      let stderr: string = '';
+
       bbBinary.on('close', () => {
-        resolve(Promise.all([fs.readFile(proofPath), fs.readFile(path.join(artifactsPath, 'vk'))]));
+        this.log(`Proof generation complete. Reading proof and vk from ${proofPath}.`);
+        return resolve(Promise.all([fs.readFile(proofPath), fs.readFile(path.join(artifactsPath, 'vk'))]));
+      });
+
+      // Catch stdout.
+      bbBinary.stdout.on('data', (data: Buffer) => {
+        stdout += data.toString();
       });
+      bbBinary.stdout.on('end', () => {
+        if (stdout.length > 0) {
+          this.log(`stdout: ${stdout}`);
+        }
+      });
+
+      // Catch stderr.
+      bbBinary.stderr.on('data', (data: Buffer) => {
+        stderr += data.toString();
+      });
+      bbBinary.stderr.on('end', () => {
+        if (stderr.length > 0) {
+          this.log(`stderr: ${stderr}`);
+        }
+      });
+
       // Catch and propagate errors from spawning
       bbBinary.on('error', err => {
         reject(err);
       });
     });
   }
+
   /**
    * Verifies an AVM proof. This function is currently only used for testing purposes, as verification
    * is not fully complete in the AVM yet.
@@ -313,9 +361,14 @@ export class PublicExecutor {
     const proofPath = path.join(artifactsPath, 'proof');
 
     // Write the verification key and the proof to files.
-    await Promise.all([fs.writeFile(vkPath, vk), fs.writeFile(proofPath, proof)]);
+    await fs.writeFile(vkPath, vk);
+    await fs.writeFile(proofPath, proof);
+
+    const bbExec = path.join(bbPath, 'build', 'bin', 'bb');
+    const bbArgs = ['avm_verify', '-p', proofPath];
+    this.log(`calling '${bbPath} ${bbArgs.join(' ')}'`);
+    const bbBinary = spawn(bbExec, bbArgs);
 
-    const bbBinary = spawn(path.join(bbPath, 'build', 'bin', 'bb'), ['avm_verify', '-p', proofPath]);
     // The binary prints to stdout 1 if the proof is valid and 0 if it is not.
     return new Promise((resolve, reject) => {
       let result = Buffer.alloc(0);

package/src/public/index.ts

@@ -1,7 +1,7 @@
 export * from './db.js';
 export {
-  PublicExecution,
-  PublicExecutionResult,
+  type PublicExecution,
+  type PublicExecutionResult,
   isPublicExecutionResult,
   collectPublicDataReads,
   collectPublicDataUpdateRequests,

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

@@ -1,19 +0,0 @@
-import { type ForeignCallInput } from '@noir-lang/acvm_js';
-import { type ACVMField } from '../acvm_types.js';
-/**
- * Convert an array of ACVMFields to a string.
- *
- * @param msg - array of ACVMFields where each represents a single ascii character
- * @returns string representation of the message
- */
-export declare function acvmFieldMessageToString(msg: ACVMField[]): string;
-/**
- * Convert an array of ACVMFields from ACVM to a formatted string.
- *
- * @param parameters - either one parameter representing a simple field or array, or two parameters when
- * It's a message without args or three parameters when it's a message with arguments.
- *
- * @returns formatted string
- */
-export declare function oracleDebugCallToFormattedStr(parameters: ForeignCallInput[]): string;
-//# sourceMappingURL=debug.d.ts.map

package/dest/acvm/oracle/debug.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"debug.d.ts","sourceRoot":"","sources":["../../../src/acvm/oracle/debug.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAE3D,OAAO,EAAE,KAAK,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAElD;;;;;GAKG;AACH,wBAAgB,wBAAwB,CAAC,GAAG,EAAE,SAAS,EAAE,GAAG,MAAM,CAajE;AAyBD;;;;;;;GAOG;AACH,wBAAgB,6BAA6B,CAAC,UAAU,EAAE,gBAAgB,EAAE,GAAG,MAAM,CAcpF"}