@aztec/simulator 0.33.0 → 0.35.0

package/src/public/transitional_adaptors.ts

@@ -0,0 +1,249 @@
+// 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,
+  Gas,
+  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 { type AvmMachineState } from '../avm/avm_machine_state.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 { PackedValuesCache, 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,
+    globalVariables.gasFees.feePerL1Gas,
+    globalVariables.gasFees.feePerL2Gas,
+    globalVariables.gasFees.feePerDaGas,
+    /*contractCallDepth=*/ Fr.zero(),
+    header,
+    globalVariables,
+    current.callContext.isStaticCall,
+    current.callContext.isDelegateCall,
+    current.args,
+    current.callContext.gasSettings,
+    current.callContext.transactionFee,
+    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,
+    gasLeft: Gas.from(avmContext.machineState.gasLeft),
+    isDelegateCall: avmContext.environment.isDelegateCall,
+    isStaticCall: avmContext.environment.isStaticCall,
+    sideEffectCounter: sideEffectCounter,
+    gasSettings: avmContext.environment.gasSettings,
+    transactionFee: avmContext.environment.transactionFee,
+  });
+  const functionData = new FunctionData(avmContext.environment.temporaryFunctionSelector, /*isPrivate=*/ false);
+  const execution: PublicExecution = {
+    contractAddress: avmContext.environment.address,
+    callContext,
+    args: calldata,
+    functionData,
+  };
+  const packedArgs = PackedValuesCache.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,
+  endMachineState: AvmMachineState,
+): 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,
+    gasLeft: endMachineState.gasLeft,
+  };
+}
+
+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/src/public/utils.ts

@@ -0,0 +1,31 @@
+import { type Tx } from '@aztec/circuit-types';
+import { CallRequest } from '@aztec/circuits.js';
+
+/**
+ * Looks at the side effects of a transaction and returns the highest counter
+ * @param tx - A transaction
+ * @returns The highest side effect counter in the transaction so far
+ */
+export function lastSideEffectCounter(tx: Tx): number {
+  const data = tx.data.forPublic!;
+  const sideEffectCounters = [
+    ...data.endNonRevertibleData.newNoteHashes,
+    ...data.endNonRevertibleData.newNullifiers,
+    ...data.endNonRevertibleData.publicCallStack,
+    ...data.end.newNoteHashes,
+    ...data.end.newNullifiers,
+    ...data.end.publicCallStack,
+  ];
+
+  let max = 0;
+  for (const sideEffect of sideEffectCounters) {
+    if (sideEffect instanceof CallRequest) {
+      // look at both start and end counters because for enqueued public calls start > 0 while end === 0
+      max = Math.max(max, sideEffect.startSideEffectCounter.toNumber(), sideEffect.endSideEffectCounter.toNumber());
+    } else {
+      max = Math.max(max, sideEffect.counter.toNumber());
+    }
+  }
+
+  return max;
+}

package/src/simulator/acvm_native.ts

@@ -1,4 +1,6 @@
 import { randomBytes } from '@aztec/foundation/crypto';
+import { createDebugLogger } from '@aztec/foundation/log';
+import { Timer } from '@aztec/foundation/timer';
 import { type NoirCompiledCircuit } from '@aztec/types/noir';
 
 import { type WitnessMap } from '@noir-lang/types';
@@ -7,6 +9,26 @@ import fs from 'fs/promises';
 
 import { type SimulationProvider } from './simulation_provider.js';
 
+const logger = createDebugLogger('aztec:acvm-native');
+
+export enum ACVM_RESULT {
+  SUCCESS,
+  FAILURE,
+}
+
+export type ACVMSuccess = {
+  status: ACVM_RESULT.SUCCESS;
+  duration: number;
+  witness: Map<number, string>;
+};
+
+export type ACVMFailure = {
+  status: ACVM_RESULT.FAILURE;
+  reason: string;
+};
+
+export type ACVMResult = ACVMSuccess | ACVMFailure;
+
 /**
  * Parses a TOML format witness map string into a Map structure
  * @param outputString - The witness map in TOML format
@@ -29,7 +51,8 @@ function parseIntoWitnessMap(outputString: string) {
  * @param inputWitness - The circuit's input witness
  * @param bytecode - The circuit bytecode
  * @param workingDirectory - A directory to use for temporary files by the ACVM
- * @param pathToAcvm - The path to the ACVm binary
+ * @param pathToAcvm - The path to the ACVM binary
+ * @param outputFilename - If specified, the output will be stored as a file, encoded using Bincode
  * @returns The completed partial witness outputted from the circuit
  */
 export async function executeNativeCircuit(
@@ -37,7 +60,8 @@ export async function executeNativeCircuit(
   bytecode: Buffer,
   workingDirectory: string,
   pathToAcvm: string,
-) {
+  outputFilename?: string,
+): Promise<ACVMResult> {
   const bytecodeFilename = 'bytecode';
   const witnessFilename = 'input_witness.toml';
 
@@ -47,55 +71,69 @@ export async function executeNativeCircuit(
     witnessMap = witnessMap.concat(`${key} = '${value}'\n`);
   });
 
-  // In case the directory is still around from some time previously, remove it
-  await fs.rm(workingDirectory, { recursive: true, force: true });
-  // Create the new working directory
-  await fs.mkdir(workingDirectory, { recursive: true });
-  // Write the bytecode and input witness to the working directory
-  await fs.writeFile(`${workingDirectory}/${bytecodeFilename}`, bytecode);
-  await fs.writeFile(`${workingDirectory}/${witnessFilename}`, witnessMap);
-
-  // Execute the ACVM using the given args
-  const args = [
-    `execute`,
-    `--working-directory`,
-    `${workingDirectory}`,
-    `--bytecode`,
-    `${bytecodeFilename}`,
-    `--input-witness`,
-    `${witnessFilename}`,
-    `--print`,
-  ];
-  const processPromise = new Promise<string>((resolve, reject) => {
-    let outputWitness = Buffer.alloc(0);
-    let errorBuffer = Buffer.alloc(0);
-    const acvm = proc.spawn(pathToAcvm, args);
-    acvm.stdout.on('data', data => {
-      outputWitness = Buffer.concat([outputWitness, data]);
-    });
-    acvm.stderr.on('data', data => {
-      errorBuffer = Buffer.concat([errorBuffer, data]);
-    });
-    acvm.on('close', code => {
-      if (code === 0) {
-        resolve(outputWitness.toString('utf-8'));
-      } else {
-        reject(errorBuffer.toString('utf-8'));
-      }
-    });
-  });
+  try {
+    // Check that the directory exists
+    await fs.access(workingDirectory);
+  } catch (error) {
+    return { status: ACVM_RESULT.FAILURE, reason: `Working directory ${workingDirectory} does not exist` };
+  }
 
   try {
+    // Write the bytecode and input witness to the working directory
+    await fs.writeFile(`${workingDirectory}/${bytecodeFilename}`, bytecode);
+    await fs.writeFile(`${workingDirectory}/${witnessFilename}`, witnessMap);
+
+    // Execute the ACVM using the given args
+    const args = [
+      `execute`,
+      `--working-directory`,
+      `${workingDirectory}`,
+      `--bytecode`,
+      `${bytecodeFilename}`,
+      `--input-witness`,
+      `${witnessFilename}`,
+      '--print',
+      '--output-witness',
+      'output-witness',
+    ];
+
+    logger.debug(`Calling ACVM with ${args.join(' ')}`);
+
+    const processPromise = new Promise<string>((resolve, reject) => {
+      let outputWitness = Buffer.alloc(0);
+      let errorBuffer = Buffer.alloc(0);
+      const acvm = proc.spawn(pathToAcvm, args);
+      acvm.stdout.on('data', data => {
+        outputWitness = Buffer.concat([outputWitness, data]);
+      });
+      acvm.stderr.on('data', data => {
+        errorBuffer = Buffer.concat([errorBuffer, data]);
+      });
+      acvm.on('close', code => {
+        if (code === 0) {
+          resolve(outputWitness.toString('utf-8'));
+        } else {
+          logger.error(`From ACVM: ${errorBuffer.toString('utf-8')}`);
+          reject(errorBuffer.toString('utf-8'));
+        }
+      });
+    });
+
+    const duration = new Timer();
     const output = await processPromise;
-    return parseIntoWitnessMap(output);
-  } finally {
-    // Clean up the working directory before we leave
-    await fs.rm(workingDirectory, { recursive: true, force: true });
+    if (outputFilename) {
+      const outputWitnessFileName = `${workingDirectory}/output-witness.gz`;
+      await fs.copyFile(outputWitnessFileName, outputFilename);
+    }
+    const witness = parseIntoWitnessMap(output);
+    return { status: ACVM_RESULT.SUCCESS, witness, duration: duration.ms() };
+  } catch (error) {
+    return { status: ACVM_RESULT.FAILURE, reason: `${error}` };
   }
 }
 
 export class NativeACVMSimulator implements SimulationProvider {
-  constructor(private workingDirectory: string, private pathToAcvm: string) {}
+  constructor(private workingDirectory: string, private pathToAcvm: string, private witnessFilename?: string) {}
   async simulateCircuit(input: WitnessMap, compiledCircuit: NoirCompiledCircuit): Promise<WitnessMap> {
     // Execute the circuit on those initial witness values
 
@@ -103,10 +141,19 @@ export class NativeACVMSimulator implements SimulationProvider {
     const decodedBytecode = Buffer.from(compiledCircuit.bytecode, 'base64');
 
     // Provide a unique working directory so we don't get clashes with parallel executions
-    const directory = `${this.workingDirectory}/${randomBytes(32).toString('hex')}`;
+    const directory = `${this.workingDirectory}/${randomBytes(8).toString('hex')}`;
+
+    await fs.mkdir(directory, { recursive: true });
+
     // Execute the circuit
-    const _witnessMap = await executeNativeCircuit(input, decodedBytecode, directory, this.pathToAcvm);
+    const result = await executeNativeCircuit(input, decodedBytecode, directory, this.pathToAcvm, this.witnessFilename);
+
+    await fs.rm(directory, { force: true, recursive: true });
+
+    if (result.status == ACVM_RESULT.FAILURE) {
+      throw new Error(`Failed to generate witness: ${result.reason}`);
+    }
 
-    return _witnessMap;
+    return result.witness;
   }
 }

package/src/simulator/acvm_wasm.ts

@@ -1,3 +1,4 @@
+import { foreignCallHandler } from '@aztec/noir-protocol-circuits-types';
 import { type NoirCompiledCircuit } from '@aztec/types/noir';
 
 import {
@@ -26,9 +27,12 @@ export class WASMSimulator implements SimulationProvider {
     const decodedBytecode = Buffer.from(compiledCircuit.bytecode, 'base64');
     //
     // Execute the circuit
-    const _witnessMap = await executeCircuitWithBlackBoxSolver(await getSolver(), decodedBytecode, input, () => {
-      throw Error('unexpected oracle during execution');
-    });
+    const _witnessMap = await executeCircuitWithBlackBoxSolver(
+      await getSolver(),
+      decodedBytecode,
+      input,
+      foreignCallHandler, // handle calls to debug_log
+    );
 
     return _witnessMap;
   }

package/dest/avm/temporary_executor_migration.d.ts

@@ -1,27 +0,0 @@
-/// <reference types="node" resolution-mode="require"/>
-import { type GlobalVariables } from '@aztec/circuits.js';
-import { type PublicExecution, type PublicExecutionResult } from '../public/execution.js';
-import { AvmExecutionEnvironment } from './avm_execution_environment.js';
-import { type AvmContractCallResults } from './avm_message_call_result.js';
-import { type JournalData } from './journal/journal.js';
-/** Temporary Method
- *
- * Convert a PublicExecution(Environment) object to an AvmExecutionEnvironment
- *
- * @param current
- * @param globalVariables
- * @returns
- */
-export declare function temporaryCreateAvmExecutionEnvironment(current: PublicExecution, globalVariables: GlobalVariables): AvmExecutionEnvironment;
-/** Temporary Method
- *
- * Convert the result of an AVM contract call to a PublicExecutionResult for the public kernel
- *
- * @param execution
- * @param newWorldState
- * @param result
- * @returns
- */
-export declare function temporaryConvertAvmResults(execution: PublicExecution, newWorldState: JournalData, result: AvmContractCallResults): PublicExecutionResult;
-export declare function isAvmBytecode(bytecode: Buffer): boolean;
-//# sourceMappingURL=temporary_executor_migration.d.ts.map

package/dest/avm/temporary_executor_migration.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"temporary_executor_migration.d.ts","sourceRoot":"","sources":["../../src/avm/temporary_executor_migration.ts"],"names":[],"mappings":";AAEA,OAAO,EAGL,KAAK,eAAe,EAKrB,MAAM,oBAAoB,CAAC;AAI5B,OAAO,EAAE,KAAK,eAAe,EAAE,KAAK,qBAAqB,EAAE,MAAM,wBAAwB,CAAC;AAC1F,OAAO,EAAE,uBAAuB,EAAE,MAAM,gCAAgC,CAAC;AACzE,OAAO,EAAE,KAAK,sBAAsB,EAAE,MAAM,8BAA8B,CAAC;AAC3E,OAAO,EAAE,KAAK,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAGxD;;;;;;;GAOG;AACH,wBAAgB,sCAAsC,CACpD,OAAO,EAAE,eAAe,EACxB,eAAe,EAAE,eAAe,GAC/B,uBAAuB,CAkBzB;AAED;;;;;;;;GAQG;AACH,wBAAgB,0BAA0B,CACxC,SAAS,EAAE,eAAe,EAC1B,aAAa,EAAE,WAAW,EAC1B,MAAM,EAAE,sBAAsB,GAC7B,qBAAqB,CA4DvB;AAED,wBAAgB,aAAa,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CASvD"}

package/dest/avm/temporary_executor_migration.js

@@ -1,94 +0,0 @@
-// All code in this file needs to die once the public executor is phased out.
-import { UnencryptedFunctionL2Logs } from '@aztec/circuit-types';
-import { ContractStorageRead, ContractStorageUpdateRequest, L2ToL1Message, SideEffect, SideEffectLinkedToNoteHash, } from '@aztec/circuits.js';
-import { Fr } from '@aztec/foundation/fields';
-import { createSimulationError } from '../common/errors.js';
-import { AvmExecutionEnvironment } from './avm_execution_environment.js';
-import { Mov } from './opcodes/memory.js';
-/** Temporary Method
- *
- * Convert a PublicExecution(Environment) object to an AvmExecutionEnvironment
- *
- * @param current
- * @param globalVariables
- * @returns
- */
-export function temporaryCreateAvmExecutionEnvironment(current, globalVariables) {
-    // Function selector is included temporarily until noir codegens public contract bytecode in a single blob
-    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(), globalVariables, current.callContext.isStaticCall, current.callContext.isDelegateCall, current.args, current.functionData.selector);
-}
-/** Temporary Method
- *
- * Convert the result of an AVM contract call to a PublicExecutionResult for the public kernel
- *
- * @param execution
- * @param newWorldState
- * @param result
- * @returns
- */
-export function temporaryConvertAvmResults(execution, newWorldState, result) {
-    const newNoteHashes = newWorldState.newNoteHashes.map(noteHash => new SideEffect(noteHash, Fr.zero()));
-    const contractStorageReads = [];
-    const reduceStorageReadRequests = (contractAddress, storageReads) => {
-        return storageReads.forEach((innerArray, key) => {
-            innerArray.forEach(value => {
-                contractStorageReads.push(new ContractStorageRead(new Fr(key), new Fr(value), 0));
-            });
-        });
-    };
-    newWorldState.storageReads.forEach((storageMap, address) => reduceStorageReadRequests(address, storageMap));
-    const contractStorageUpdateRequests = [];
-    const reduceStorageUpdateRequests = (contractAddress, storageUpdateRequests) => {
-        return storageUpdateRequests.forEach((innerArray, key) => {
-            innerArray.forEach(value => {
-                contractStorageUpdateRequests.push(new ContractStorageUpdateRequest(new Fr(key), new Fr(value), 0));
-            });
-        });
-    };
-    newWorldState.storageWrites.forEach((storageMap, address) => reduceStorageUpdateRequests(address, storageMap));
-    const returnValues = result.output;
-    // TODO(follow up in pr tree): NOT SUPPORTED YET, make sure hashing and log resolution is done correctly
-    // Disabled.
-    const nestedExecutions = [];
-    const nullifierReadRequests = [];
-    const nullifierNonExistentReadRequests = [];
-    const newNullifiers = 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
-    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 isAvmBytecode(bytecode) {
-    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);
-}
-//# sourceMappingURL=data:application/json;base64,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

package/dest/common/packed_args_cache.d.ts

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

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

@@ -1 +0,0 @@
-{"version":3,"file":"packed_args_cache.d.ts","sourceRoot":"","sources":["../../src/common/packed_args_cache.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AACvD,OAAO,EAAE,EAAE,EAAE,MAAM,oBAAoB,CAAC;AAExC;;GAEG;AACH,qBAAa,eAAe;IAC1B,OAAO,CAAC,KAAK,CAAoB;gBAErB,gBAAgB,GAAE,eAAe,EAAO;IAOpD;;;;OAIG;WACW,MAAM,CAAC,gBAAgB,GAAE,eAAe,EAAO;IAI7D;;;;OAIG;IACI,MAAM,CAAC,IAAI,EAAE,EAAE,GAAG,EAAE,EAAE;IAW7B;;;;OAIG;IACI,IAAI,CAAC,IAAI,EAAE,EAAE,EAAE;CAQvB"}