@aztec/simulator 0.41.0 → 0.42.0

package/src/client/unconstrained_execution.ts

@@ -1,5 +1,9 @@
-import { type FunctionData } from '@aztec/circuits.js';
-import { type DecodedReturn, type FunctionArtifact, decodeReturnValues } from '@aztec/foundation/abi';
+import {
+  type DecodedReturn,
+  type FunctionArtifact,
+  type FunctionSelector,
+  decodeReturnValues,
+} from '@aztec/foundation/abi';
 import { type AztecAddress } from '@aztec/foundation/aztec-address';
 import { type Fr } from '@aztec/foundation/fields';
 import { createDebugLogger } from '@aztec/foundation/log';
@@ -7,7 +11,6 @@ import { createDebugLogger } from '@aztec/foundation/log';
 import { witnessMapToFields } from '../acvm/deserialize.js';
 import { Oracle, acvm, extractCallStack, toACVMWitness } from '../acvm/index.js';
 import { ExecutionError } from '../common/errors.js';
-import { AcirSimulator } from './simulator.js';
 import { type ViewDataOracle } from './view_data_oracle.js';
 
 // docs:start:execute_unconstrained_function
@@ -18,21 +21,15 @@ export async function executeUnconstrainedFunction(
   oracle: ViewDataOracle,
   artifact: FunctionArtifact,
   contractAddress: AztecAddress,
-  functionData: FunctionData,
+  functionSelector: FunctionSelector,
   args: Fr[],
   log = createDebugLogger('aztec:simulator:unconstrained_execution'),
 ): Promise<DecodedReturn> {
-  const functionSelector = functionData.selector;
   log.verbose(`Executing unconstrained function ${contractAddress}:${functionSelector}(${artifact.name})`);
 
   const acir = artifact.bytecode;
   const initialWitness = toACVMWitness(0, args);
-  const acirExecutionResult = await acvm(
-    await AcirSimulator.getSolver(),
-    acir,
-    initialWitness,
-    new Oracle(oracle),
-  ).catch((err: Error) => {
+  const acirExecutionResult = await acvm(acir, initialWitness, new Oracle(oracle)).catch((err: Error) => {
     throw new ExecutionError(
       err.message,
       {
@@ -45,6 +42,6 @@ export async function executeUnconstrainedFunction(
   });
 
   const returnWitness = witnessMapToFields(acirExecutionResult.returnWitness);
-  return decodeReturnValues(artifact, returnWitness);
+  return decodeReturnValues(artifact.returnTypes, returnWitness);
 }
 // docs:end:execute_unconstrained_function

package/src/client/view_data_oracle.ts

@@ -34,6 +34,14 @@ export class ViewDataOracle extends TypedOracle {
     super();
   }
 
+  public override getBlockNumber(): Promise<number> {
+    return this.aztecNode.getBlockNumber();
+  }
+
+  public override getContractAddress(): Promise<AztecAddress> {
+    return Promise.resolve(this.contractAddress);
+  }
+
   /**
    * Retrieve keys associated with a specific master public key and app address.
    * @param pkMHash - The master public key hash.

package/src/index.ts

@@ -1,7 +1,9 @@
 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 './simulator/index.js';
+export * from './providers/index.js';
 export * from './mocks/index.js';
 export * from './stats/index.js';
+export * from './utils.js';

package/src/mocks/fixtures.ts

@@ -1,18 +1,17 @@
 import { type FunctionCall, type SimulationError, UnencryptedFunctionL2Logs } from '@aztec/circuit-types';
 import {
   ARGS_LENGTH,
+  AvmExecutionHints,
   type AztecAddress,
   CallContext,
-  CallRequest,
+  type ContractStorageRead,
   type ContractStorageUpdateRequest,
   Fr,
-  FunctionData,
   Gas,
-  MAX_PUBLIC_CALL_STACK_LENGTH_PER_TX,
-  type PrivateKernelTailCircuitPublicInputs,
   type PublicCallRequest,
 } from '@aztec/circuits.js';
 import { makeAztecAddress, makeSelector } from '@aztec/circuits.js/testing';
+import { FunctionType } from '@aztec/foundation/abi';
 import { padArrayEnd } from '@aztec/foundation/collection';
 
 import { type PublicExecution, type PublicExecutionResult } from '../public/execution.js';
@@ -21,6 +20,7 @@ export class PublicExecutionResultBuilder {
   private _execution: PublicExecution;
   private _nestedExecutions: PublicExecutionResult[] = [];
   private _contractStorageUpdateRequests: ContractStorageUpdateRequest[] = [];
+  private _contractStorageReads: ContractStorageRead[] = [];
   private _returnValues: Fr[] = [];
   private _reverted = false;
   private _revertReason: SimulationError | undefined = undefined;
@@ -34,17 +34,25 @@ export class PublicExecutionResultBuilder {
     returnValues = [new Fr(1n)],
     nestedExecutions = [],
     contractStorageUpdateRequests = [],
+    contractStorageReads = [],
+    revertReason = undefined,
   }: {
     request: PublicCallRequest;
     returnValues?: Fr[];
     nestedExecutions?: PublicExecutionResult[];
     contractStorageUpdateRequests?: ContractStorageUpdateRequest[];
+    contractStorageReads?: ContractStorageRead[];
+    revertReason?: SimulationError;
   }): PublicExecutionResultBuilder {
     const builder = new PublicExecutionResultBuilder(request);
 
     builder.withNestedExecutions(...nestedExecutions);
     builder.withContractStorageUpdateRequest(...contractStorageUpdateRequests);
+    builder.withContractStorageRead(...contractStorageReads);
     builder.withReturnValues(...returnValues);
+    if (revertReason) {
+      builder.withReverted(revertReason);
+    }
 
     return builder;
   }
@@ -55,6 +63,7 @@ export class PublicExecutionResultBuilder {
     returnValues = [new Fr(1n)],
     nestedExecutions = [],
     contractStorageUpdateRequests = [],
+    contractStorageReads = [],
     revertReason,
   }: {
     from: AztecAddress;
@@ -62,17 +71,19 @@ export class PublicExecutionResultBuilder {
     returnValues?: Fr[];
     nestedExecutions?: PublicExecutionResult[];
     contractStorageUpdateRequests?: ContractStorageUpdateRequest[];
+    contractStorageReads?: ContractStorageRead[];
     revertReason?: SimulationError;
   }) {
     const builder = new PublicExecutionResultBuilder({
-      callContext: new CallContext(from, tx.to, tx.functionData.selector, false, false, 0),
+      callContext: new CallContext(from, tx.to, tx.selector, false, false, 0),
       contractAddress: tx.to,
-      functionData: tx.functionData,
+      functionSelector: tx.selector,
       args: tx.args,
     });
 
     builder.withNestedExecutions(...nestedExecutions);
     builder.withContractStorageUpdateRequest(...contractStorageUpdateRequests);
+    builder.withContractStorageRead(...contractStorageReads);
     builder.withReturnValues(...returnValues);
     if (revertReason) {
       builder.withReverted(revertReason);
@@ -91,6 +102,11 @@ export class PublicExecutionResultBuilder {
     return this;
   }
 
+  withContractStorageRead(...reads: ContractStorageRead[]): PublicExecutionResultBuilder {
+    this._contractStorageReads.push(...reads);
+    return this;
+  }
+
   withReturnValues(...values: Fr[]): PublicExecutionResultBuilder {
     this._returnValues.push(...values);
     return this;
@@ -106,8 +122,10 @@ export class PublicExecutionResultBuilder {
     return {
       execution: this._execution,
       nestedExecutions: this._nestedExecutions,
+      noteHashReadRequests: [],
       nullifierReadRequests: [],
       nullifierNonExistentReadRequests: [],
+      l1ToL2MsgReadRequests: [],
       contractStorageUpdateRequests: this._contractStorageUpdateRequests,
       returnValues: padArrayEnd(this._returnValues, Fr.ZERO, 4), // TODO(#5450) Need to use the proper return values here
       newNoteHashes: [],
@@ -124,39 +142,19 @@ export class PublicExecutionResultBuilder {
       startGasLeft: Gas.test(),
       endGasLeft: Gas.test(),
       transactionFee: Fr.ZERO,
+      calldata: [],
+      avmHints: AvmExecutionHints.empty(),
       ...overrides,
     };
   }
 }
 
 export const makeFunctionCall = (
+  name = 'function',
   to = makeAztecAddress(30),
   selector = makeSelector(5),
+  type = FunctionType.PUBLIC,
   args = new Array(ARGS_LENGTH).fill(Fr.ZERO),
   isStatic = false,
-) => ({ to, functionData: new FunctionData(selector, /*isPrivate=*/ false), args, isStatic });
-
-export function addKernelPublicCallStack(
-  kernelOutput: PrivateKernelTailCircuitPublicInputs,
-  calls: {
-    setupCalls: PublicCallRequest[];
-    appLogicCalls: PublicCallRequest[];
-    teardownCall: PublicCallRequest;
-  },
-) {
-  // the first two calls are non-revertible
-  // the first is for setup, the second is for teardown
-  kernelOutput.forPublic!.endNonRevertibleData.publicCallStack = padArrayEnd(
-    // this is a stack, so the first item is the last call
-    // and callRequests is in the order of the calls
-    [calls.teardownCall.toCallRequest(), ...calls.setupCalls.map(c => c.toCallRequest())],
-    CallRequest.empty(),
-    MAX_PUBLIC_CALL_STACK_LENGTH_PER_TX,
-  );
-
-  kernelOutput.forPublic!.end.publicCallStack = padArrayEnd(
-    calls.appLogicCalls.map(c => c.toCallRequest()),
-    CallRequest.empty(),
-    MAX_PUBLIC_CALL_STACK_LENGTH_PER_TX,
-  );
-}
+  returnTypes = [],
+) => ({ name, to, selector, type, args, isStatic, returnTypes });

package/src/{simulator → providers}/acvm_native.ts

@@ -1,4 +1,4 @@
-import { randomBytes } from '@aztec/foundation/crypto';
+import { runInDirectory } from '@aztec/foundation/fs';
 import { createDebugLogger } from '@aztec/foundation/log';
 import { Timer } from '@aztec/foundation/timer';
 import { type NoirCompiledCircuit } from '@aztec/types/noir';
@@ -137,23 +137,25 @@ export class NativeACVMSimulator implements SimulationProvider {
   async simulateCircuit(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');
-
-    // Provide a unique working directory so we don't get clashes with parallel executions
-    const directory = `${this.workingDirectory}/${randomBytes(8).toString('hex')}`;
-
-    await fs.mkdir(directory, { recursive: true });
-
-    // Execute the circuit
-    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 result.witness;
+    const operation = async (directory: string) => {
+      // 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 result = await executeNativeCircuit(
+        input,
+        decodedBytecode,
+        directory,
+        this.pathToAcvm,
+        this.witnessFilename,
+      );
+
+      if (result.status == ACVM_RESULT.FAILURE) {
+        throw new Error(`Failed to generate witness: ${result.reason}`);
+      }
+
+      return result.witness;
+    };
+
+    return await runInDirectory(this.workingDirectory, operation);
   }
 }

package/src/{simulator → providers}/acvm_wasm.ts

@@ -1,24 +1,11 @@
 import { foreignCallHandler } from '@aztec/noir-protocol-circuits-types';
 import { type NoirCompiledCircuit } from '@aztec/types/noir';
 
-import {
-  type WasmBlackBoxFunctionSolver,
-  createBlackBoxSolver,
-  executeCircuitWithBlackBoxSolver,
-} from '@noir-lang/acvm_js';
+import { executeCircuit } from '@noir-lang/acvm_js';
 import { type WitnessMap } from '@noir-lang/types';
 
 import { type SimulationProvider } from './simulation_provider.js';
 
-let solver: Promise<WasmBlackBoxFunctionSolver>;
-
-const getSolver = (): Promise<WasmBlackBoxFunctionSolver> => {
-  if (!solver) {
-    solver = createBlackBoxSolver();
-  }
-  return solver;
-};
-
 export class WASMSimulator implements SimulationProvider {
   async simulateCircuit(input: WitnessMap, compiledCircuit: NoirCompiledCircuit): Promise<WitnessMap> {
     // Execute the circuit on those initial witness values
@@ -27,8 +14,7 @@ export class WASMSimulator implements SimulationProvider {
     const decodedBytecode = Buffer.from(compiledCircuit.bytecode, 'base64');
     //
     // Execute the circuit
-    const _witnessMap = await executeCircuitWithBlackBoxSolver(
-      await getSolver(),
+    const _witnessMap = await executeCircuit(
       decodedBytecode,
       input,
       foreignCallHandler, // handle calls to debug_log