@aztec/simulator 0.32.1 → 0.34.0

package/src/client/view_data_oracle.ts

@@ -257,7 +257,7 @@ export class ViewDataOracle extends TypedOracle {
       const storageSlot = new Fr(startStorageSlot.value + i);
       const value = await this.aztecNode.getPublicStorageAt(this.contractAddress, storageSlot);
 
-      this.log(`Oracle storage read: slot=${storageSlot.toString()} value=${value}`);
+      this.log.debug(`Oracle storage read: slot=${storageSlot.toString()} value=${value}`);
       values.push(value);
     }
     return values;

package/src/public/executor.ts

@@ -12,10 +12,6 @@ import { AvmMachineState } from '../avm/avm_machine_state.js';
 import { AvmSimulator } from '../avm/avm_simulator.js';
 import { HostStorage } from '../avm/journal/host_storage.js';
 import { AvmPersistableStateManager } from '../avm/journal/index.js';
-import {
-  temporaryConvertAvmResults,
-  temporaryCreateAvmExecutionEnvironment,
-} from '../avm/temporary_executor_migration.js';
 import { AcirSimulator } from '../client/simulator.js';
 import { ExecutionError, createSimulationError } from '../common/errors.js';
 import { SideEffectCounter } from '../common/index.js';
@@ -23,35 +19,92 @@ import { PackedArgsCache } from '../common/packed_args_cache.js';
 import { type CommitmentsDB, type PublicContractsDB, type PublicStateDB } from './db.js';
 import { type PublicExecution, type PublicExecutionResult, checkValidStaticCall } from './execution.js';
 import { PublicExecutionContext } from './public_execution_context.js';
+import { convertAvmResults, createAvmExecutionEnvironment, isAvmBytecode } from './transitional_adaptors.js';
 
 /**
  * Execute a public function and return the execution result.
  */
 export async function executePublicFunction(
+  context: PublicExecutionContext,
+  nested: boolean,
+): Promise<PublicExecutionResult> {
+  const bytecode = await context.contractsDb.getBytecode(
+    context.execution.contractAddress,
+    context.execution.functionData.selector,
+  );
+  if (!bytecode) {
+    throw new Error(
+      `Bytecode not found for ${context.execution.contractAddress}:${context.execution.functionData.selector}`,
+    );
+  }
+
+  if (isAvmBytecode(bytecode)) {
+    return await executePublicFunctionAvm(context);
+  } else {
+    return await executePublicFunctionAcvm(context, bytecode, nested);
+  }
+}
+
+async function executePublicFunctionAvm(executionContext: PublicExecutionContext): Promise<PublicExecutionResult> {
+  const address = executionContext.execution.contractAddress;
+  const selector = executionContext.execution.functionData.selector;
+  const log = createDebugLogger('aztec:simulator:public_execution');
+  log.verbose(`[AVM] Executing public external function ${address.toString()}:${selector}.`);
+
+  // Temporary code to construct the AVM context
+  // These data structures will permeate across the simulator when the public executor is phased out
+  const hostStorage = new HostStorage(
+    executionContext.stateDb,
+    executionContext.contractsDb,
+    executionContext.commitmentsDb,
+  );
+  const worldStateJournal = new AvmPersistableStateManager(hostStorage);
+
+  const executionEnv = createAvmExecutionEnvironment(
+    executionContext.execution,
+    executionContext.header,
+    executionContext.globalVariables,
+  );
+
+  // TODO(@spalladino) Load initial gas from the public execution request
+  const machineState = new AvmMachineState(1e7, 1e7, 1e7);
+
+  const context = new AvmContext(worldStateJournal, executionEnv, machineState);
+  const simulator = new AvmSimulator(context);
+
+  const result = await simulator.execute();
+  const newWorldState = context.persistableState.flush();
+
+  log.verbose(`[AVM] ${address.toString()}:${selector} returned, reverted: ${result.reverted}.`);
+
+  // TODO(@spalladino) Read gas left from machineState and return it
+  return await convertAvmResults(executionContext, newWorldState, result);
+}
+
+async function executePublicFunctionAcvm(
   context: PublicExecutionContext,
   acir: Buffer,
   nested: boolean,
-  log = createDebugLogger('aztec:simulator:public_execution'),
 ): Promise<PublicExecutionResult> {
   const execution = context.execution;
   const { contractAddress, functionData } = execution;
   const selector = functionData.selector;
-  log(`Executing public external function ${contractAddress.toString()}:${selector}`);
+  const log = createDebugLogger('aztec:simulator:public_execution');
+  log.verbose(`[ACVM] Executing public external function ${contractAddress.toString()}:${selector}.`);
 
   const initialWitness = context.getInitialWitness();
   const acvmCallback = new Oracle(context);
-  const { partialWitness, reverted, revertReason } = await acvm(
-    await AcirSimulator.getSolver(),
-    acir,
-    initialWitness,
-    acvmCallback,
-  )
-    .then(result => ({
-      partialWitness: result.partialWitness,
-      reverted: false,
-      revertReason: undefined,
-    }))
-    .catch((err: Error) => {
+
+  const { partialWitness, reverted, revertReason } = await (async () => {
+    try {
+      const result = await acvm(await AcirSimulator.getSolver(), acir, initialWitness, acvmCallback);
+      return {
+        partialWitness: result.partialWitness,
+        reverted: false,
+        revertReason: undefined,
+      };
+    } catch (err_) {
+      const err = err_ as Error;
       const ee = new ExecutionError(
         err.message,
         {
@@ -72,7 +125,9 @@ export async function executePublicFunction(
           revertReason: createSimulationError(ee),
         };
       }
-    });
+    }
+  })();
+
   if (reverted) {
     if (!revertReason) {
       throw new Error('Reverted but no revert reason');
@@ -122,12 +177,12 @@ export async function executePublicFunction(
 
   const { contractStorageReads, contractStorageUpdateRequests } = context.getStorageActionData();
 
-  log(
+  log.debug(
     `Contract storage reads: ${contractStorageReads
       .map(r => r.toFriendlyJSON() + ` - sec: ${r.sideEffectCounter}`)
       .join(', ')}`,
   );
-  log(
+  log.debug(
     `Contract storage update requests: ${contractStorageUpdateRequests
       .map(r => r.toFriendlyJSON() + ` - sec: ${r.sideEffectCounter}`)
       .join(', ')}`,
@@ -166,6 +221,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.
@@ -177,12 +233,6 @@ export class PublicExecutor {
     globalVariables: GlobalVariables,
     sideEffectCounter: number = 0,
   ): Promise<PublicExecutionResult> {
-    const selector = execution.functionData.selector;
-    const acir = await this.contractsDb.getBytecode(execution.contractAddress, selector);
-    if (!acir) {
-      throw new Error(`Bytecode not found for ${execution.contractAddress}:${selector}`);
-    }
-
     // Functions can request to pack arguments before calling other functions.
     // We use this cache to hold the packed arguments.
     const packedArgs = PackedArgsCache.create([]);
@@ -198,7 +248,7 @@ export class PublicExecutor {
       this.commitmentsDb,
     );
 
-    const executionResult = await executePublicFunction(context, acir, false /** nested */);
+    const executionResult = await executePublicFunction(context, /*nested=*/ false);
 
     if (executionResult.execution.callContext.isStaticCall) {
       checkValidStaticCall(
@@ -213,34 +263,6 @@ export class PublicExecutor {
     return executionResult;
   }
 
-  /**
-   * 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(
-    execution: PublicExecution,
-    globalVariables: GlobalVariables,
-    _sideEffectCounter = 0,
-  ): Promise<PublicExecutionResult> {
-    // Temporary code to construct the AVM context
-    // These data structures will permeate across the simulator when the public executor is phased out
-    const hostStorage = new HostStorage(this.stateDb, this.contractsDb, this.commitmentsDb);
-    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 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);
-  }
-
   /**
    * These functions are currently housed in the temporary executor as it relies on access to
    * oracles like the contractsDB and this is the least intrusive way to achieve this.
@@ -260,6 +282,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 +292,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.debug(`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.verbose(`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.debug(`stdout: ${stdout}`);
+        }
       });
+
+      // Catch stderr.
+      bbBinary.stderr.on('data', (data: Buffer) => {
+        stderr += data.toString();
+      });
+      bbBinary.stderr.on('end', () => {
+        if (stderr.length > 0) {
+          this.log.warn(`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 +356,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.debug(`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/src/public/public_execution_context.ts

@@ -36,13 +36,13 @@ export class PublicExecutionContext extends TypedOracle {
      * Data for this execution.
      */
     public readonly execution: PublicExecution,
-    private readonly header: Header,
-    private readonly globalVariables: GlobalVariables,
+    public readonly header: Header,
+    public readonly globalVariables: GlobalVariables,
     private readonly packedArgsCache: PackedArgsCache,
     private readonly sideEffectCounter: SideEffectCounter,
-    private readonly stateDb: PublicStateDB,
-    private readonly contractsDb: PublicContractsDB,
-    private readonly commitmentsDb: CommitmentsDB,
+    public readonly stateDb: PublicStateDB,
+    public readonly contractsDb: PublicContractsDB,
+    public readonly commitmentsDb: CommitmentsDB,
     private log = createDebugLogger('aztec:simulator:public_execution_context'),
   ) {
     super();
@@ -120,7 +120,7 @@ export class PublicExecutionContext extends TypedOracle {
   public emitUnencryptedLog(log: UnencryptedL2Log) {
     // TODO(https://github.com/AztecProtocol/aztec-packages/issues/885)
     this.unencryptedLogs.push(log);
-    this.log(`Emitted unencrypted log: "${log.toHumanReadable()}"`);
+    this.log.verbose(`Emitted unencrypted log: "${log.toHumanReadable()}"`);
   }
 
   /**
@@ -144,7 +144,7 @@ export class PublicExecutionContext extends TypedOracle {
       const storageSlot = new Fr(startStorageSlot.value + BigInt(i));
       const sideEffectCounter = this.sideEffectCounter.count();
       const value = await this.storageActions.read(storageSlot, sideEffectCounter);
-      this.log(`Oracle storage read: slot=${storageSlot.toString()} value=${value.toString()}`);
+      this.log.debug(`Oracle storage read: slot=${storageSlot.toString()} value=${value.toString()}`);
       values.push(value);
     }
     return values;
@@ -163,7 +163,7 @@ export class PublicExecutionContext extends TypedOracle {
       const sideEffectCounter = this.sideEffectCounter.count();
       this.storageActions.write(storageSlot, newValue, sideEffectCounter);
       await this.stateDb.storageWrite(this.execution.callContext.storageContractAddress, storageSlot, newValue);
-      this.log(`Oracle storage write: slot=${storageSlot.toString()} value=${newValue.toString()}`);
+      this.log.debug(`Oracle storage write: slot=${storageSlot.toString()} value=${newValue.toString()}`);
       newValues.push(newValue);
     }
     return newValues;
@@ -187,17 +187,12 @@ export class PublicExecutionContext extends TypedOracle {
     isStaticCall = isStaticCall || this.execution.callContext.isStaticCall;
 
     const args = this.packedArgsCache.unpack(argsHash);
-    this.log(`Public function call: addr=${targetContractAddress} selector=${functionSelector} args=${args.join(',')}`);
+    this.log.verbose(
+      `Public function call: addr=${targetContractAddress} selector=${functionSelector} args=${args.join(',')}`,
+    );
 
     const portalAddress = (await this.contractsDb.getPortalContractAddress(targetContractAddress)) ?? EthAddress.ZERO;
-
-    const acir = await this.contractsDb.getBytecode(targetContractAddress, functionSelector);
-    if (!acir) {
-      throw new Error(`Bytecode not found for ${targetContractAddress}:${functionSelector}`);
-    }
-
-    const functionData = new FunctionData(functionSelector, false);
-
+    const functionData = new FunctionData(functionSelector, /*isPrivate=*/ false);
     const callContext = CallContext.from({
       msgSender: isDelegateCall ? this.execution.callContext.msgSender : this.execution.contractAddress,
       storageContractAddress: isDelegateCall ? this.execution.contractAddress : targetContractAddress,
@@ -227,7 +222,7 @@ export class PublicExecutionContext extends TypedOracle {
       this.log,
     );
 
-    const childExecutionResult = await executePublicFunction(context, acir, true /** nested */);
+    const childExecutionResult = await executePublicFunction(context, /*nested=*/ true);
 
     if (isStaticCall) {
       checkValidStaticCall(
@@ -240,7 +235,7 @@ export class PublicExecutionContext extends TypedOracle {
     }
 
     this.nestedExecutions.push(childExecutionResult);
-    this.log(`Returning from nested call: ret=${childExecutionResult.returnValues.join(', ')}`);
+    this.log.debug(`Returning from nested call: ret=${childExecutionResult.returnValues.join(', ')}`);
 
     return childExecutionResult.returnValues;
   }

package/src/public/transitional_adaptors.ts

@@ -0,0 +1,240 @@
+// All code in this file needs to die once the public executor is phased out in favor of the AVM.
+import { UnencryptedFunctionL2Logs, UnencryptedL2Log } from '@aztec/circuit-types';
+import {
+  CallContext,
+  ContractStorageRead,
+  ContractStorageUpdateRequest,
+  FunctionData,
+  type GlobalVariables,
+  type Header,
+  L2ToL1Message,
+  ReadRequest,
+  SideEffect,
+  SideEffectLinkedToNoteHash,
+} from '@aztec/circuits.js';
+import { Fr } from '@aztec/foundation/fields';
+
+import { type AvmContext } from '../avm/avm_context.js';
+import { AvmExecutionEnvironment } from '../avm/avm_execution_environment.js';
+import { AvmContractCallResults } from '../avm/avm_message_call_result.js';
+import { type JournalData } from '../avm/journal/journal.js';
+import { Mov } from '../avm/opcodes/memory.js';
+import { createSimulationError } from '../common/errors.js';
+import { PackedArgsCache, SideEffectCounter } from '../index.js';
+import { type PublicExecution, type PublicExecutionResult } from './execution.js';
+import { PublicExecutionContext } from './public_execution_context.js';
+
+/**
+ * Convert a PublicExecution(Environment) object to an AvmExecutionEnvironment
+ *
+ * @param current
+ * @param globalVariables
+ * @returns
+ */
+export function createAvmExecutionEnvironment(
+  current: PublicExecution,
+  header: Header,
+  globalVariables: GlobalVariables,
+): AvmExecutionEnvironment {
+  return new AvmExecutionEnvironment(
+    current.contractAddress,
+    current.callContext.storageContractAddress,
+    current.callContext.msgSender, // TODO: origin is not available
+    current.callContext.msgSender,
+    current.callContext.portalContractAddress,
+    /*feePerL1Gas=*/ Fr.zero(),
+    /*feePerL2Gas=*/ Fr.zero(),
+    /*feePerDaGas=*/ Fr.zero(),
+    /*contractCallDepth=*/ Fr.zero(),
+    header,
+    globalVariables,
+    current.callContext.isStaticCall,
+    current.callContext.isDelegateCall,
+    current.args,
+    current.functionData.selector,
+  );
+}
+
+export function createPublicExecutionContext(avmContext: AvmContext, calldata: Fr[]): PublicExecutionContext {
+  const sideEffectCounter = avmContext.persistableState.trace.accessCounter;
+  const callContext = CallContext.from({
+    msgSender: avmContext.environment.sender,
+    storageContractAddress: avmContext.environment.storageAddress,
+    portalContractAddress: avmContext.environment.portal,
+    functionSelector: avmContext.environment.temporaryFunctionSelector,
+    isDelegateCall: avmContext.environment.isDelegateCall,
+    isStaticCall: avmContext.environment.isStaticCall,
+    sideEffectCounter: sideEffectCounter,
+  });
+  const functionData = new FunctionData(avmContext.environment.temporaryFunctionSelector, /*isPrivate=*/ false);
+  const execution: PublicExecution = {
+    contractAddress: avmContext.environment.address,
+    callContext,
+    args: calldata,
+    functionData,
+  };
+  const packedArgs = PackedArgsCache.create([]);
+
+  const context = new PublicExecutionContext(
+    execution,
+    avmContext.environment.header,
+    avmContext.environment.globals,
+    packedArgs,
+    new SideEffectCounter(sideEffectCounter),
+    avmContext.persistableState.hostStorage.publicStateDb,
+    avmContext.persistableState.hostStorage.contractsDb,
+    avmContext.persistableState.hostStorage.commitmentsDb,
+  );
+
+  return context;
+}
+
+/**
+ * Convert the result of an AVM contract call to a PublicExecutionResult for the public kernel
+ *
+ * @param execution
+ * @param newWorldState
+ * @param result
+ * @returns
+ */
+export async function convertAvmResults(
+  executionContext: PublicExecutionContext,
+  newWorldState: JournalData,
+  result: AvmContractCallResults,
+): Promise<PublicExecutionResult> {
+  const execution = executionContext.execution;
+
+  const contractStorageReads: ContractStorageRead[] = newWorldState.storageReads.map(
+    read => new ContractStorageRead(read.slot, read.value, read.counter.toNumber()),
+  );
+  const contractStorageUpdateRequests: ContractStorageUpdateRequest[] = newWorldState.storageWrites.map(
+    write => new ContractStorageUpdateRequest(write.slot, write.value, write.counter.toNumber()),
+  );
+  // We need to write the storage updates to the DB, because that's what the ACVM expects.
+  // Assumes the updates are in the right order.
+  for (const write of newWorldState.storageWrites) {
+    await executionContext.stateDb.storageWrite(write.storageAddress, write.slot, write.value);
+  }
+
+  const newNoteHashes = newWorldState.newNoteHashes.map(
+    noteHash => new SideEffect(noteHash.noteHash, noteHash.counter),
+  );
+  const nullifierReadRequests: ReadRequest[] = newWorldState.nullifierChecks
+    .filter(nullifierCheck => nullifierCheck.exists)
+    .map(nullifierCheck => new ReadRequest(nullifierCheck.nullifier, nullifierCheck.counter.toNumber()));
+  const nullifierNonExistentReadRequests: ReadRequest[] = newWorldState.nullifierChecks
+    .filter(nullifierCheck => !nullifierCheck.exists)
+    .map(nullifierCheck => new ReadRequest(nullifierCheck.nullifier, nullifierCheck.counter.toNumber()));
+  const newNullifiers: SideEffectLinkedToNoteHash[] = newWorldState.newNullifiers.map(
+    tracedNullifier =>
+      new SideEffectLinkedToNoteHash(
+        /*value=*/ tracedNullifier.nullifier,
+        /*noteHash=*/ Fr.ZERO, // NEEDED?
+        tracedNullifier.counter,
+      ),
+  );
+  const unencryptedLogs: UnencryptedFunctionL2Logs = new UnencryptedFunctionL2Logs(
+    newWorldState.newLogs.map(log => new UnencryptedL2Log(log.contractAddress, log.selector, log.data)),
+  );
+  const newL2ToL1Messages = newWorldState.newL1Messages.map(m => new L2ToL1Message(m.recipient, m.content));
+
+  const returnValues = result.output;
+
+  // TODO: Support nested executions.
+  const nestedExecutions: PublicExecutionResult[] = [];
+  // TODO keep track of side effect counters
+  const startSideEffectCounter = Fr.ZERO;
+  const endSideEffectCounter = Fr.ZERO;
+
+  return {
+    execution,
+    nullifierReadRequests,
+    nullifierNonExistentReadRequests,
+    newNoteHashes,
+    newL2ToL1Messages,
+    startSideEffectCounter,
+    endSideEffectCounter,
+    newNullifiers,
+    contractStorageReads,
+    contractStorageUpdateRequests,
+    returnValues,
+    nestedExecutions,
+    unencryptedLogs,
+    reverted: result.reverted,
+    revertReason: result.revertReason ? createSimulationError(result.revertReason) : undefined,
+  };
+}
+
+export function convertPublicExecutionResult(res: PublicExecutionResult): AvmContractCallResults {
+  return new AvmContractCallResults(res.reverted, res.returnValues, res.revertReason);
+}
+
+export function updateAvmContextFromPublicExecutionResult(ctx: AvmContext, result: PublicExecutionResult): void {
+  // We have to push these manually and not use the trace* functions
+  // so that we respect the side effect counters.
+  for (const readRequest of result.contractStorageReads) {
+    ctx.persistableState.trace.publicStorageReads.push({
+      storageAddress: ctx.environment.storageAddress,
+      exists: true, // FIXME
+      slot: readRequest.storageSlot,
+      value: readRequest.currentValue,
+      counter: new Fr(readRequest.sideEffectCounter ?? Fr.ZERO),
+    });
+  }
+
+  for (const updateRequest of result.contractStorageUpdateRequests) {
+    ctx.persistableState.trace.publicStorageWrites.push({
+      storageAddress: ctx.environment.storageAddress,
+      slot: updateRequest.storageSlot,
+      value: updateRequest.newValue,
+      counter: new Fr(updateRequest.sideEffectCounter ?? Fr.ZERO),
+    });
+
+    // We need to manually populate the cache.
+    ctx.persistableState.publicStorage.write(
+      ctx.environment.storageAddress,
+      updateRequest.storageSlot,
+      updateRequest.newValue,
+    );
+  }
+
+  for (const nullifier of result.newNullifiers) {
+    ctx.persistableState.trace.newNullifiers.push({
+      storageAddress: ctx.environment.storageAddress,
+      nullifier: nullifier.value,
+      counter: nullifier.counter,
+    });
+  }
+
+  for (const noteHash of result.newNoteHashes) {
+    ctx.persistableState.trace.newNoteHashes.push({
+      storageAddress: ctx.environment.storageAddress,
+      noteHash: noteHash.value,
+      counter: noteHash.counter,
+    });
+  }
+
+  for (const message of result.newL2ToL1Messages) {
+    ctx.persistableState.newL1Messages.push(message);
+  }
+
+  for (const log of result.unencryptedLogs.logs) {
+    ctx.persistableState.newLogs.push(new UnencryptedL2Log(log.contractAddress, log.selector, log.data));
+  }
+}
+
+const AVM_MAGIC_SUFFIX = Buffer.from([
+  Mov.opcode, // opcode
+  0x00, // indirect
+  ...Buffer.from('000018ca', 'hex'), // srcOffset
+  ...Buffer.from('000018ca', 'hex'), // dstOffset
+]);
+
+export function markBytecodeAsAvm(bytecode: Buffer): Buffer {
+  return Buffer.concat([bytecode, AVM_MAGIC_SUFFIX]);
+}
+
+export function isAvmBytecode(bytecode: Buffer): boolean {
+  const magicSize = AVM_MAGIC_SUFFIX.length;
+  return bytecode.subarray(-magicSize).equals(AVM_MAGIC_SUFFIX);
+}

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"}