@aztec/simulator 0.40.0 → 0.41.0

package/src/client/db_oracle.ts

@@ -5,13 +5,13 @@ import {
   type NullifierMembershipWitness,
   type PublicDataWitness,
 } from '@aztec/circuit-types';
-import { type CompleteAddress, type Header } from '@aztec/circuits.js';
+import { type CompleteAddress, type Header, type KeyValidationRequest } from '@aztec/circuits.js';
 import { type FunctionArtifact, type FunctionSelector } from '@aztec/foundation/abi';
 import { type AztecAddress } from '@aztec/foundation/aztec-address';
 import { type Fr } from '@aztec/foundation/fields';
 import { type ContractInstance } from '@aztec/types/contracts';
 
-import { type NoteData, type NullifierKeys } from '../acvm/index.js';
+import { type NoteData } from '../acvm/index.js';
 import { type CommitmentsDB } from '../public/db.js';
 
 /**
@@ -45,10 +45,11 @@ export interface DBOracle extends CommitmentsDB {
 
   /**
    * Retrieve the complete address associated to a given address.
-   * @param address - Address to fetch the pubkey for.
+   * @param account - The account address.
    * @returns A complete address associated with the input address.
+   * @throws An error if the account is not registered in the database.
    */
-  getCompleteAddress(address: AztecAddress): Promise<CompleteAddress>;
+  getCompleteAddress(account: AztecAddress): Promise<CompleteAddress>;
 
   /**
    * Retrieve the auth witness for a given message hash.
@@ -65,14 +66,12 @@ export interface DBOracle extends CommitmentsDB {
   popCapsule(): Promise<Fr[]>;
 
   /**
-   * 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 nullifier keys of a requested account and contract.
-   * @throws An error if the account is not registered in the database.
+   * Retrieve keys associated with a specific master public key and app address.
+   * @param pkMHash - The master public key hash.
+   * @returns A Promise that resolves to nullifier keys.
+   * @throws If the keys are not registered in the key store.
    */
-  getNullifierKeys(accountAddress: AztecAddress, contractAddress: AztecAddress): Promise<NullifierKeys>;
+  getKeyValidationRequest(pkMHash: Fr, contractAddress: AztecAddress): Promise<KeyValidationRequest>;
 
   /**
    * Retrieves a set of notes stored in the database for a given contract address and storage slot.

package/src/client/execution_note_cache.ts

@@ -1,8 +1,10 @@
+import { type EncryptedL2Log } from '@aztec/circuit-types';
 import { siloNullifier } from '@aztec/circuits.js/hash';
 import { type AztecAddress } from '@aztec/foundation/aztec-address';
 import { Fr } from '@aztec/foundation/fields';
 
 import { type NoteData } from '../acvm/index.js';
+import { type CountedLog } from './execution_result.js';
 
 export interface PendingNote {
   note: NoteData;
@@ -27,6 +29,13 @@ export class ExecutionNoteCache {
    */
   private nullifiers: Map<bigint, Set<bigint>> = new Map();
 
+  /**
+   * The list of encrypted logs linked to note hashes created in this transaction.
+   * This mapping maps from inner note hash to log(s) emitted for that note hash.
+   * Note that their value (bigint representation) is used because Frs cannot be looked up in Sets.
+   */
+  private logs: Map<bigint, CountedLog<EncryptedL2Log>[]> = new Map();
+
   /**
    * Add a new note to cache.
    * @param note - New note created during execution.
@@ -37,6 +46,16 @@ export class ExecutionNoteCache {
     this.newNotes.set(note.contractAddress.toBigInt(), notes);
   }
 
+  /**
+   * Add a new note to cache.
+   * @param note - New note created during execution.
+   */
+  public addNewLog(log: CountedLog<EncryptedL2Log>, innerNoteHash: Fr) {
+    const logs = this.logs.get(innerNoteHash.toBigInt()) ?? [];
+    logs.push(log);
+    this.logs.set(innerNoteHash.toBigInt(), logs);
+  }
+
   /**
    * Add a nullifier to cache. It could be for a db note or a new note created during execution.
    * @param contractAddress - Contract address of the note.
@@ -52,7 +71,7 @@ export class ExecutionNoteCache {
     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.
+    // Find and remove the matching new note and log(s) 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.note.innerNoteHash.equals(innerNoteHash));
@@ -62,6 +81,8 @@ export class ExecutionNoteCache {
       const note = notes.splice(noteIndexToRemove, 1)[0];
       nullifiedNoteHashCounter = note.counter;
       this.newNotes.set(contractAddress.toBigInt(), notes);
+      // If a log linked to the note hash does not exist, this method just does nothing
+      this.logs.delete(innerNoteHash.toBigInt());
     }
 
     return nullifiedNoteHashCounter;
@@ -96,4 +117,11 @@ export class ExecutionNoteCache {
   public getNullifiers(contractAddress: AztecAddress): Set<bigint> {
     return this.nullifiers.get(contractAddress.toBigInt()) ?? new Set();
   }
+
+  /**
+   * Return all note logs emitted from a contract.
+   */
+  public getLogs(): CountedLog<EncryptedL2Log>[] {
+    return Array.from(this.logs.values()).flat();
+  }
 }

package/src/client/execution_result.ts

@@ -58,6 +58,11 @@ export interface ExecutionResult {
   enqueuedPublicFunctionCalls: PublicCallRequest[];
   /** Public function execution requested for teardown */
   publicTeardownFunctionCall: PublicCallRequest;
+  /**
+   * Encrypted note logs emitted during execution of this function call.
+   * Note: These are preimages to `noteEncryptedLogsHashes`.
+   */
+  noteEncryptedLogs: CountedLog<EncryptedL2Log>[];
   /**
    * Encrypted logs emitted during execution of this function call.
    * Note: These are preimages to `encryptedLogsHashes`.
@@ -82,13 +87,32 @@ export function collectNullifiedNoteHashCounters(execResult: ExecutionResult, ac
   return accum;
 }
 
+/**
+ * Collect all encrypted logs across all nested executions.
+ * @param execResult - The topmost execution result.
+ * @returns All encrypted logs.
+ */
+function collectNoteEncryptedLogs(execResult: ExecutionResult): CountedLog<EncryptedL2Log>[] {
+  return [execResult.noteEncryptedLogs, ...execResult.nestedExecutions.flatMap(collectNoteEncryptedLogs)].flat();
+}
+
+/**
+ * Collect all encrypted logs across all nested executions and sorts by counter.
+ * @param execResult - The topmost execution result.
+ * @returns All encrypted logs.
+ */
+export function collectSortedNoteEncryptedLogs(execResult: ExecutionResult): EncryptedFunctionL2Logs {
+  const allLogs = collectNoteEncryptedLogs(execResult);
+  const sortedLogs = sortByCounter(allLogs);
+  return new EncryptedFunctionL2Logs(sortedLogs.map(l => l.log));
+}
 /**
  * Collect all encrypted logs across all nested executions.
  * @param execResult - The topmost execution result.
  * @returns All encrypted logs.
  */
 function collectEncryptedLogs(execResult: ExecutionResult): CountedLog<EncryptedL2Log>[] {
-  return [execResult.encryptedLogs, ...[...execResult.nestedExecutions].flatMap(collectEncryptedLogs)].flat();
+  return [execResult.encryptedLogs, ...execResult.nestedExecutions.flatMap(collectEncryptedLogs)].flat();
 }
 
 /**
@@ -108,7 +132,7 @@ export function collectSortedEncryptedLogs(execResult: ExecutionResult): Encrypt
  * @returns All unencrypted logs.
  */
 function collectUnencryptedLogs(execResult: ExecutionResult): CountedLog<UnencryptedL2Log>[] {
-  return [execResult.unencryptedLogs, ...[...execResult.nestedExecutions].flatMap(collectUnencryptedLogs)].flat();
+  return [execResult.unencryptedLogs, ...execResult.nestedExecutions.flatMap(collectUnencryptedLogs)].flat();
 }
 
 /**

package/src/client/private_execution.ts

@@ -42,6 +42,8 @@ export async function executePrivateFunction(
   const returnWitness = witnessMapToFields(acirExecutionResult.returnWitness);
   const publicInputs = PrivateCircuitPublicInputs.fromFields(returnWitness);
 
+  context.chopNoteEncryptedLogs();
+  const noteEncryptedLogs = context.getNoteEncryptedLogs();
   const encryptedLogs = context.getEncryptedLogs();
   const unencryptedLogs = context.getUnencryptedLogs();
 
@@ -69,6 +71,7 @@ export async function executePrivateFunction(
     vk: Buffer.from(artifact.verificationKey!, 'hex'),
     nestedExecutions,
     enqueuedPublicFunctionCalls,
+    noteEncryptedLogs,
     publicTeardownFunctionCall,
     encryptedLogs,
     unencryptedLogs,

package/src/client/simulator.ts

@@ -19,7 +19,6 @@ import { ClientExecutionContext } from './client_execution_context.js';
 import { type DBOracle } from './db_oracle.js';
 import { ExecutionNoteCache } from './execution_note_cache.js';
 import { type ExecutionResult } from './execution_result.js';
-import { LogsCache } from './logs_cache.js';
 import { executePrivateFunction } from './private_execution.js';
 import { executeUnconstrainedFunction } from './unconstrained_execution.js';
 import { ViewDataOracle } from './view_data_oracle.js';
@@ -69,8 +68,8 @@ export class AcirSimulator {
     contractAddress: AztecAddress,
     msgSender = AztecAddress.ZERO,
   ): Promise<ExecutionResult> {
-    if (entryPointArtifact.functionType !== FunctionType.SECRET) {
-      throw new Error(`Cannot run ${entryPointArtifact.functionType} function as secret`);
+    if (entryPointArtifact.functionType !== FunctionType.PRIVATE) {
+      throw new Error(`Cannot run ${entryPointArtifact.functionType} function as private`);
     }
 
     if (request.origin !== contractAddress) {
@@ -89,7 +88,7 @@ export class AcirSimulator {
       contractAddress,
       FunctionSelector.fromNameAndParameters(entryPointArtifact.name, entryPointArtifact.parameters),
       false,
-      false,
+      entryPointArtifact.isStatic,
       startSideEffectCounter,
     );
     const context = new ClientExecutionContext(
@@ -101,7 +100,6 @@ export class AcirSimulator {
       request.authWitnesses,
       PackedValuesCache.create(request.argsOfCalls),
       new ExecutionNoteCache(),
-      new LogsCache(),
       this.db,
       this.node,
       startSideEffectCounter,
@@ -197,6 +195,7 @@ export class AcirSimulator {
     const execRequest: FunctionCall = {
       to: contractAddress,
       functionData: FunctionData.empty(),
+      isStatic: artifact.isStatic,
       args: encodeArguments(artifact, [contractAddress, nonce, storageSlot, noteTypeId, extendedNoteItems]),
     };
 

package/src/client/view_data_oracle.ts

@@ -7,14 +7,14 @@ import {
   type NullifierMembershipWitness,
   type PublicDataWitness,
 } from '@aztec/circuit-types';
-import { type Header } from '@aztec/circuits.js';
+import { type Header, type KeyValidationRequest } from '@aztec/circuits.js';
 import { siloNullifier } from '@aztec/circuits.js/hash';
 import { type AztecAddress } from '@aztec/foundation/aztec-address';
 import { Fr } from '@aztec/foundation/fields';
-import { createDebugLogger } from '@aztec/foundation/log';
+import { applyStringFormatting, createDebugLogger } from '@aztec/foundation/log';
 import { type ContractInstance } from '@aztec/types/contracts';
 
-import { type NoteData, type NullifierKeys, TypedOracle } from '../acvm/index.js';
+import { type NoteData, TypedOracle } from '../acvm/index.js';
 import { type DBOracle } from './db_oracle.js';
 import { pickNotes } from './pick_notes.js';
 
@@ -35,14 +35,13 @@ export class ViewDataOracle extends TypedOracle {
   }
 
   /**
-   * Retrieve nullifier keys associated with a specific account and app/contract address.
-   *
-   * @param accountAddress - The account address.
-   * @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.
+   * Retrieve keys associated with a specific master public key and app address.
+   * @param pkMHash - The master public key hash.
+   * @returns A Promise that resolves to nullifier keys.
+   * @throws If the keys are not registered in the key store.
    */
-  public override getNullifierKeys(account: AztecAddress): Promise<NullifierKeys> {
-    return this.db.getNullifierKeys(account, this.contractAddress);
+  public override getKeyValidationRequest(pkMHash: Fr): Promise<KeyValidationRequest> {
+    return this.db.getKeyValidationRequest(pkMHash, this.contractAddress);
   }
 
   /**
@@ -129,11 +128,12 @@ export class ViewDataOracle extends TypedOracle {
 
   /**
    * Retrieve the complete address associated to a given address.
-   * @param address - Address to fetch the complete address for.
+   * @param account - The account address.
    * @returns A complete address associated with the input address.
+   * @throws An error if the account is not registered in the database.
    */
-  public override getCompleteAddress(address: AztecAddress): Promise<CompleteAddress> {
-    return this.db.getCompleteAddress(address);
+  public override getCompleteAddress(account: AztecAddress): Promise<CompleteAddress> {
+    return this.db.getCompleteAddress(account);
   }
 
   /**
@@ -258,4 +258,9 @@ export class ViewDataOracle extends TypedOracle {
     }
     return values;
   }
+
+  public override debugLog(message: string, fields: Fr[]): void {
+    const formattedStr = applyStringFormatting(message, fields);
+    this.log.verbose(`debug_log ${formattedStr}`);
+  }
 }

package/src/common/index.ts

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

package/src/common/return_values.ts

@@ -0,0 +1,18 @@
+import { NestedProcessReturnValues } from '@aztec/circuit-types';
+
+import type { ExecutionResult } from '../client/execution_result.js';
+import type { PublicExecutionResult } from '../public/execution.js';
+
+/**
+ * Recursively accummulate the return values of a call result and its nested executions,
+ * so they can be retrieved in order.
+ * @param executionResult
+ * @returns
+ */
+export function accumulateReturnValues(
+  executionResult: PublicExecutionResult | ExecutionResult,
+): NestedProcessReturnValues {
+  const acc = new NestedProcessReturnValues(executionResult.returnValues);
+  acc.nested = executionResult.nestedExecutions.map(nestedExecution => accumulateReturnValues(nestedExecution));
+  return acc;
+}

package/src/mocks/fixtures.ts

@@ -116,7 +116,6 @@ export class PublicExecutionResultBuilder {
       contractStorageReads: [],
       unencryptedLogsHashes: [],
       unencryptedLogs: UnencryptedFunctionL2Logs.empty(),
-      unencryptedLogPreimagesLength: new Fr(4n), // empty logs have len 4
       allUnencryptedLogs: UnencryptedFunctionL2Logs.empty(),
       startSideEffectCounter: Fr.ZERO,
       endSideEffectCounter: Fr.ZERO,
@@ -134,7 +133,8 @@ export const makeFunctionCall = (
   to = makeAztecAddress(30),
   selector = makeSelector(5),
   args = new Array(ARGS_LENGTH).fill(Fr.ZERO),
-) => ({ to, functionData: new FunctionData(selector, false), args });
+  isStatic = false,
+) => ({ to, functionData: new FunctionData(selector, /*isPrivate=*/ false), args, isStatic });
 
 export function addKernelPublicCallStack(
   kernelOutput: PrivateKernelTailCircuitPublicInputs,

package/src/public/abstract_phase_manager.ts

@@ -1,6 +1,6 @@
 import {
   MerkleTreeId,
-  type ProcessReturnValues,
+  type NestedProcessReturnValues,
   type PublicKernelRequest,
   PublicKernelType,
   type SimulationError,
@@ -18,6 +18,7 @@ import {
   type Header,
   type KernelCircuitPublicInputs,
   L2ToL1Message,
+  LogHash,
   MAX_NEW_L2_TO_L1_MSGS_PER_CALL,
   MAX_NEW_NOTE_HASHES_PER_CALL,
   MAX_NEW_NULLIFIERS_PER_CALL,
@@ -44,7 +45,6 @@ import {
   PublicKernelData,
   ReadRequest,
   RevertCode,
-  SideEffect,
   VK_TREE_HEIGHT,
   VerificationKey,
   makeEmptyProof,
@@ -57,6 +57,7 @@ import {
   type PublicExecution,
   type PublicExecutionResult,
   type PublicExecutor,
+  accumulateReturnValues,
   collectPublicDataReads,
   collectPublicDataUpdateRequests,
   isPublicExecutionResult,
@@ -140,7 +141,7 @@ export abstract class AbstractPhaseManager {
      * revert reason, if any
      */
     revertReason: SimulationError | undefined;
-    returnValues: ProcessReturnValues;
+    returnValues: NestedProcessReturnValues[];
     /** Gas used during the execution this particular phase. */
     gasUsed: Gas | undefined;
   }>;
@@ -227,7 +228,7 @@ export abstract class AbstractPhaseManager {
       Proof,
       UnencryptedFunctionL2Logs[],
       SimulationError | undefined,
-      ProcessReturnValues,
+      NestedProcessReturnValues[],
       Gas,
     ]
   > {
@@ -238,7 +239,7 @@ export abstract class AbstractPhaseManager {
     const enqueuedCalls = this.extractEnqueuedPublicCalls(tx);
 
     if (!enqueuedCalls || !enqueuedCalls.length) {
-      return [[], kernelOutput, kernelProof, [], undefined, undefined, Gas.empty()];
+      return [[], kernelOutput, kernelProof, [], undefined, [], Gas.empty()];
     }
 
     const newUnencryptedFunctionLogs: UnencryptedFunctionL2Logs[] = [];
@@ -250,9 +251,10 @@ export abstract class AbstractPhaseManager {
     // separate public callstacks to be proven by separate public kernel sequences
     // and submitted separately to the base rollup?
 
-    let returns: ProcessReturnValues = undefined;
     let gasUsed = Gas.empty();
 
+    const enqueuedCallResults = [];
+
     for (const enqueuedCall of enqueuedCalls) {
       const executionStack: (PublicExecution | PublicExecutionResult)[] = [enqueuedCall];
 
@@ -334,13 +336,14 @@ export abstract class AbstractPhaseManager {
             }`,
           );
           // TODO(@spalladino): Check gasUsed is correct. The AVM should take care of setting gasLeft to zero upon a revert.
-          return [[], kernelOutput, kernelProof, [], result.revertReason, undefined, gasUsed];
+          return [[], kernelOutput, kernelProof, [], result.revertReason, [], gasUsed];
         }
 
         if (!enqueuedExecutionResult) {
           enqueuedExecutionResult = result;
-          returns = result.returnValues;
         }
+
+        enqueuedCallResults.push(accumulateReturnValues(enqueuedExecutionResult));
       }
       // HACK(#1622): Manually patches the ordering of public state actions
       // TODO(#757): Enforce proper ordering of public state actions
@@ -350,7 +353,15 @@ export abstract class AbstractPhaseManager {
     // TODO(#3675): This should be done in a public kernel circuit
     removeRedundantPublicDataWrites(kernelOutput, this.phase);
 
-    return [publicKernelInputs, kernelOutput, kernelProof, newUnencryptedFunctionLogs, undefined, returns, gasUsed];
+    return [
+      publicKernelInputs,
+      kernelOutput,
+      kernelProof,
+      newUnencryptedFunctionLogs,
+      undefined,
+      enqueuedCallResults,
+      gasUsed,
+    ];
   }
 
   /** Returns all pending private and public nullifiers.  */
@@ -451,12 +462,7 @@ export abstract class AbstractPhaseManager {
         MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_CALL,
       ),
       publicCallStackHashes,
-      unencryptedLogsHashes: padArrayEnd(
-        result.unencryptedLogsHashes,
-        SideEffect.empty(),
-        MAX_UNENCRYPTED_LOGS_PER_CALL,
-      ),
-      unencryptedLogPreimagesLength: result.unencryptedLogPreimagesLength,
+      unencryptedLogsHashes: padArrayEnd(result.unencryptedLogsHashes, LogHash.empty(), MAX_UNENCRYPTED_LOGS_PER_CALL),
       historicalHeader: this.historicalHeader,
       globalVariables: this.globalVariables,
       startGasLeft: Gas.from(result.startGasLeft),

package/src/public/execution.ts

@@ -4,13 +4,13 @@ import {
   type ContractStorageUpdateRequest,
   type Fr,
   type L2ToL1Message,
+  type LogHash,
   type NoteHash,
   type Nullifier,
   type PublicCallRequest,
   PublicDataRead,
   PublicDataUpdateRequest,
   type ReadRequest,
-  type SideEffect,
 } from '@aztec/circuits.js';
 import { computePublicDataTreeLeafSlot, computePublicDataTreeValue } from '@aztec/circuits.js/hash';
 
@@ -48,16 +48,12 @@ export interface PublicExecutionResult {
    * The hashed logs with side effect counter.
    * Note: required as we don't track the counter anywhere else.
    */
-  unencryptedLogsHashes: SideEffect[];
+  unencryptedLogsHashes: LogHash[];
   /**
    * Unencrypted logs emitted during execution of this function call.
    * Note: These are preimages to `unencryptedLogsHashes`.
    */
   unencryptedLogs: UnencryptedFunctionL2Logs;
-  /**
-   * Length of the unencrypted log preimages emitted in this function call.
-   */
-  unencryptedLogPreimagesLength: Fr;
   /**
    * Unencrypted logs emitted during this call AND any nested calls.
    * Useful for maintaining correct ordering in ts.

package/src/public/executor.ts

@@ -11,6 +11,7 @@ import {
 import { createDebugLogger } from '@aztec/foundation/log';
 
 import { spawn } from 'child_process';
+import { assert } from 'console';
 import fs from 'fs/promises';
 import path from 'path';
 
@@ -27,7 +28,12 @@ import { PackedValuesCache } from '../common/packed_values_cache.js';
 import { type CommitmentsDB, type PublicContractsDB, type PublicStateDB } from './db.js';
 import { type PublicExecution, type PublicExecutionResult, checkValidStaticCall } from './execution.js';
 import { PublicExecutionContext } from './public_execution_context.js';
-import { convertAvmResultsToPxResult, createAvmExecutionEnvironment, isAvmBytecode } from './transitional_adaptors.js';
+import {
+  convertAvmResultsToPxResult,
+  createAvmExecutionEnvironment,
+  decompressBytecodeIfCompressed,
+  isAvmBytecode,
+} from './transitional_adaptors.js';
 
 /**
  * Execute a public function and return the execution result.
@@ -46,7 +52,7 @@ export async function executePublicFunction(
     );
   }
 
-  if (isAvmBytecode(bytecode)) {
+  if (await isAvmBytecode(bytecode)) {
     return await executeTopLevelPublicFunctionAvm(context, bytecode);
   } else {
     return await executePublicFunctionAcvm(context, bytecode, nested);
@@ -82,7 +88,8 @@ async function executeTopLevelPublicFunctionAvm(
   for (const nullifier of executionContext.pendingNullifiers) {
     worldStateJournal.nullifiers.cache.appendSiloed(nullifier.value);
   }
-  worldStateJournal.trace.accessCounter = startSideEffectCounter;
+  // All the subsequent side effects will have a counter larger than the call's start counter.
+  worldStateJournal.trace.accessCounter = startSideEffectCounter + 1;
 
   const executionEnv = createAvmExecutionEnvironment(
     executionContext.execution,
@@ -184,7 +191,6 @@ async function executePublicFunctionAcvm(
       nestedExecutions: [],
       unencryptedLogsHashes: [],
       unencryptedLogs: UnencryptedFunctionL2Logs.empty(),
-      unencryptedLogPreimagesLength: new Fr(4n), // empty logs have len 4
       allUnencryptedLogs: UnencryptedFunctionL2Logs.empty(),
       reverted,
       revertReason,
@@ -209,7 +215,6 @@ async function executePublicFunctionAcvm(
     startSideEffectCounter,
     endSideEffectCounter,
     unencryptedLogsHashes: unencryptedLogsHashesPadded,
-    unencryptedLogPreimagesLength,
   } = PublicCircuitPublicInputs.fromFields(returnWitness);
   const returnValues = await context.unpackReturns(returnsHash);
 
@@ -256,7 +261,6 @@ async function executePublicFunctionAcvm(
     nestedExecutions,
     unencryptedLogsHashes,
     unencryptedLogs,
-    unencryptedLogPreimagesLength,
     allUnencryptedLogs,
     reverted: false,
     revertReason: undefined,
@@ -354,7 +358,10 @@ export class PublicExecutor {
     const proofPath = path.join(artifactsPath, 'proof');
 
     const { args, functionData, contractAddress } = avmExecution;
-    const bytecode = await this.contractsDb.getBytecode(contractAddress, functionData.selector);
+    let bytecode = await this.contractsDb.getBytecode(contractAddress, functionData.selector);
+    assert(!!bytecode, `Bytecode not found for ${contractAddress}:${functionData.selector}`);
+    // This should be removed once we do bytecode validation.
+    bytecode = await decompressBytecodeIfCompressed(bytecode!);
     // Write call data and bytecode to files.
     await fs.writeFile(
       calldataPath,

package/src/public/hints_builder.ts

@@ -3,7 +3,7 @@ import {
   type Fr,
   type MAX_NEW_NULLIFIERS_PER_TX,
   type MAX_NULLIFIER_NON_EXISTENT_READ_REQUESTS_PER_TX,
-  type MAX_NULLIFIER_READ_REQUESTS_PER_TX,
+  MAX_NULLIFIER_READ_REQUESTS_PER_TX,
   type MAX_PUBLIC_DATA_HINTS,
   type MAX_PUBLIC_DATA_READS_PER_TX,
   type MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX,
@@ -27,11 +27,19 @@ import { type IndexedTreeId, type MerkleTreeOperations } from '@aztec/world-stat
 export class HintsBuilder {
   constructor(private db: MerkleTreeOperations) {}
 
-  getNullifierReadRequestHints(
+  async getNullifierReadRequestHints(
     nullifierReadRequests: Tuple<ScopedReadRequest, typeof MAX_NULLIFIER_READ_REQUESTS_PER_TX>,
     pendingNullifiers: Tuple<Nullifier, typeof MAX_NEW_NULLIFIERS_PER_TX>,
   ) {
-    return buildSiloedNullifierReadRequestHints(this, nullifierReadRequests, pendingNullifiers);
+    return (
+      await buildSiloedNullifierReadRequestHints(
+        this,
+        nullifierReadRequests,
+        pendingNullifiers,
+        MAX_NULLIFIER_READ_REQUESTS_PER_TX,
+        MAX_NULLIFIER_READ_REQUESTS_PER_TX,
+      )
+    ).hints;
   }
 
   getNullifierNonExistentReadRequestHints(

package/src/public/public_processor.ts

@@ -1,7 +1,7 @@
 import {
   type BlockProver,
   type FailedTx,
-  type ProcessReturnValues,
+  NestedProcessReturnValues,
   type ProcessedTx,
   type PublicKernelRequest,
   type SimulationError,
@@ -96,12 +96,12 @@ export class PublicProcessor {
     maxTransactions = txs.length,
     blockProver?: BlockProver,
     txValidator?: TxValidator<ProcessedTx>,
-  ): Promise<[ProcessedTx[], FailedTx[], ProcessReturnValues[]]> {
+  ): Promise<[ProcessedTx[], FailedTx[], NestedProcessReturnValues[]]> {
     // The processor modifies the tx objects in place, so we need to clone them.
     txs = txs.map(tx => Tx.clone(tx));
     const result: ProcessedTx[] = [];
     const failed: FailedTx[] = [];
-    const returns: ProcessReturnValues[] = [];
+    const returns: NestedProcessReturnValues[] = [];
 
     for (const tx of txs) {
       // only process up to the limit of the block
@@ -129,7 +129,7 @@ export class PublicProcessor {
           await blockProver.addNewTx(processedTx);
         }
         result.push(processedTx);
-        returns.push(returnValues);
+        returns.push(returnValues?.[0] ?? new NestedProcessReturnValues([]));
       } catch (err: any) {
         const errorMessage = err instanceof Error ? err.message : 'Unknown error';
         this.log.warn(`Failed to process tx ${tx.getTxHash()}: ${errorMessage}`);
@@ -138,7 +138,7 @@ export class PublicProcessor {
           tx,
           error: err instanceof Error ? err : new Error(errorMessage),
         });
-        returns.push([]);
+        returns.push(new NestedProcessReturnValues([]));
       }
     }
 
@@ -154,8 +154,8 @@ export class PublicProcessor {
     return makeEmptyProcessedTx(this.historicalHeader.clone(), chainId, version);
   }
 
-  private async processTxWithPublicCalls(tx: Tx): Promise<[ProcessedTx, ProcessReturnValues | undefined]> {
-    let returnValues: ProcessReturnValues = undefined;
+  private async processTxWithPublicCalls(tx: Tx): Promise<[ProcessedTx, NestedProcessReturnValues[]]> {
+    let returnValues: NestedProcessReturnValues[] = [];
     const publicRequests: PublicKernelRequest[] = [];
     let phase: AbstractPhaseManager | undefined = PhaseManagerFactory.phaseFromTx(
       tx,

package/src/public/setup_phase_manager.ts

@@ -67,7 +67,7 @@ export class SetupPhaseManager extends AbstractPhaseManager {
       publicKernelOutput,
       publicKernelProof,
       revertReason,
-      returnValues: undefined,
+      returnValues: [],
       gasUsed,
     };
   }