@aztec/simulator 0.35.1 → 0.37.0

package/src/client/client_execution_context.ts

@@ -16,12 +16,13 @@ import {
   FunctionSelector,
   type Header,
   NoteHashReadRequestMembershipWitness,
+  PrivateContextInputs,
   PublicCallRequest,
   type SideEffect,
-  TxContext,
+  type TxContext,
 } from '@aztec/circuits.js';
-import { type Grumpkin } from '@aztec/circuits.js/barretenberg';
-import { computePublicDataTreeLeafSlot, computeUniqueCommitment, siloNoteHash } from '@aztec/circuits.js/hash';
+import { Aes128 } from '@aztec/circuits.js/barretenberg';
+import { computePublicDataTreeLeafSlot, computeUniqueNoteHash, siloNoteHash } from '@aztec/circuits.js/hash';
 import { type FunctionAbi, type FunctionArtifact, countArgumentsSize } from '@aztec/foundation/abi';
 import { type AztecAddress } from '@aztec/foundation/aztec-address';
 import { Fr, type Point } from '@aztec/foundation/fields';
@@ -31,7 +32,7 @@ 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 { type ExecutionResult, type NoteAndSlot } from './execution_result.js';
+import { type ExecutionResult, type NoteAndSlot, type NullifiedNoteHashCounter } from './execution_result.js';
 import { pickNotes } from './pick_notes.js';
 import { executePrivateFunction } from './private_execution.js';
 import { ViewDataOracle } from './view_data_oracle.js';
@@ -58,27 +59,27 @@ export class ClientExecutionContext extends ViewDataOracle {
    * They should act as references for the read requests output by an app circuit via public inputs.
    */
   private gotNotes: Map<bigint, bigint> = new Map();
+  private nullifiedNoteHashCounters: NullifiedNoteHashCounter[] = [];
   private encryptedLogs: EncryptedL2Log[] = [];
   private unencryptedLogs: UnencryptedL2Log[] = [];
   private nestedExecutions: ExecutionResult[] = [];
   private enqueuedPublicFunctionCalls: PublicCallRequest[] = [];
 
   constructor(
-    protected readonly contractAddress: AztecAddress,
+    contractAddress: AztecAddress,
     private readonly argsHash: Fr,
     private readonly txContext: TxContext,
     private readonly callContext: CallContext,
     /** Header of a block whose state is used during private execution (not the block the transaction is included in). */
     protected readonly historicalHeader: Header,
     /** List of transient auth witnesses to be used during this simulation */
-    protected readonly authWitnesses: AuthWitness[],
+    authWitnesses: AuthWitness[],
     private readonly packedValuesCache: PackedValuesCache,
     private readonly noteCache: ExecutionNoteCache,
-    protected readonly db: DBOracle,
-    private readonly curve: Grumpkin,
+    db: DBOracle,
     private node: AztecNode,
     protected sideEffectCounter: number = 0,
-    protected log = createDebugLogger('aztec:simulator:client_execution_context'),
+    log = createDebugLogger('aztec:simulator:client_execution_context'),
   ) {
     super(contractAddress, authWitnesses, db, node, log);
   }
@@ -99,18 +100,14 @@ export class ClientExecutionContext extends ViewDataOracle {
       throw new Error('Invalid arguments size');
     }
 
-    const fields = [
-      ...this.callContext.toFields(),
-      ...this.historicalHeader.toFields(),
-
-      this.txContext.chainId,
-      this.txContext.version,
-
-      new Fr(this.sideEffectCounter),
-
-      ...args,
-    ];
+    const privateContextInputs = new PrivateContextInputs(
+      this.callContext,
+      this.historicalHeader,
+      this.txContext,
+      this.sideEffectCounter,
+    );
 
+    const fields = [...privateContextInputs.toFields(), ...args];
     return toACVMWitness(0, fields);
   }
 
@@ -142,6 +139,10 @@ export class ClientExecutionContext extends ViewDataOracle {
     return this.newNotes;
   }
 
+  public getNullifiedNoteHashCounters() {
+    return this.nullifiedNoteHashCounters;
+  }
+
   /**
    * Return the encrypted logs emitted during this execution.
    */
@@ -171,10 +172,10 @@ export class ClientExecutionContext extends ViewDataOracle {
   }
 
   /**
-   * Pack the given arguments.
+   * Pack the given array of arguments.
    * @param args - Arguments to pack
    */
-  public packArguments(args: Fr[]): Promise<Fr> {
+  public override packArgumentsArray(args: Fr[]): Promise<Fr> {
     return Promise.resolve(this.packedValuesCache.pack(args));
   }
 
@@ -182,7 +183,7 @@ export class ClientExecutionContext extends ViewDataOracle {
    * Pack the given returns.
    * @param returns - Returns to pack
    */
-  public packReturns(returns: Fr[]): Promise<Fr> {
+  public override packReturns(returns: Fr[]): Promise<Fr> {
     return Promise.resolve(this.packedValuesCache.pack(returns));
   }
 
@@ -190,7 +191,7 @@ export class ClientExecutionContext extends ViewDataOracle {
    * Unpack the given returns.
    * @param returnsHash - Returns hash to unpack
    */
-  public unpackReturns(returnsHash: Fr): Promise<Fr[]> {
+  public override unpackReturns(returnsHash: Fr): Promise<Fr[]> {
     return Promise.resolve(this.packedValuesCache.unpack(returnsHash));
   }
 
@@ -214,7 +215,7 @@ export class ClientExecutionContext extends ViewDataOracle {
    * @param status - The status of notes to fetch.
    * @returns Array of note data.
    */
-  public async getNotes(
+  public override async getNotes(
     storageSlot: Fr,
     numSelects: number,
     selectByIndexes: number[],
@@ -260,7 +261,7 @@ export class ClientExecutionContext extends ViewDataOracle {
     notes.forEach(n => {
       if (n.index !== undefined) {
         const siloedNoteHash = siloNoteHash(n.contractAddress, n.innerNoteHash);
-        const uniqueSiloedNoteHash = computeUniqueCommitment(n.nonce, siloedNoteHash);
+        const uniqueSiloedNoteHash = computeUniqueNoteHash(n.nonce, siloedNoteHash);
         // TODO(https://github.com/AztecProtocol/aztec-packages/issues/1386)
         // Should always be uniqueSiloedNoteHash when publicly created notes include nonces.
         const noteHashForReadRequest = n.nonce.isZero() ? siloedNoteHash : uniqueSiloedNoteHash;
@@ -281,16 +282,25 @@ export class ClientExecutionContext extends ViewDataOracle {
    * @param innerNoteHash - The inner note hash of the new note.
    * @returns
    */
-  public notifyCreatedNote(storageSlot: Fr, noteTypeId: Fr, noteItems: Fr[], innerNoteHash: Fr) {
+  public override notifyCreatedNote(
+    storageSlot: Fr,
+    noteTypeId: Fr,
+    noteItems: Fr[],
+    innerNoteHash: Fr,
+    counter: number,
+  ) {
     const note = new Note(noteItems);
-    this.noteCache.addNewNote({
-      contractAddress: this.callContext.storageContractAddress,
-      storageSlot,
-      nonce: Fr.ZERO, // Nonce cannot be known during private execution.
-      note,
-      siloedNullifier: undefined, // Siloed nullifier cannot be known for newly created note.
-      innerNoteHash,
-    });
+    this.noteCache.addNewNote(
+      {
+        contractAddress: this.callContext.storageContractAddress,
+        storageSlot,
+        nonce: Fr.ZERO, // Nonce cannot be known during private execution.
+        note,
+        siloedNullifier: undefined, // Siloed nullifier cannot be known for newly created note.
+        innerNoteHash,
+      },
+      counter,
+    );
     this.newNotes.push({
       storageSlot,
       noteTypeId,
@@ -304,8 +314,15 @@ export class ClientExecutionContext extends ViewDataOracle {
    * @param innerNullifier - The pending nullifier to add in the list (not yet siloed by contract address).
    * @param innerNoteHash - The inner note hash of the new note.
    */
-  public notifyNullifiedNote(innerNullifier: Fr, innerNoteHash: Fr) {
-    this.noteCache.nullifyNote(this.callContext.storageContractAddress, innerNullifier, innerNoteHash);
+  public override notifyNullifiedNote(innerNullifier: Fr, innerNoteHash: Fr, counter: number) {
+    const nullifiedNoteHashCounter = this.noteCache.nullifyNote(
+      this.callContext.storageContractAddress,
+      innerNullifier,
+      innerNoteHash,
+    );
+    if (nullifiedNoteHashCounter !== undefined) {
+      this.nullifiedNoteHashCounters.push({ noteHashCounter: nullifiedNoteHashCounter, nullifierCounter: counter });
+    }
     return Promise.resolve();
   }
 
@@ -317,22 +334,31 @@ export class ClientExecutionContext extends ViewDataOracle {
    * @param publicKey - The public key of the account that can decrypt the log.
    * @param log - The log contents.
    */
-  public emitEncryptedLog(contractAddress: AztecAddress, storageSlot: Fr, noteTypeId: Fr, publicKey: Point, log: Fr[]) {
+  public override emitEncryptedLog(
+    contractAddress: AztecAddress,
+    storageSlot: Fr,
+    noteTypeId: Fr,
+    publicKey: Point,
+    log: Fr[],
+  ) {
     const note = new Note(log);
     const l1NotePayload = new L1NotePayload(note, contractAddress, storageSlot, noteTypeId);
     const taggedNote = new TaggedNote(l1NotePayload);
-    const encryptedNote = taggedNote.toEncryptedBuffer(publicKey, this.curve);
-    this.encryptedLogs.push(new EncryptedL2Log(encryptedNote));
+    const encryptedNote = taggedNote.toEncryptedBuffer(publicKey);
+    const encryptedLog = new EncryptedL2Log(encryptedNote);
+    this.encryptedLogs.push(encryptedLog);
+    return Fr.fromBuffer(encryptedLog.hash());
   }
 
   /**
    * Emit an unencrypted log.
    * @param log - The unencrypted log to be emitted.
    */
-  public emitUnencryptedLog(log: UnencryptedL2Log) {
+  public override emitUnencryptedLog(log: UnencryptedL2Log) {
     this.unencryptedLogs.push(log);
     const text = log.toHumanReadable();
     this.log.verbose(`Emitted unencrypted log: "${text.length > 100 ? text.slice(0, 100) + '...' : text}"`);
+    return Fr.fromBuffer(log.hash());
   }
 
   #checkValidStaticCall(childExecutionResult: ExecutionResult) {
@@ -357,7 +383,7 @@ export class ClientExecutionContext extends ViewDataOracle {
    * @param isStaticCall - Whether the call is a delegate call.
    * @returns The execution result.
    */
-  async callPrivateFunction(
+  override async callPrivateFunction(
     targetContractAddress: AztecAddress,
     functionSelector: FunctionSelector,
     argsHash: Fr,
@@ -374,9 +400,9 @@ export class ClientExecutionContext extends ViewDataOracle {
     const targetArtifact = await this.db.getFunctionArtifact(targetContractAddress, functionSelector);
     const targetFunctionData = FunctionData.fromAbi(targetArtifact);
 
-    const derivedTxContext = new TxContext(false, false, this.txContext.chainId, this.txContext.version);
+    const derivedTxContext = this.txContext.clone();
 
-    const derivedCallContext = await this.deriveCallContext(
+    const derivedCallContext = this.deriveCallContext(
       targetContractAddress,
       targetArtifact,
       sideEffectCounter,
@@ -394,7 +420,6 @@ export class ClientExecutionContext extends ViewDataOracle {
       this.packedValuesCache,
       this.noteCache,
       this.db,
-      this.curve,
       this.node,
       sideEffectCounter,
     );
@@ -426,7 +451,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.
    */
-  public async enqueuePublicFunctionCall(
+  public override async enqueuePublicFunctionCall(
     targetContractAddress: AztecAddress,
     functionSelector: FunctionSelector,
     argsHash: Fr,
@@ -437,7 +462,7 @@ export class ClientExecutionContext extends ViewDataOracle {
     isStaticCall = isStaticCall || this.callContext.isStaticCall;
 
     const targetArtifact = await this.db.getFunctionArtifact(targetContractAddress, functionSelector);
-    const derivedCallContext = await this.deriveCallContext(
+    const derivedCallContext = this.deriveCallContext(
       targetContractAddress,
       targetArtifact,
       sideEffectCounter,
@@ -475,25 +500,20 @@ export class ClientExecutionContext extends ViewDataOracle {
    * @param isStaticCall - Whether the call is a static call.
    * @returns The derived call context.
    */
-  private async deriveCallContext(
+  private deriveCallContext(
     targetContractAddress: AztecAddress,
     targetArtifact: FunctionArtifact,
     startSideEffectCounter: number,
     isDelegateCall = false,
     isStaticCall = false,
   ) {
-    const portalContractAddress = await this.db.getPortalContractAddress(targetContractAddress);
     return new CallContext(
       isDelegateCall ? this.callContext.msgSender : this.contractAddress,
       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,
     );
   }
 
@@ -502,7 +522,7 @@ export class ClientExecutionContext extends ViewDataOracle {
    * @param startStorageSlot - The starting storage slot.
    * @param numberOfElements - Number of elements to read from the starting storage slot.
    */
-  public async storageRead(startStorageSlot: Fr, numberOfElements: number): Promise<Fr[]> {
+  public override async storageRead(startStorageSlot: Fr, numberOfElements: number): Promise<Fr[]> {
     // TODO(#4320): This is a hack to work around not having directly access to the public data tree but
     // still having access to the witnesses
     const bn = await this.db.getBlockNumber();
@@ -521,4 +541,9 @@ export class ClientExecutionContext extends ViewDataOracle {
     }
     return values;
   }
+
+  public override aes128Encrypt(input: Buffer, initializationVector: Buffer, key: Buffer): Buffer {
+    const aes128 = new Aes128();
+    return aes128.encryptBufferCBC(input, initializationVector, key);
+  }
 }

package/src/client/db_oracle.ts

@@ -8,11 +8,10 @@ import {
 import { type CompleteAddress, type Header } from '@aztec/circuits.js';
 import { type FunctionArtifactWithDebugMetadata, type FunctionSelector } from '@aztec/foundation/abi';
 import { type AztecAddress } from '@aztec/foundation/aztec-address';
-import { type EthAddress } from '@aztec/foundation/eth-address';
-import { type Fr } from '@aztec/foundation/fields';
+import { type Fr, type Point } from '@aztec/foundation/fields';
 import { type ContractInstance } from '@aztec/types/contracts';
 
-import { type KeyPair, type NoteData } from '../acvm/index.js';
+import { type NoteData, type NullifierKeys } from '../acvm/index.js';
 import { type CommitmentsDB } from '../public/db.js';
 
 /**
@@ -66,16 +65,22 @@ export interface DBOracle extends CommitmentsDB {
   popCapsule(): Promise<Fr[]>;
 
   /**
-   * Retrieve the nullifier key pair associated with a specific account.
-   * The function only allows access to the secret keys of the transaction creator,
-   * and throws an error if the address does not match the account address of the key pair.
+   * Gets public keys for an address.
+   * @param The address to look up
+   * @returns The public keys for a specific address
+   * TODO(#5834): Replace with `getCompleteAddress`.
+   */
+  getPublicKeysForAddress(address: AztecAddress): Promise<Point[]>;
+
+  /**
+   * Retrieve nullifier keys associated with a specific account and app/contract address.
    *
    * @param accountAddress - The account address.
    * @param contractAddress - The contract address.
-   * @returns A Promise that resolves to the nullifier key pair.
-   * @throws An Error if the input address does not match the account address of the key pair.
+   * @returns A Promise that resolves to nullifier keys of a requested account and contract.
+   * @throws An error if the account is not registered in the database.
    */
-  getNullifierKeyPair(accountAddress: AztecAddress, contractAddress: AztecAddress): Promise<KeyPair>;
+  getNullifierKeys(accountAddress: AztecAddress, contractAddress: AztecAddress): Promise<NullifierKeys>;
 
   /**
    * Retrieves a set of notes stored in the database for a given contract address and storage slot.
@@ -115,15 +120,6 @@ export interface DBOracle extends CommitmentsDB {
     functionName: string,
   ): Promise<FunctionArtifactWithDebugMetadata | undefined>;
 
-  /**
-   * Retrieves the portal contract address associated with the given contract address.
-   * Throws an error if the input contract address is not found or invalid.
-   *
-   * @param contractAddress - The address of the contract whose portal address is to be fetched.
-   * @returns A Promise that resolves to an EthAddress instance, representing the portal contract address.
-   */
-  getPortalContractAddress(contractAddress: AztecAddress): Promise<EthAddress>;
-
   /**
    * Gets the index of a nullifier in the nullifier tree.
    * @param nullifier - The nullifier.

package/src/client/execution_note_cache.ts

@@ -4,6 +4,11 @@ import { Fr } from '@aztec/foundation/fields';
 
 import { type NoteData } from '../acvm/index.js';
 
+export interface PendingNote {
+  note: NoteData;
+  counter: number;
+}
+
 /**
  * Data that's accessible by all the function calls in an execution.
  */
@@ -12,7 +17,7 @@ export class ExecutionNoteCache {
    * New notes created in this transaction.
    * This mapping maps from a contract address to the notes in the contract.
    */
-  private newNotes: Map<bigint, NoteData[]> = new Map();
+  private newNotes: Map<bigint, PendingNote[]> = new Map();
 
   /**
    * The list of nullifiers created in this transaction.
@@ -26,9 +31,9 @@ export class ExecutionNoteCache {
    * Add a new note to cache.
    * @param note - New note created during execution.
    */
-  public addNewNote(note: NoteData) {
+  public addNewNote(note: NoteData, counter: number) {
     const notes = this.newNotes.get(note.contractAddress.toBigInt()) ?? [];
-    notes.push(note);
+    notes.push({ note, counter });
     this.newNotes.set(note.contractAddress.toBigInt(), notes);
   }
 
@@ -46,16 +51,20 @@ export class ExecutionNoteCache {
     nullifiers.add(siloedNullifier.value);
     this.nullifiers.set(contractAddress.toBigInt(), nullifiers);
 
+    let nullifiedNoteHashCounter: number | undefined = undefined;
     // Find and remove the matching new note if the emitted innerNoteHash is not empty.
     if (!innerNoteHash.equals(Fr.ZERO)) {
       const notes = this.newNotes.get(contractAddress.toBigInt()) ?? [];
-      const noteIndexToRemove = notes.findIndex(n => n.innerNoteHash.equals(innerNoteHash));
+      const noteIndexToRemove = notes.findIndex(n => n.note.innerNoteHash.equals(innerNoteHash));
       if (noteIndexToRemove === -1) {
         throw new Error('Attempt to remove a pending note that does not exist.');
       }
-      notes.splice(noteIndexToRemove, 1);
+      const note = notes.splice(noteIndexToRemove, 1)[0];
+      nullifiedNoteHashCounter = note.counter;
       this.newNotes.set(contractAddress.toBigInt(), notes);
     }
+
+    return nullifiedNoteHashCounter;
   }
 
   /**
@@ -66,7 +75,7 @@ export class ExecutionNoteCache {
    **/
   public getNotes(contractAddress: AztecAddress, storageSlot: Fr) {
     const notes = this.newNotes.get(contractAddress.toBigInt()) ?? [];
-    return notes.filter(n => n.storageSlot.equals(storageSlot));
+    return notes.filter(n => n.note.storageSlot.equals(storageSlot)).map(n => n.note);
   }
 
   /**
@@ -77,7 +86,7 @@ export class ExecutionNoteCache {
    **/
   public checkNoteExists(contractAddress: AztecAddress, innerNoteHash: Fr) {
     const notes = this.newNotes.get(contractAddress.toBigInt()) ?? [];
-    return notes.some(n => n.innerNoteHash.equals(innerNoteHash));
+    return notes.some(n => n.note.innerNoteHash.equals(innerNoteHash));
   }
 
   /**

package/src/client/execution_result.ts

@@ -4,7 +4,6 @@ import {
   type PrivateCallStackItem,
   type PublicCallRequest,
 } from '@aztec/circuits.js';
-import { type DecodedReturn } from '@aztec/foundation/abi';
 import { type Fr } from '@aztec/foundation/fields';
 
 import { type ACVMField } from '../acvm/index.js';
@@ -21,6 +20,11 @@ export interface NoteAndSlot {
   noteTypeId: Fr;
 }
 
+export interface NullifiedNoteHashCounter {
+  noteHashCounter: number;
+  nullifierCounter: number;
+}
+
 /**
  * The result of executing a private function.
  */
@@ -37,27 +41,34 @@ export interface ExecutionResult {
   callStackItem: PrivateCallStackItem;
   /** The partially filled-in read request membership witnesses for commitments being read. */
   noteHashReadRequestPartialWitnesses: NoteHashReadRequestMembershipWitness[];
-  // Needed when we enable chained txs. The new notes can be cached and used in a later transaction.
   /** The notes created in the executed function. */
   newNotes: NoteAndSlot[];
-  /** The decoded return values of the executed function. */
-  returnValues: DecodedReturn;
+  nullifiedNoteHashCounters: NullifiedNoteHashCounter[];
+  /** The raw return values of the executed function. */
+  returnValues: Fr[];
   /** The nested executions. */
   nestedExecutions: this[];
   /** Enqueued public function execution requests to be picked up by the sequencer. */
   enqueuedPublicFunctionCalls: PublicCallRequest[];
   /**
    * Encrypted logs emitted during execution of this function call.
-   * Note: These are preimages to `encryptedLogsHash`.
+   * Note: These are preimages to `encryptedLogsHashes`.
    */
   encryptedLogs: EncryptedFunctionL2Logs;
   /**
    * Unencrypted logs emitted during execution of this function call.
-   * Note: These are preimages to `unencryptedLogsHash`.
+   * Note: These are preimages to `unencryptedLogsHashes`.
    */
   unencryptedLogs: UnencryptedFunctionL2Logs;
 }
 
+export function collectNullifiedNoteHashCounters(execResult: ExecutionResult): NullifiedNoteHashCounter[] {
+  return [
+    execResult.nullifiedNoteHashCounters,
+    ...execResult.nestedExecutions.flatMap(collectNullifiedNoteHashCounters),
+  ].flat();
+}
+
 /**
  * Collect all encrypted logs across all nested executions.
  * @param execResult - The topmost execution result.

package/src/client/private_execution.ts

@@ -1,5 +1,5 @@
 import { type FunctionData, PrivateCallStackItem, PrivateCircuitPublicInputs } from '@aztec/circuits.js';
-import { type AbiType, type FunctionArtifactWithDebugMetadata, decodeReturnValues } from '@aztec/foundation/abi';
+import { type FunctionArtifactWithDebugMetadata } from '@aztec/foundation/abi';
 import { type AztecAddress } from '@aztec/foundation/aztec-address';
 import { Fr } from '@aztec/foundation/fields';
 import { createDebugLogger } from '@aztec/foundation/log';
@@ -46,24 +46,18 @@ export async function executePrivateFunction(
   const encryptedLogs = context.getEncryptedLogs();
   const unencryptedLogs = context.getUnencryptedLogs();
   // TODO(https://github.com/AztecProtocol/aztec-packages/issues/1165) --> set this in Noir
-  publicInputs.encryptedLogsHash = Fr.fromBuffer(encryptedLogs.hash());
   publicInputs.encryptedLogPreimagesLength = new Fr(encryptedLogs.getSerializedLength());
-  publicInputs.unencryptedLogsHash = Fr.fromBuffer(unencryptedLogs.hash());
   publicInputs.unencryptedLogPreimagesLength = new Fr(unencryptedLogs.getSerializedLength());
 
   const callStackItem = new PrivateCallStackItem(contractAddress, functionData, publicInputs);
 
-  // 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 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, rawReturnValues);
 
   const noteHashReadRequestPartialWitnesses = context.getNoteHashReadRequestPartialWitnesses(
     publicInputs.noteHashReadRequests,
   );
   const newNotes = context.getNewNotes();
+  const nullifiedNoteHashCounters = context.getNullifiedNoteHashCounters();
   const nestedExecutions = context.getNestedExecutions();
   const enqueuedPublicFunctionCalls = context.getEnqueuedPublicFunctionCalls();
 
@@ -73,9 +67,10 @@ export async function executePrivateFunction(
     acir,
     partialWitness,
     callStackItem,
-    returnValues,
+    returnValues: rawReturnValues,
     noteHashReadRequestPartialWitnesses,
     newNotes,
+    nullifiedNoteHashCounters,
     vk: Buffer.from(artifact.verificationKey!, 'hex'),
     nestedExecutions,
     enqueuedPublicFunctionCalls,

package/src/client/simulator.ts

@@ -1,6 +1,5 @@
 import { type AztecNode, type FunctionCall, type Note, type TxExecutionRequest } from '@aztec/circuit-types';
 import { CallContext, FunctionData } from '@aztec/circuits.js';
-import { Grumpkin } from '@aztec/circuits.js/barretenberg';
 import {
   type ArrayType,
   type FunctionArtifactWithDebugMetadata,
@@ -9,7 +8,6 @@ import {
   encodeArguments,
 } from '@aztec/foundation/abi';
 import { AztecAddress } from '@aztec/foundation/aztec-address';
-import { type EthAddress } from '@aztec/foundation/eth-address';
 import { Fr } from '@aztec/foundation/fields';
 import { type DebugLogger, createDebugLogger } from '@aztec/foundation/log';
 
@@ -61,7 +59,6 @@ export class AcirSimulator {
    * @param request - The transaction request.
    * @param entryPointArtifact - The artifact of the entry point function.
    * @param contractAddress - The address of the contract (should match request.origin)
-   * @param portalContractAddress - The address of the portal contract.
    * @param msgSender - The address calling the function. This can be replaced to simulate a call from another contract or a specific account.
    * @returns The result of the execution.
    */
@@ -69,7 +66,6 @@ export class AcirSimulator {
     request: TxExecutionRequest,
     entryPointArtifact: FunctionArtifactWithDebugMetadata,
     contractAddress: AztecAddress,
-    portalContractAddress: EthAddress,
     msgSender = AztecAddress.ZERO,
   ): Promise<ExecutionResult> {
     if (entryPointArtifact.functionType !== FunctionType.SECRET) {
@@ -82,37 +78,29 @@ export class AcirSimulator {
       );
     }
 
-    const curve = new Grumpkin();
-
     const header = await this.db.getHeader();
 
     // 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,
-      request.argsHash,
+      request.firstCallArgsHash,
       request.txContext,
       callContext,
       header,
       request.authWitnesses,
-      PackedValuesCache.create(request.packedArguments),
+      PackedValuesCache.create(request.argsOfCalls),
       new ExecutionNoteCache(),
       this.db,
-      curve,
       this.node,
       startSideEffectCounter,
     );
@@ -143,7 +131,7 @@ export class AcirSimulator {
     contractAddress: AztecAddress,
   ) {
     if (entryPointArtifact.functionType !== FunctionType.UNCONSTRAINED) {
-      throw new Error(`Cannot run ${entryPointArtifact.functionType} function as constrained`);
+      throw new Error(`Cannot run ${entryPointArtifact.functionType} function as unconstrained`);
     }
 
     const context = new ViewDataOracle(contractAddress, [], this.db, this.node);