@aztec/simulator 0.47.0 → 0.47.1

package/src/acvm/oracle/oracle.ts

@@ -6,7 +6,7 @@ import { Fr, Point } from '@aztec/foundation/fields';
 
 import { type ACVMField } from '../acvm_types.js';
 import { frToBoolean, frToNumber, fromACVMField } from '../deserialize.js';
-import { toACVMField, toAcvmEnqueuePublicFunctionResult } from '../serialize.js';
+import { toACVMField } from '../serialize.js';
 import { type TypedOracle } from './typed_oracle.js';
 
 /**
@@ -429,7 +429,7 @@ export class Oracle {
     [isStaticCall]: ACVMField[],
     [isDelegateCall]: ACVMField[],
   ): Promise<ACVMField[]> {
-    const callStackItem = await this.typedOracle.callPrivateFunction(
+    const { endSideEffectCounter, returnsHash } = await this.typedOracle.callPrivateFunction(
       AztecAddress.fromField(fromACVMField(contractAddress)),
       FunctionSelector.fromField(fromACVMField(functionSelector)),
       fromACVMField(argsHash),
@@ -437,7 +437,7 @@ export class Oracle {
       frToBoolean(fromACVMField(isStaticCall)),
       frToBoolean(fromACVMField(isDelegateCall)),
     );
-    return callStackItem.toFields().map(toACVMField);
+    return [endSideEffectCounter, returnsHash].map(toACVMField);
   }
 
   async callPublicFunction(
@@ -467,7 +467,7 @@ export class Oracle {
     [isStaticCall]: ACVMField[],
     [isDelegateCall]: ACVMField[],
   ) {
-    const enqueuedRequest = await this.typedOracle.enqueuePublicFunctionCall(
+    await this.typedOracle.enqueuePublicFunctionCall(
       AztecAddress.fromString(contractAddress),
       FunctionSelector.fromField(fromACVMField(functionSelector)),
       fromACVMField(argsHash),
@@ -475,7 +475,6 @@ export class Oracle {
       frToBoolean(fromACVMField(isStaticCall)),
       frToBoolean(fromACVMField(isDelegateCall)),
     );
-    return toAcvmEnqueuePublicFunctionResult(enqueuedRequest);
   }
 
   async setPublicTeardownFunctionCall(
@@ -486,7 +485,7 @@ export class Oracle {
     [isStaticCall]: ACVMField[],
     [isDelegateCall]: ACVMField[],
   ) {
-    const teardownRequest = await this.typedOracle.setPublicTeardownFunctionCall(
+    await this.typedOracle.setPublicTeardownFunctionCall(
       AztecAddress.fromString(contractAddress),
       FunctionSelector.fromField(fromACVMField(functionSelector)),
       fromACVMField(argsHash),
@@ -494,7 +493,6 @@ export class Oracle {
       frToBoolean(fromACVMField(isStaticCall)),
       frToBoolean(fromACVMField(isDelegateCall)),
     );
-    return toAcvmEnqueuePublicFunctionResult(teardownRequest);
   }
 
   aes128Encrypt(input: ACVMField[], initializationVector: ACVMField[], key: ACVMField[]): ACVMField[] {

package/src/acvm/oracle/typed_oracle.ts

@@ -9,13 +9,7 @@ import {
   type SiblingPath,
   type UnencryptedL2Log,
 } from '@aztec/circuit-types';
-import {
-  type Header,
-  type KeyValidationRequest,
-  type L1_TO_L2_MSG_TREE_HEIGHT,
-  type PrivateCallStackItem,
-  type PublicCallRequest,
-} from '@aztec/circuits.js';
+import { type Header, type KeyValidationRequest, type L1_TO_L2_MSG_TREE_HEIGHT } from '@aztec/circuits.js';
 import { type FunctionSelector, type NoteSelector } from '@aztec/foundation/abi';
 import { type AztecAddress } from '@aztec/foundation/aztec-address';
 import { Fr } from '@aztec/foundation/fields';
@@ -255,7 +249,7 @@ export abstract class TypedOracle {
     _sideEffectCounter: number,
     _isStaticCall: boolean,
     _isDelegateCall: boolean,
-  ): Promise<PrivateCallStackItem> {
+  ): Promise<{ endSideEffectCounter: Fr; returnsHash: Fr }> {
     throw new OracleMethodNotAvailableError('callPrivateFunction');
   }
 
@@ -277,7 +271,7 @@ export abstract class TypedOracle {
     _sideEffectCounter: number,
     _isStaticCall: boolean,
     _isDelegateCall: boolean,
-  ): Promise<PublicCallRequest> {
+  ): Promise<void> {
     throw new OracleMethodNotAvailableError('enqueuePublicFunctionCall');
   }
 
@@ -288,7 +282,7 @@ export abstract class TypedOracle {
     _sideEffectCounter: number,
     _isStaticCall: boolean,
     _isDelegateCall: boolean,
-  ): Promise<PublicCallRequest> {
+  ): Promise<void> {
     throw new OracleMethodNotAvailableError('setPublicTeardownFunctionCall');
   }
 

package/src/acvm/serialize.ts

@@ -1,4 +1,3 @@
-import { ENQUEUE_PUBLIC_FUNCTION_CALL_RETURN_LENGTH, type PublicCallRequest } from '@aztec/circuits.js';
 import { type AztecAddress } from '@aztec/foundation/aztec-address';
 import { type EthAddress } from '@aztec/foundation/eth-address';
 import { Fr } from '@aztec/foundation/fields';
@@ -40,34 +39,6 @@ export function toACVMField(
   return `0x${adaptBufferSize(buffer).toString('hex')}`;
 }
 
-// Utilities to write TS classes to ACVM Field arrays
-// In the order that the ACVM expects them
-
-/**
- * Converts a public call stack item with the request for executing a public function to
- * a set of ACVM fields accepted by the enqueue_public_function_call_oracle Aztec.nr function.
- * Note that only the fields related to the request are serialized: those related to the result
- * are empty since this is just an execution request, so we don't send them to the circuit.
- * @param item - The public call stack item to serialize to be passed onto Noir.
- * @returns The fields expected by the enqueue_public_function_call_oracle Aztec.nr function.
- * TODO(#4380): Nuke this and replace it with PublicCallRequest.toFields()
- */
-export function toAcvmEnqueuePublicFunctionResult(item: PublicCallRequest): ACVMField[] {
-  const fields = [
-    item.contractAddress.toField(),
-    item.functionSelector.toField(),
-    ...item.callContext.toFields(),
-    item.sideEffectCounter,
-    item.getArgsHash(),
-  ];
-  if (fields.length !== ENQUEUE_PUBLIC_FUNCTION_CALL_RETURN_LENGTH) {
-    throw new Error(
-      `Invalid length for EnqueuePublicFunctionResult (got ${fields.length} expected ${ENQUEUE_PUBLIC_FUNCTION_CALL_RETURN_LENGTH})`,
-    );
-  }
-  return fields.map(toACVMField);
-}
-
 /**
  * Inserts a list of ACVM fields to a witness.
  * @param witnessStartIndex - The index where to start inserting the fields.

package/src/avm/avm_gas.ts

@@ -124,6 +124,7 @@ const BaseGasCosts: Record<Opcode, Gas> = {
   [Opcode.PEDERSEN]: DefaultBaseGasCost,
   [Opcode.ECADD]: DefaultBaseGasCost,
   [Opcode.MSM]: DefaultBaseGasCost,
+  [Opcode.PEDERSENCOMMITMENT]: DefaultBaseGasCost,
   // Conversions
   [Opcode.TORADIXLE]: DefaultBaseGasCost,
   // Other

package/src/avm/opcodes/commitment.ts

@@ -0,0 +1,66 @@
+import { pedersenCommit } from '@aztec/foundation/crypto';
+
+import { type AvmContext } from '../avm_context.js';
+import { Field, TypeTag, Uint8 } from '../avm_memory_types.js';
+import { Opcode, OperandType } from '../serialization/instruction_serialization.js';
+import { Addressing } from './addressing_mode.js';
+import { Instruction } from './instruction.js';
+
+export class PedersenCommitment extends Instruction {
+  static type: string = 'PEDERSENCOMMITMENT';
+  static readonly opcode: Opcode = Opcode.PEDERSENCOMMITMENT;
+
+  // Informs (de)serialization. See Instruction.deserialize.
+  static readonly wireFormat: OperandType[] = [
+    OperandType.UINT8 /* Opcode */,
+    OperandType.UINT8 /* Indirect */,
+    OperandType.UINT32 /* Input Offset*/,
+    OperandType.UINT32 /* Dst Offset */,
+    OperandType.UINT32 /* Input Size Offset */,
+    OperandType.UINT32 /* Generator Index Offset */,
+  ];
+
+  constructor(
+    private indirect: number,
+    private inputOffset: number,
+    private outputOffset: number,
+    private inputSizeOffset: number,
+    private genIndexOffset: number,
+  ) {
+    super();
+  }
+
+  public async execute(context: AvmContext): Promise<void> {
+    const memory = context.machineState.memory.track(this.type);
+    const [inputOffset, outputOffset, inputSizeOffset, genIndexOffset] = Addressing.fromWire(this.indirect).resolve(
+      [this.inputOffset, this.outputOffset, this.inputSizeOffset, this.genIndexOffset],
+      memory,
+    );
+
+    const inputSize = memory.get(inputSizeOffset).toNumber();
+    memory.checkTag(TypeTag.UINT32, inputSizeOffset);
+
+    const inputs = memory.getSlice(inputOffset, inputSize);
+    memory.checkTagsRange(TypeTag.FIELD, inputOffset, inputSize);
+
+    // Generator index not used for now since we dont utilise it in the pedersenCommit function
+    memory.checkTag(TypeTag.UINT32, genIndexOffset);
+
+    const memoryOperations = { reads: inputSize + 1, writes: 3, indirect: this.indirect };
+    context.machineState.consumeGas(this.gasCost(memoryOperations));
+
+    const inputBuffer: Buffer[] = inputs.map(input => input.toBuffer());
+    // TODO: Add the generate index to the pedersenCommit function
+    const commitment = pedersenCommit(inputBuffer).map(f => new Field(f));
+    // The function doesnt include a flag if the output point is infinity, come back to this
+    // for now we just check if theyre zero - until we know how bb encodes them
+    const isInfinity = commitment[0].equals(new Field(0)) && commitment[1].equals(new Field(0));
+
+    memory.set(outputOffset, commitment[0]); // Field typed
+    memory.set(outputOffset + 1, commitment[1]); // Field typed
+    memory.set(outputOffset + 2, new Uint8(isInfinity ? 1 : 0)); // U8 typed
+
+    memory.assert(memoryOperations);
+    context.machineState.incrementPc();
+  }
+}

package/src/avm/serialization/bytecode_serialization.ts

@@ -1,3 +1,4 @@
+import { PedersenCommitment } from '../opcodes/commitment.js';
 import { DAGasLeft, L2GasLeft } from '../opcodes/context_getters.js';
 import { EcAdd } from '../opcodes/ec_add.js';
 import { Keccak, KeccakF1600, Pedersen, Poseidon2, Sha256 } from '../opcodes/hashing.js';
@@ -146,6 +147,7 @@ const INSTRUCTION_SET = () =>
     [Sha256.opcode, Sha256],
     [Pedersen.opcode, Pedersen],
     [MultiScalarMul.opcode, MultiScalarMul],
+    [PedersenCommitment.opcode, PedersenCommitment],
     // Conversions
     [ToRadixLE.opcode, ToRadixLE],
     // Future Gadgets -- pending changes in noir

package/src/avm/serialization/instruction_serialization.ts

@@ -78,6 +78,7 @@ export enum Opcode {
   PEDERSEN, // temp - may be removed, but alot of contracts rely on it
   ECADD,
   MSM,
+  PEDERSENCOMMITMENT,
   // Conversion
   TORADIXLE,
   // Future Gadgets -- pending changes in noir

package/src/client/client_execution_context.ts

@@ -8,6 +8,7 @@ import {
   L1NotePayload,
   Note,
   type NoteStatus,
+  PublicExecutionRequest,
   TaggedLog,
   type UnencryptedL2Log,
 } from '@aztec/circuit-types';
@@ -17,7 +18,6 @@ import {
   type Header,
   type KeyValidationRequest,
   PrivateContextInputs,
-  PublicCallRequest,
   type TxContext,
 } from '@aztec/circuits.js';
 import { Aes128 } from '@aztec/circuits.js/barretenberg';
@@ -38,7 +38,13 @@ import { type NoteData, toACVMWitness } from '../acvm/index.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 { CountedLog, CountedNoteLog, type ExecutionResult, type NoteAndSlot } from './execution_result.js';
+import {
+  CountedLog,
+  CountedNoteLog,
+  CountedPublicExecutionRequest,
+  type ExecutionResult,
+  type NoteAndSlot,
+} from './execution_result.js';
 import { pickNotes } from './pick_notes.js';
 import { executePrivateFunction } from './private_execution.js';
 import { ViewDataOracle } from './view_data_oracle.js';
@@ -70,8 +76,8 @@ export class ClientExecutionContext extends ViewDataOracle {
   private encryptedLogs: CountedLog<EncryptedL2Log>[] = [];
   private unencryptedLogs: CountedLog<UnencryptedL2Log>[] = [];
   private nestedExecutions: ExecutionResult[] = [];
-  private enqueuedPublicFunctionCalls: PublicCallRequest[] = [];
-  private publicTeardownFunctionCall: PublicCallRequest = PublicCallRequest.empty();
+  private enqueuedPublicFunctionCalls: CountedPublicExecutionRequest[] = [];
+  private publicTeardownFunctionCall: PublicExecutionRequest = PublicExecutionRequest.empty();
 
   constructor(
     contractAddress: AztecAddress,
@@ -528,7 +534,11 @@ export class ClientExecutionContext extends ViewDataOracle {
 
     this.nestedExecutions.push(childExecutionResult);
 
-    return childExecutionResult.callStackItem;
+    const publicInputs = childExecutionResult.callStackItem.publicInputs;
+    return {
+      endSideEffectCounter: publicInputs.endSideEffectCounter,
+      returnsHash: publicInputs.returnsHash,
+    };
   }
 
   /**
@@ -540,7 +550,7 @@ export class ClientExecutionContext extends ViewDataOracle {
    * @param isStaticCall - Whether the call is a static call.
    * @returns The public call stack item with the request information.
    */
-  protected async createPublicCallRequest(
+  protected async createPublicExecutionRequest(
     callType: 'enqueued' | 'teardown',
     targetContractAddress: AztecAddress,
     functionSelector: FunctionSelector,
@@ -548,9 +558,7 @@ export class ClientExecutionContext extends ViewDataOracle {
     sideEffectCounter: number,
     isStaticCall: boolean,
     isDelegateCall: boolean,
-  ): Promise<PublicCallRequest> {
-    isStaticCall = isStaticCall || this.callContext.isStaticCall;
-
+  ) {
     const targetArtifact = await this.db.getFunctionArtifact(targetContractAddress, functionSelector);
     const derivedCallContext = this.deriveCallContext(
       targetContractAddress,
@@ -560,22 +568,21 @@ export class ClientExecutionContext extends ViewDataOracle {
     );
     const args = this.packedValuesCache.unpack(argsHash);
 
-    // TODO($846): if enqueued public calls are associated with global
-    // 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.verbose(
-      `Created PublicCallRequest of type [${callType}], side-effect counter [${sideEffectCounter}] to ${targetContractAddress}:${functionSelector}(${targetArtifact.name})`,
+      `Created PublicExecutionRequest of type [${callType}], side-effect counter [${sideEffectCounter}] to ${targetContractAddress}:${functionSelector}(${targetArtifact.name})`,
     );
 
-    return PublicCallRequest.from({
+    const request = PublicExecutionRequest.from({
       args,
       callContext: derivedCallContext,
-      parentCallContext: this.callContext,
-      functionSelector,
       contractAddress: targetContractAddress,
-      sideEffectCounter,
     });
+
+    if (callType === 'enqueued') {
+      this.enqueuedPublicFunctionCalls.push(new CountedPublicExecutionRequest(request, sideEffectCounter));
+    } else {
+      this.publicTeardownFunctionCall = request;
+    }
   }
 
   /**
@@ -596,8 +603,8 @@ export class ClientExecutionContext extends ViewDataOracle {
     sideEffectCounter: number,
     isStaticCall: boolean,
     isDelegateCall: boolean,
-  ): Promise<PublicCallRequest> {
-    const enqueuedRequest = await this.createPublicCallRequest(
+  ) {
+    await this.createPublicExecutionRequest(
       'enqueued',
       targetContractAddress,
       functionSelector,
@@ -606,10 +613,6 @@ export class ClientExecutionContext extends ViewDataOracle {
       isStaticCall,
       isDelegateCall,
     );
-
-    this.enqueuedPublicFunctionCalls.push(enqueuedRequest);
-
-    return enqueuedRequest;
   }
 
   /**
@@ -630,8 +633,8 @@ export class ClientExecutionContext extends ViewDataOracle {
     sideEffectCounter: number,
     isStaticCall: boolean,
     isDelegateCall: boolean,
-  ): Promise<PublicCallRequest> {
-    const publicTeardownFunctionCall = await this.createPublicCallRequest(
+  ) {
+    await this.createPublicExecutionRequest(
       'teardown',
       targetContractAddress,
       functionSelector,
@@ -640,10 +643,6 @@ export class ClientExecutionContext extends ViewDataOracle {
       isStaticCall,
       isDelegateCall,
     );
-
-    this.publicTeardownFunctionCall = publicTeardownFunctionCall;
-
-    return publicTeardownFunctionCall;
   }
 
   /**

package/src/client/execution_result.ts

@@ -4,10 +4,11 @@ import {
   type EncryptedL2NoteLog,
   EncryptedNoteFunctionL2Logs,
   type Note,
+  PublicExecutionRequest,
   UnencryptedFunctionL2Logs,
   type UnencryptedL2Log,
 } from '@aztec/circuit-types';
-import { type IsEmpty, type PrivateCallStackItem, PublicCallRequest, sortByCounter } from '@aztec/circuits.js';
+import { type IsEmpty, type PrivateCallStackItem, sortByCounter } from '@aztec/circuits.js';
 import { type NoteSelector } from '@aztec/foundation/abi';
 import { type Fr } from '@aztec/foundation/fields';
 
@@ -38,6 +39,15 @@ export class CountedNoteLog extends CountedLog<EncryptedL2NoteLog> {
     super(log, counter);
   }
 }
+
+export class CountedPublicExecutionRequest {
+  constructor(public request: PublicExecutionRequest, public counter: number) {}
+
+  isEmpty(): boolean {
+    return this.request.isEmpty() && !this.counter;
+  }
+}
+
 /**
  * The result of executing a private function.
  */
@@ -63,9 +73,9 @@ export interface ExecutionResult {
   /** The nested executions. */
   nestedExecutions: this[];
   /** Enqueued public function execution requests to be picked up by the sequencer. */
-  enqueuedPublicFunctionCalls: PublicCallRequest[];
+  enqueuedPublicFunctionCalls: CountedPublicExecutionRequest[];
   /** Public function execution requested for teardown */
-  publicTeardownFunctionCall: PublicCallRequest;
+  publicTeardownFunctionCall: PublicExecutionRequest;
   /**
    * Encrypted note logs emitted during execution of this function call.
    * Note: These are preimages to `noteEncryptedLogsHashes`.
@@ -161,21 +171,26 @@ export function collectSortedUnencryptedLogs(execResult: ExecutionResult): Unenc
   return new UnencryptedFunctionL2Logs(sortedLogs.map(l => l.log));
 }
 
+function collectEnqueuedCountedPublicExecutionRequests(execResult: ExecutionResult): CountedPublicExecutionRequest[] {
+  return [
+    ...execResult.enqueuedPublicFunctionCalls,
+    ...execResult.nestedExecutions.flatMap(collectEnqueuedCountedPublicExecutionRequests),
+  ];
+}
+
 /**
  * Collect all enqueued public function calls across all nested executions.
  * @param execResult - The topmost execution result.
  * @returns All enqueued public function calls.
  */
-export function collectEnqueuedPublicFunctionCalls(execResult: ExecutionResult): PublicCallRequest[] {
+export function collectEnqueuedPublicFunctionCalls(execResult: ExecutionResult): PublicExecutionRequest[] {
+  const countedRequests = collectEnqueuedCountedPublicExecutionRequests(execResult);
   // without the reverse sort, the logs will be in a queue like fashion which is wrong
   // as the kernel processes it like a stack, popping items off and pushing them to output
-  return [
-    ...execResult.enqueuedPublicFunctionCalls,
-    ...execResult.nestedExecutions.flatMap(collectEnqueuedPublicFunctionCalls),
-  ].sort((a, b) => b.sideEffectCounter - a.sideEffectCounter);
+  return sortByCounter(countedRequests, false).map(r => r.request);
 }
 
-export function collectPublicTeardownFunctionCall(execResult: ExecutionResult): PublicCallRequest {
+export function collectPublicTeardownFunctionCall(execResult: ExecutionResult): PublicExecutionRequest {
   const teardownCalls = [
     execResult.publicTeardownFunctionCall,
     ...execResult.nestedExecutions.flatMap(collectPublicTeardownFunctionCall),
@@ -189,5 +204,5 @@ export function collectPublicTeardownFunctionCall(execResult: ExecutionResult):
     throw new Error('Multiple public teardown calls detected');
   }
 
-  return PublicCallRequest.empty();
+  return PublicExecutionRequest.empty();
 }

package/src/mocks/fixtures.ts

@@ -1,4 +1,9 @@
-import { type FunctionCall, type SimulationError, UnencryptedFunctionL2Logs } from '@aztec/circuit-types';
+import {
+  type FunctionCall,
+  PublicExecutionRequest,
+  type SimulationError,
+  UnencryptedFunctionL2Logs,
+} from '@aztec/circuit-types';
 import {
   ARGS_LENGTH,
   AvmExecutionHints,
@@ -8,13 +13,12 @@ import {
   type ContractStorageUpdateRequest,
   Fr,
   Gas,
-  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 PublicExecutionRequest, type PublicExecutionResult } from '../public/execution.js';
+import { type PublicExecutionResult, resultToPublicCallRequest } from '../public/execution.js';
 
 export class PublicExecutionResultBuilder {
   private _executionRequest: PublicExecutionRequest;
@@ -29,7 +33,7 @@ export class PublicExecutionResultBuilder {
     this._executionRequest = executionRequest;
   }
 
-  static fromPublicCallRequest({
+  static fromPublicExecutionRequest({
     request,
     returnValues = [new Fr(1n)],
     nestedExecutions = [],
@@ -37,7 +41,7 @@ export class PublicExecutionResultBuilder {
     contractStorageReads = [],
     revertReason = undefined,
   }: {
-    request: PublicCallRequest;
+    request: PublicExecutionRequest;
     returnValues?: Fr[];
     nestedExecutions?: PublicExecutionResult[];
     contractStorageUpdateRequests?: ContractStorageUpdateRequest[];
@@ -74,12 +78,9 @@ export class PublicExecutionResultBuilder {
     contractStorageReads?: ContractStorageRead[];
     revertReason?: SimulationError;
   }) {
-    const builder = new PublicExecutionResultBuilder({
-      callContext: new CallContext(from, tx.to, tx.selector, false, false),
-      contractAddress: tx.to,
-      functionSelector: tx.selector,
-      args: tx.args,
-    });
+    const builder = new PublicExecutionResultBuilder(
+      new PublicExecutionRequest(tx.to, new CallContext(from, tx.to, tx.selector, false, false), tx.args),
+    );
 
     builder.withNestedExecutions(...nestedExecutions);
     builder.withContractStorageUpdateRequest(...contractStorageUpdateRequests);
@@ -122,6 +123,7 @@ export class PublicExecutionResultBuilder {
     return {
       executionRequest: this._executionRequest,
       nestedExecutions: this._nestedExecutions,
+      publicCallRequests: this._nestedExecutions.map(resultToPublicCallRequest),
       noteHashReadRequests: [],
       nullifierReadRequests: [],
       nullifierNonExistentReadRequests: [],