@aztec/simulator 0.33.0 → 0.35.0

package/src/avm/serialization/instruction_serialization.ts

@@ -75,7 +75,7 @@ export enum Opcode {
   REVERT,
   // Gadgets
   KECCAK,
-  POSEIDON,
+  POSEIDON2,
   SHA256, // temp - may be removed, but alot of contracts rely on it
   PEDERSEN, // temp - may be removed, but alot of contracts rely on it
 }

package/src/client/client_execution_context.ts

@@ -28,7 +28,7 @@ import { Fr, type Point } from '@aztec/foundation/fields';
 import { createDebugLogger } from '@aztec/foundation/log';
 
 import { type NoteData, toACVMWitness } from '../acvm/index.js';
-import { type PackedArgsCache } from '../common/packed_args_cache.js';
+import { type PackedValuesCache } from '../common/packed_values_cache.js';
 import { type DBOracle } from './db_oracle.js';
 import { type ExecutionNoteCache } from './execution_note_cache.js';
 import { type ExecutionResult, type NoteAndSlot } from './execution_result.js';
@@ -72,7 +72,7 @@ export class ClientExecutionContext extends ViewDataOracle {
     protected readonly historicalHeader: Header,
     /** List of transient auth witnesses to be used during this simulation */
     protected readonly authWitnesses: AuthWitness[],
-    private readonly packedArgsCache: PackedArgsCache,
+    private readonly packedValuesCache: PackedValuesCache,
     private readonly noteCache: ExecutionNoteCache,
     protected readonly db: DBOracle,
     private readonly curve: Grumpkin,
@@ -93,7 +93,7 @@ export class ClientExecutionContext extends ViewDataOracle {
   public getInitialWitness(abi: FunctionAbi) {
     const argumentsSize = countArgumentsSize(abi);
 
-    const args = this.packedArgsCache.unpack(this.argsHash);
+    const args = this.packedValuesCache.unpack(this.argsHash);
 
     if (args.length !== argumentsSize) {
       throw new Error('Invalid arguments size');
@@ -175,7 +175,23 @@ export class ClientExecutionContext extends ViewDataOracle {
    * @param args - Arguments to pack
    */
   public packArguments(args: Fr[]): Promise<Fr> {
-    return Promise.resolve(this.packedArgsCache.pack(args));
+    return Promise.resolve(this.packedValuesCache.pack(args));
+  }
+
+  /**
+   * Pack the given returns.
+   * @param returns - Returns to pack
+   */
+  public packReturns(returns: Fr[]): Promise<Fr> {
+    return Promise.resolve(this.packedValuesCache.pack(returns));
+  }
+
+  /**
+   * Unpack the given returns.
+   * @param returnsHash - Returns hash to unpack
+   */
+  public unpackReturns(returnsHash: Fr): Promise<Fr[]> {
+    return Promise.resolve(this.packedValuesCache.unpack(returnsHash));
   }
 
   /**
@@ -235,7 +251,7 @@ export class ClientExecutionContext extends ViewDataOracle {
       offset,
     });
 
-    this.log(
+    this.log.debug(
       `Returning ${notes.length} notes for ${this.callContext.storageContractAddress} at ${storageSlot}: ${notes
         .map(n => `${n.nonce.toString()}:[${n.note.items.map(i => i.toString()).join(',')}]`)
         .join(', ')}`,
@@ -316,7 +332,7 @@ export class ClientExecutionContext extends ViewDataOracle {
   public emitUnencryptedLog(log: UnencryptedL2Log) {
     this.unencryptedLogs.push(log);
     const text = log.toHumanReadable();
-    this.log(`Emitted unencrypted log: "${text.length > 100 ? text.slice(0, 100) + '...' : text}"`);
+    this.log.verbose(`Emitted unencrypted log: "${text.length > 100 ? text.slice(0, 100) + '...' : text}"`);
   }
 
   #checkValidStaticCall(childExecutionResult: ExecutionResult) {
@@ -349,7 +365,7 @@ export class ClientExecutionContext extends ViewDataOracle {
     isStaticCall: boolean,
     isDelegateCall: boolean,
   ) {
-    this.log(
+    this.log.debug(
       `Calling private function ${this.contractAddress}:${functionSelector} from ${this.callContext.storageContractAddress}`,
     );
 
@@ -375,7 +391,7 @@ export class ClientExecutionContext extends ViewDataOracle {
       derivedCallContext,
       this.historicalHeader,
       this.authWitnesses,
-      this.packedArgsCache,
+      this.packedValuesCache,
       this.noteCache,
       this.db,
       this.curve,
@@ -428,7 +444,7 @@ export class ClientExecutionContext extends ViewDataOracle {
       isDelegateCall,
       isStaticCall,
     );
-    const args = this.packedArgsCache.unpack(argsHash);
+    const args = this.packedValuesCache.unpack(argsHash);
     const enqueuedRequest = PublicCallRequest.from({
       args,
       callContext: derivedCallContext,
@@ -441,7 +457,7 @@ export class ClientExecutionContext extends ViewDataOracle {
     // side-effect counter, that will leak info about how many other private
     // side-effects occurred in the TX. Ultimately the private kernel should
     // just output everything in the proper order without any counters.
-    this.log(
+    this.log.verbose(
       `Enqueued call to public function (with side-effect counter #${sideEffectCounter}) ${targetContractAddress}:${functionSelector}(${targetArtifact.name})`,
     );
 
@@ -472,9 +488,12 @@ export class ClientExecutionContext extends ViewDataOracle {
       isDelegateCall ? this.contractAddress : targetContractAddress,
       portalContractAddress,
       FunctionSelector.fromNameAndParameters(targetArtifact.name, targetArtifact.parameters),
+      this.callContext.gasLeft, // TODO(palla/gas): We should deduct DA and L1 gas used for the derived context
       isDelegateCall,
       isStaticCall,
       startSideEffectCounter,
+      this.callContext.gasSettings,
+      this.callContext.transactionFee,
     );
   }
 
@@ -497,7 +516,7 @@ export class ClientExecutionContext extends ViewDataOracle {
         throw new Error(`No witness for slot ${storageSlot.toString()}`);
       }
       const value = witness.leafPreimage.value;
-      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/client/private_execution.ts

@@ -4,7 +4,7 @@ import { type AztecAddress } from '@aztec/foundation/aztec-address';
 import { Fr } from '@aztec/foundation/fields';
 import { createDebugLogger } from '@aztec/foundation/log';
 
-import { extractReturnWitness } from '../acvm/deserialize.js';
+import { witnessMapToFields } from '../acvm/deserialize.js';
 import { Oracle, acvm, extractCallStack } from '../acvm/index.js';
 import { ExecutionError } from '../common/errors.js';
 import { type ClientExecutionContext } from './client_execution_context.js';
@@ -22,11 +22,11 @@ export async function executePrivateFunction(
   log = createDebugLogger('aztec:simulator:secret_execution'),
 ): Promise<ExecutionResult> {
   const functionSelector = functionData.selector;
-  log(`Executing external function ${contractAddress}:${functionSelector}(${artifact.name})`);
+  log.verbose(`Executing external function ${contractAddress}:${functionSelector}(${artifact.name})`);
   const acir = artifact.bytecode;
   const initialWitness = context.getInitialWitness(artifact);
   const acvmCallback = new Oracle(context);
-  const { partialWitness } = await acvm(await AcirSimulator.getSolver(), acir, initialWitness, acvmCallback).catch(
+  const acirExecutionResult = await acvm(await AcirSimulator.getSolver(), acir, initialWitness, acvmCallback).catch(
     (err: Error) => {
       throw new ExecutionError(
         err.message,
@@ -39,8 +39,8 @@ export async function executePrivateFunction(
       );
     },
   );
-
-  const returnWitness = extractReturnWitness(acir, partialWitness);
+  const partialWitness = acirExecutionResult.partialWitness;
+  const returnWitness = witnessMapToFields(acirExecutionResult.returnWitness);
   const publicInputs = PrivateCircuitPublicInputs.fromFields(returnWitness);
 
   const encryptedLogs = context.getEncryptedLogs();
@@ -55,9 +55,10 @@ export async function executePrivateFunction(
 
   // 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 rawReturnValues = await context.unpackReturns(publicInputs.returnsHash);
+  const returnTypes: AbiType[] = [{ kind: 'array', length: rawReturnValues.length, type: { kind: 'field' } }];
   const mockArtifact = { ...artifact, returnTypes };
-  const returnValues = decodeReturnValues(mockArtifact, publicInputs.returnValues);
+  const returnValues = decodeReturnValues(mockArtifact, rawReturnValues);
 
   const noteHashReadRequestPartialWitnesses = context.getNoteHashReadRequestPartialWitnesses(
     publicInputs.noteHashReadRequests,
@@ -66,7 +67,7 @@ export async function executePrivateFunction(
   const nestedExecutions = context.getNestedExecutions();
   const enqueuedPublicFunctionCalls = context.getEnqueuedPublicFunctionCalls();
 
-  log(`Returning from call to ${contractAddress.toString()}:${functionSelector}`);
+  log.debug(`Returning from call to ${contractAddress.toString()}:${functionSelector}`);
 
   return {
     acir,

package/src/client/simulator.ts

@@ -16,7 +16,7 @@ import { type DebugLogger, createDebugLogger } from '@aztec/foundation/log';
 import { type WasmBlackBoxFunctionSolver, createBlackBoxSolver } from '@noir-lang/acvm_js';
 
 import { createSimulationError } from '../common/errors.js';
-import { PackedArgsCache } from '../common/packed_args_cache.js';
+import { PackedValuesCache } from '../common/packed_values_cache.js';
 import { ClientExecutionContext } from './client_execution_context.js';
 import { type DBOracle } from './db_oracle.js';
 import { ExecutionNoteCache } from './execution_note_cache.js';
@@ -89,14 +89,18 @@ export class AcirSimulator {
     // reserve the first side effect for the tx hash (inserted by the private kernel)
     const startSideEffectCounter = 1;
 
+    const transactionFee = Fr.ZERO;
     const callContext = new CallContext(
       msgSender,
       contractAddress,
       portalContractAddress,
       FunctionSelector.fromNameAndParameters(entryPointArtifact.name, entryPointArtifact.parameters),
+      request.gasSettings.getInitialAvailable(),
       false,
       false,
       startSideEffectCounter,
+      request.gasSettings,
+      transactionFee,
     );
     const context = new ClientExecutionContext(
       contractAddress,
@@ -105,7 +109,7 @@ export class AcirSimulator {
       callContext,
       header,
       request.authWitnesses,
-      PackedArgsCache.create(request.packedArguments),
+      PackedValuesCache.create(request.packedArguments),
       new ExecutionNoteCache(),
       this.db,
       curve,
@@ -194,7 +198,7 @@ export class AcirSimulator {
     const maxNoteFields = (artifact.parameters[artifact.parameters.length - 1].type as ArrayType).length;
     if (maxNoteFields < note.items.length) {
       throw new Error(
-        `The note being processed has ${note.items.length} fields, while "compute_note_hash_and_nullifier" can only handle a maximum of ${maxNoteFields} fields. Please consider increasing the allowed field size to accommodate all notes generated from the contract.`,
+        `The note being processed has ${note.items.length} fields, while "compute_note_hash_and_nullifier" can only handle a maximum of ${maxNoteFields} fields. Please reduce the number of fields in your note.`,
       );
     }
 

package/src/client/unconstrained_execution.ts

@@ -4,7 +4,7 @@ import { type AztecAddress } from '@aztec/foundation/aztec-address';
 import { type Fr } from '@aztec/foundation/fields';
 import { createDebugLogger } from '@aztec/foundation/log';
 
-import { extractReturnWitness } from '../acvm/deserialize.js';
+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';
@@ -23,11 +23,11 @@ export async function executeUnconstrainedFunction(
   log = createDebugLogger('aztec:simulator:unconstrained_execution'),
 ): Promise<DecodedReturn> {
   const functionSelector = functionData.selector;
-  log(`Executing unconstrained function ${contractAddress}:${functionSelector}`);
+  log.verbose(`Executing unconstrained function ${contractAddress}:${functionSelector}(${artifact.name})`);
 
   const acir = artifact.bytecode;
   const initialWitness = toACVMWitness(0, args);
-  const { partialWitness } = await acvm(
+  const acirExecutionResult = await acvm(
     await AcirSimulator.getSolver(),
     acir,
     initialWitness,
@@ -44,6 +44,7 @@ export async function executeUnconstrainedFunction(
     );
   });
 
-  return decodeReturnValues(artifact, extractReturnWitness(acir, partialWitness));
+  const returnWitness = witnessMapToFields(acirExecutionResult.returnWitness);
+  return decodeReturnValues(artifact, returnWitness);
 }
 // docs:end:execute_unconstrained_function

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/common/index.ts

@@ -1,3 +1,3 @@
-export * from './packed_args_cache.js';
+export * from './packed_values_cache.js';
 export * from './errors.js';
 export * from './side_effect_counter.js';

package/src/common/packed_values_cache.ts

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

package/src/index.ts

@@ -3,3 +3,4 @@ export * from './client/index.js';
 export * from './common/index.js';
 export * from './public/index.js';
 export * from './simulator/index.js';
+export * from './mocks/index.js';

package/src/mocks/fixtures.ts

@@ -0,0 +1,169 @@
+import { type FunctionCall, type SimulationError, UnencryptedFunctionL2Logs } from '@aztec/circuit-types';
+import {
+  ARGS_LENGTH,
+  type AztecAddress,
+  CallContext,
+  CallRequest,
+  type ContractStorageUpdateRequest,
+  EthAddress,
+  Fr,
+  FunctionData,
+  Gas,
+  GasSettings,
+  MAX_PUBLIC_CALL_STACK_LENGTH_PER_TX,
+  type PrivateKernelTailCircuitPublicInputs,
+  type PublicCallRequest,
+} from '@aztec/circuits.js';
+import { makeAztecAddress, makeSelector } from '@aztec/circuits.js/testing';
+import { padArrayEnd } from '@aztec/foundation/collection';
+
+import { type PublicExecution, type PublicExecutionResult } from '../public/execution.js';
+
+export class PublicExecutionResultBuilder {
+  private _execution: PublicExecution;
+  private _nestedExecutions: PublicExecutionResult[] = [];
+  private _contractStorageUpdateRequests: ContractStorageUpdateRequest[] = [];
+  private _returnValues: Fr[] = [];
+  private _reverted = false;
+  private _revertReason: SimulationError | undefined = undefined;
+
+  constructor(execution: PublicExecution) {
+    this._execution = execution;
+  }
+
+  static fromPublicCallRequest({
+    request,
+    returnValues = [new Fr(1n)],
+    nestedExecutions = [],
+    contractStorageUpdateRequests = [],
+  }: {
+    request: PublicCallRequest;
+    returnValues?: Fr[];
+    nestedExecutions?: PublicExecutionResult[];
+    contractStorageUpdateRequests?: ContractStorageUpdateRequest[];
+  }): PublicExecutionResultBuilder {
+    const builder = new PublicExecutionResultBuilder(request);
+
+    builder.withNestedExecutions(...nestedExecutions);
+    builder.withContractStorageUpdateRequest(...contractStorageUpdateRequests);
+    builder.withReturnValues(...returnValues);
+
+    return builder;
+  }
+
+  static fromFunctionCall({
+    from,
+    tx,
+    returnValues = [new Fr(1n)],
+    nestedExecutions = [],
+    contractStorageUpdateRequests = [],
+    revertReason,
+  }: {
+    from: AztecAddress;
+    tx: FunctionCall;
+    returnValues?: Fr[];
+    nestedExecutions?: PublicExecutionResult[];
+    contractStorageUpdateRequests?: ContractStorageUpdateRequest[];
+    revertReason?: SimulationError;
+  }) {
+    const builder = new PublicExecutionResultBuilder({
+      callContext: new CallContext(
+        from,
+        tx.to,
+        EthAddress.ZERO,
+        tx.functionData.selector,
+        Gas.test(),
+        false,
+        false,
+        0,
+        GasSettings.default(),
+        Fr.ZERO,
+      ),
+      contractAddress: tx.to,
+      functionData: tx.functionData,
+      args: tx.args,
+    });
+
+    builder.withNestedExecutions(...nestedExecutions);
+    builder.withContractStorageUpdateRequest(...contractStorageUpdateRequests);
+    builder.withReturnValues(...returnValues);
+    if (revertReason) {
+      builder.withReverted(revertReason);
+    }
+
+    return builder;
+  }
+
+  withNestedExecutions(...nested: PublicExecutionResult[]): PublicExecutionResultBuilder {
+    this._nestedExecutions.push(...nested);
+    return this;
+  }
+
+  withContractStorageUpdateRequest(...request: ContractStorageUpdateRequest[]): PublicExecutionResultBuilder {
+    this._contractStorageUpdateRequests.push(...request);
+    return this;
+  }
+
+  withReturnValues(...values: Fr[]): PublicExecutionResultBuilder {
+    this._returnValues.push(...values);
+    return this;
+  }
+
+  withReverted(reason: SimulationError): PublicExecutionResultBuilder {
+    this._reverted = true;
+    this._revertReason = reason;
+    return this;
+  }
+
+  build(): PublicExecutionResult {
+    return {
+      execution: this._execution,
+      nestedExecutions: this._nestedExecutions,
+      nullifierReadRequests: [],
+      nullifierNonExistentReadRequests: [],
+      contractStorageUpdateRequests: this._contractStorageUpdateRequests,
+      returnValues: padArrayEnd(this._returnValues, Fr.ZERO, 4), // TODO(#5450) Need to use the proper return values here
+      newNoteHashes: [],
+      newNullifiers: [],
+      newL2ToL1Messages: [],
+      contractStorageReads: [],
+      unencryptedLogs: UnencryptedFunctionL2Logs.empty(),
+      startSideEffectCounter: Fr.ZERO,
+      endSideEffectCounter: Fr.ZERO,
+      reverted: this._reverted,
+      revertReason: this._revertReason,
+      gasLeft: this._execution.callContext.gasLeft.mul(0.9),
+    };
+  }
+}
+
+export const makeFunctionCall = (
+  to = makeAztecAddress(30),
+  selector = makeSelector(5),
+  args = new Array(ARGS_LENGTH).fill(Fr.ZERO),
+) => ({ to, functionData: new FunctionData(selector, false), args });
+
+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,
+  );
+}

package/src/mocks/index.ts

@@ -0,0 +1 @@
+export * from './fixtures.js';