@aztec/simulator 0.44.0 → 0.45.1

package/src/avm/avm_execution_environment.ts

@@ -1,15 +1,15 @@
-import { FunctionSelector, type GasSettings, type GlobalVariables, type Header } from '@aztec/circuits.js';
+import { FunctionSelector, type GlobalVariables, type Header } from '@aztec/circuits.js';
 import { computeVarArgsHash } from '@aztec/circuits.js/hash';
 import { type AztecAddress } from '@aztec/foundation/aztec-address';
 import { Fr } from '@aztec/foundation/fields';
 
 export class AvmContextInputs {
-  static readonly SIZE = 3;
+  static readonly SIZE = 2;
 
-  constructor(private selector: Fr, private argsHash: Fr, private isStaticCall: boolean) {}
+  constructor(private argsHash: Fr, private isStaticCall: boolean) {}
 
   public toFields(): Fr[] {
-    return [this.selector, this.argsHash, new Fr(this.isStaticCall)];
+    return [this.argsHash, new Fr(this.isStaticCall)];
   }
 }
 
@@ -17,38 +17,24 @@ export class AvmContextInputs {
  * Contains variables that remain constant during AVM execution
  * These variables are provided by the public kernel circuit
  */
-// TODO(https://github.com/AztecProtocol/aztec-packages/issues/3992): gas not implemented
 export class AvmExecutionEnvironment {
-  private readonly calldataPrefixLength;
   constructor(
     public readonly address: AztecAddress,
     public readonly storageAddress: AztecAddress,
     public readonly sender: AztecAddress,
-    public readonly feePerL2Gas: Fr,
-    public readonly feePerDaGas: Fr,
+    public readonly functionSelector: FunctionSelector, // may be temporary (#7224)
     public readonly contractCallDepth: Fr,
+    public readonly transactionFee: Fr,
     public readonly header: Header,
     public readonly globals: GlobalVariables,
     public readonly isStaticCall: boolean,
     public readonly isDelegateCall: boolean,
     public readonly calldata: Fr[],
-    public readonly gasSettings: GasSettings,
-    public readonly transactionFee: Fr,
-
-    // Function selector is temporary since eventually public contract bytecode will be one blob
-    // containing all functions, and function selector will become an application-level mechanism
-    // (e.g. first few bytes of calldata + compiler-generated jump table)
-    public readonly temporaryFunctionSelector: FunctionSelector,
   ) {
     // We encode some extra inputs (AvmContextInputs) in calldata.
     // This will have to go once we move away from one proof per call.
-    const inputs = new AvmContextInputs(
-      temporaryFunctionSelector.toField(),
-      computeVarArgsHash(calldata),
-      isStaticCall,
-    ).toFields();
+    const inputs = new AvmContextInputs(computeVarArgsHash(calldata), isStaticCall).toFields();
     this.calldata = [...inputs, ...calldata];
-    this.calldataPrefixLength = inputs.length;
   }
 
   private deriveEnvironmentForNestedCallInternal(
@@ -62,17 +48,14 @@ export class AvmExecutionEnvironment {
       /*address=*/ targetAddress,
       /*storageAddress=*/ targetAddress,
       /*sender=*/ this.address,
-      this.feePerL2Gas,
-      this.feePerDaGas,
+      functionSelector,
       this.contractCallDepth.add(Fr.ONE),
+      this.transactionFee,
       this.header,
       this.globals,
       isStaticCall,
       isDelegateCall,
       calldata,
-      this.gasSettings,
-      this.transactionFee,
-      functionSelector,
     );
   }
 
@@ -114,6 +97,6 @@ export class AvmExecutionEnvironment {
 
   public getCalldataWithoutPrefix(): Fr[] {
     // clip off the first few entries
-    return this.calldata.slice(this.calldataPrefixLength);
+    return this.calldata.slice(AvmContextInputs.SIZE);
   }
 }

package/src/avm/avm_gas.ts

@@ -76,7 +76,7 @@ const BaseGasCosts: Record<Opcode, Gas> = {
   [Opcode.FEEPERL2GAS]: DefaultBaseGasCost,
   [Opcode.FEEPERDAGAS]: DefaultBaseGasCost,
   [Opcode.TRANSACTIONFEE]: DefaultBaseGasCost,
-  [Opcode.CONTRACTCALLDEPTH]: DefaultBaseGasCost,
+  [Opcode.FUNCTIONSELECTOR]: DefaultBaseGasCost,
   [Opcode.CHAINID]: DefaultBaseGasCost,
   [Opcode.VERSION]: DefaultBaseGasCost,
   [Opcode.BLOCKNUMBER]: DefaultBaseGasCost,

package/src/avm/avm_simulator.ts

@@ -2,9 +2,9 @@ import { type DebugLogger, createDebugLogger } from '@aztec/foundation/log';
 
 import { strict as assert } from 'assert';
 
-import { decompressBytecodeIfCompressed, isAvmBytecode } from '../public/transitional_adaptors.js';
 import type { AvmContext } from './avm_context.js';
-import { AvmContractCallResults } from './avm_message_call_result.js';
+import { AvmContractCallResult } from './avm_contract_call_result.js';
+import { decompressBytecodeIfCompressed, isAvmBytecode } from './bytecode_utils.js';
 import {
   AvmExecutionError,
   InvalidProgramCounterError,
@@ -20,18 +20,16 @@ export class AvmSimulator {
   private bytecode: Buffer | undefined;
 
   constructor(private context: AvmContext) {
-    this.log = createDebugLogger(
-      `aztec:avm_simulator:core(f:${context.environment.temporaryFunctionSelector.toString()})`,
-    );
+    this.log = createDebugLogger(`aztec:avm_simulator:core(f:${context.environment.functionSelector.toString()})`);
   }
 
   /**
    * Fetch the bytecode and execute it in the current context.
    */
-  public async execute(): Promise<AvmContractCallResults> {
+  public async execute(): Promise<AvmContractCallResult> {
     const bytecode = await this.context.persistableState.getBytecode(
       this.context.environment.address,
-      this.context.environment.temporaryFunctionSelector,
+      this.context.environment.functionSelector,
     );
 
     // This assumes that we will not be able to send messages to accounts without code
@@ -54,7 +52,7 @@ export class AvmSimulator {
    * Executes the provided bytecode in the current context.
    * This method is useful for testing and debugging.
    */
-  public async executeBytecode(bytecode: Buffer): Promise<AvmContractCallResults> {
+  public async executeBytecode(bytecode: Buffer): Promise<AvmContractCallResult> {
     const decompressedBytecode = await decompressBytecodeIfCompressed(bytecode);
     assert(isAvmBytecode(decompressedBytecode), "AVM simulator can't execute non-AVM bytecode");
 
@@ -66,7 +64,7 @@ export class AvmSimulator {
    * Executes the provided instructions in the current context.
    * This method is useful for testing and debugging.
    */
-  public async executeInstructions(instructions: Instruction[]): Promise<AvmContractCallResults> {
+  public async executeInstructions(instructions: Instruction[]): Promise<AvmContractCallResult> {
     assert(instructions.length > 0);
     const { machineState } = this.context;
     try {
@@ -95,7 +93,7 @@ export class AvmSimulator {
       const output = machineState.getOutput();
       const reverted = machineState.getReverted();
       const revertReason = reverted ? revertReasonFromExplicitRevert(output, this.context) : undefined;
-      const results = new AvmContractCallResults(reverted, output, revertReason);
+      const results = new AvmContractCallResult(reverted, output, revertReason);
       this.log.debug(`Context execution results: ${results.toString()}`);
       // Return results for processing by calling context
       return results;
@@ -108,7 +106,7 @@ export class AvmSimulator {
 
       const revertReason = revertReasonFromExceptionalHalt(err, this.context);
       // Note: "exceptional halts" cannot return data, hence []
-      const results = new AvmContractCallResults(/*reverted=*/ true, /*output=*/ [], revertReason);
+      const results = new AvmContractCallResult(/*reverted=*/ true, /*output=*/ [], revertReason);
       this.log.debug(`Context execution results: ${results.toString()}`);
       // Return results for processing by calling context
       return results;

package/src/avm/bytecode_utils.ts

@@ -0,0 +1,32 @@
+import { promisify } from 'util';
+import { gunzip } from 'zlib';
+
+import { Mov } from '../avm/opcodes/memory.js';
+
+const AVM_MAGIC_SUFFIX = Buffer.from([
+  Mov.opcode, // opcode
+  0x00, // indirect
+  ...Buffer.from('000018ca', 'hex'), // srcOffset
+  ...Buffer.from('000018ca', 'hex'), // dstOffset
+]);
+
+export function markBytecodeAsAvm(bytecode: Buffer): Buffer {
+  return Buffer.concat([bytecode, AVM_MAGIC_SUFFIX]);
+}
+
+// This is just a helper function for the AVM simulator
+export async function decompressBytecodeIfCompressed(bytecode: Buffer): Promise<Buffer> {
+  try {
+    return await promisify(gunzip)(bytecode);
+  } catch {
+    // If the bytecode is not compressed, the gunzip call will throw an error
+    // In this case, we assume the bytecode is not compressed and continue.
+    return Promise.resolve(bytecode);
+  }
+}
+
+export async function isAvmBytecode(bytecode: Buffer): Promise<boolean> {
+  const decompressedBytecode = await decompressBytecodeIfCompressed(bytecode);
+  const magicSize = AVM_MAGIC_SUFFIX.length;
+  return decompressedBytecode.subarray(-magicSize).equals(AVM_MAGIC_SUFFIX);
+}

package/src/avm/errors.ts

@@ -113,7 +113,7 @@ function createRevertReason(message: string, context: AvmContext, nestedError?:
     message,
     /*failingFunction=*/ {
       contractAddress: context.environment.address,
-      functionSelector: context.environment.temporaryFunctionSelector,
+      functionSelector: context.environment.functionSelector,
     },
     /*noirCallStack=*/ [...context.machineState.internalCallStack, context.machineState.pc].map(pc => `0.${pc}`),
     /*options=*/ { cause: nestedError },

package/src/avm/fixtures/index.ts

@@ -1,4 +1,4 @@
-import { GasFees, GasSettings, GlobalVariables, Header } from '@aztec/circuits.js';
+import { GasFees, GlobalVariables, Header } from '@aztec/circuits.js';
 import { FunctionSelector } from '@aztec/foundation/abi';
 import { AztecAddress } from '@aztec/foundation/aztec-address';
 import { EthAddress } from '@aztec/foundation/eth-address';
@@ -72,17 +72,14 @@ export function initExecutionEnvironment(overrides?: Partial<AvmExecutionEnviron
     overrides?.address ?? AztecAddress.zero(),
     overrides?.storageAddress ?? AztecAddress.zero(),
     overrides?.sender ?? AztecAddress.zero(),
-    overrides?.feePerL2Gas ?? Fr.zero(),
-    overrides?.feePerDaGas ?? Fr.zero(),
+    overrides?.functionSelector ?? FunctionSelector.empty(),
     overrides?.contractCallDepth ?? Fr.zero(),
+    overrides?.transactionFee ?? Fr.zero(),
     overrides?.header ?? Header.empty(),
     overrides?.globals ?? GlobalVariables.empty(),
     overrides?.isStaticCall ?? false,
     overrides?.isDelegateCall ?? false,
     overrides?.calldata ?? [],
-    overrides?.gasSettings ?? GasSettings.empty(),
-    overrides?.transactionFee ?? Fr.ZERO,
-    overrides?.temporaryFunctionSelector ?? FunctionSelector.empty(),
   );
 }
 

package/src/avm/journal/journal.ts

@@ -5,8 +5,8 @@ import { SerializableContractInstance } from '@aztec/types/contracts';
 
 import { type TracedContractInstance } from '../../public/side_effect_trace.js';
 import { type PublicSideEffectTraceInterface } from '../../public/side_effect_trace_interface.js';
+import { type AvmContractCallResult } from '../avm_contract_call_result.js';
 import { type AvmExecutionEnvironment } from '../avm_execution_environment.js';
-import { type AvmContractCallResults } from '../avm_message_call_result.js';
 import { type HostStorage } from './host_storage.js';
 import { NullifierManager } from './nullifiers.js';
 import { PublicStorage } from './public_storage.js';
@@ -25,10 +25,11 @@ export class AvmPersistableStateManager {
 
   constructor(
     /** Reference to node storage */
-    private hostStorage: HostStorage,
+    private readonly hostStorage: HostStorage,
     /** Side effect trace */
-    private trace: PublicSideEffectTraceInterface,
+    private readonly trace: PublicSideEffectTraceInterface,
     /** Public storage, including cached writes */
+    // TODO(5818): make private once no longer accessed in executor
     public readonly publicStorage: PublicStorage,
     /** Nullifier set, including cached/recently-emitted nullifiers */
     private readonly nullifiers: NullifierManager,
@@ -197,9 +198,9 @@ export class AvmPersistableStateManager {
    * @param event - log event selector
    * @param log - log contents
    */
-  public writeUnencryptedLog(contractAddress: Fr, event: Fr, log: Fr[]) {
-    this.log.debug(`UnencryptedL2Log(${contractAddress}) += event ${event} with ${log.length} fields.`);
-    this.trace.traceUnencryptedLog(contractAddress, event, log);
+  public writeUnencryptedLog(contractAddress: Fr, log: Fr[]) {
+    this.log.debug(`UnencryptedL2Log(${contractAddress}) += event with ${log.length} fields.`);
+    this.trace.traceUnencryptedLog(contractAddress, log);
   }
 
   /**
@@ -243,21 +244,23 @@ export class AvmPersistableStateManager {
    */
   public async processNestedCall(
     nestedState: AvmPersistableStateManager,
-    success: boolean,
     nestedEnvironment: AvmExecutionEnvironment,
     startGasLeft: Gas,
     endGasLeft: Gas,
     bytecode: Buffer,
-    avmCallResults: AvmContractCallResults,
+    avmCallResults: AvmContractCallResult,
   ) {
-    if (success) {
+    if (!avmCallResults.reverted) {
       this.acceptNestedCallState(nestedState);
     }
     const functionName =
       (await nestedState.hostStorage.contractsDb.getDebugFunctionName(
         nestedEnvironment.address,
-        nestedEnvironment.temporaryFunctionSelector,
-      )) ?? `${nestedEnvironment.address}:${nestedEnvironment.temporaryFunctionSelector}`;
+        nestedEnvironment.functionSelector,
+      )) ?? `${nestedEnvironment.address}:${nestedEnvironment.functionSelector}`;
+
+    this.log.verbose(`[AVM] Calling nested function ${functionName}`);
+
     this.trace.traceNestedCall(
       nestedState.trace,
       nestedEnvironment,

package/src/avm/journal/public_storage.ts

@@ -16,7 +16,7 @@ type PublicStorageReadResult = {
  */
 export class PublicStorage {
   /** Cached storage writes. */
-  private cache: PublicStorageCache;
+  private readonly cache: PublicStorageCache;
 
   constructor(
     /** Reference to node storage. Checked on parent cache-miss. */
@@ -134,7 +134,7 @@ class PublicStorageCache {
    * mapping storage slot to latest staged write value.
    */
   public cachePerContract: Map<bigint, Map<bigint, Fr>> = new Map();
-  // FIXME: storage ^ should be private, but its value is used in tests for "currentStorageValue"
+  // FIXME: storage ^ should be private, but its value is used in commitToDB
 
   /**
    * Read a staged value from storage, if it has been previously written to.

package/src/avm/opcodes/accrued_substate.ts

@@ -217,20 +217,9 @@ export class EmitUnencryptedLog extends Instruction {
   static type: string = 'EMITUNENCRYPTEDLOG';
   static readonly opcode: Opcode = Opcode.EMITUNENCRYPTEDLOG;
   // Informs (de)serialization. See Instruction.deserialize.
-  static readonly wireFormat = [
-    OperandType.UINT8,
-    OperandType.UINT8,
-    OperandType.UINT32,
-    OperandType.UINT32,
-    OperandType.UINT32,
-  ];
+  static readonly wireFormat = [OperandType.UINT8, OperandType.UINT8, OperandType.UINT32, OperandType.UINT32];
 
-  constructor(
-    private indirect: number,
-    private eventSelectorOffset: number,
-    private logOffset: number,
-    private logSizeOffset: number,
-  ) {
+  constructor(private indirect: number, private logOffset: number, private logSizeOffset: number) {
     super();
   }
 
@@ -241,22 +230,20 @@ export class EmitUnencryptedLog extends Instruction {
 
     const memory = context.machineState.memory.track(this.type);
 
-    const [eventSelectorOffset, logOffset, logSizeOffset] = Addressing.fromWire(this.indirect).resolve(
-      [this.eventSelectorOffset, this.logOffset, this.logSizeOffset],
+    const [logOffset, logSizeOffset] = Addressing.fromWire(this.indirect).resolve(
+      [this.logOffset, this.logSizeOffset],
       memory,
     );
-    memory.checkTag(TypeTag.FIELD, eventSelectorOffset);
     memory.checkTag(TypeTag.UINT32, logSizeOffset);
     const logSize = memory.get(logSizeOffset).toNumber();
     memory.checkTagsRange(TypeTag.FIELD, logOffset, logSize);
 
     const contractAddress = context.environment.address;
-    const event = memory.get(eventSelectorOffset).toFr();
 
-    const memoryOperations = { reads: 2 + logSize, indirect: this.indirect };
+    const memoryOperations = { reads: 1 + logSize, indirect: this.indirect };
     context.machineState.consumeGas(this.gasCost(memoryOperations));
     const log = memory.getSlice(logOffset, logSize).map(f => f.toFr());
-    context.persistableState.writeUnencryptedLog(contractAddress, event, log);
+    context.persistableState.writeUnencryptedLog(contractAddress, log);
 
     memory.assert(memoryOperations);
     context.machineState.incrementPc();

package/src/avm/opcodes/environment_getters.ts

@@ -1,6 +1,6 @@
 import type { AvmContext } from '../avm_context.js';
 import type { AvmExecutionEnvironment } from '../avm_execution_environment.js';
-import { Field, type MemoryValue, Uint64 } from '../avm_memory_types.js';
+import { Field, type MemoryValue, Uint32, Uint64 } from '../avm_memory_types.js';
 import { Opcode } from '../serialization/instruction_serialization.js';
 import { GetterInstruction } from './instruction_impl.js';
 
@@ -39,21 +39,12 @@ export class Sender extends EnvironmentGetterInstruction {
   }
 }
 
-export class FeePerL2Gas extends EnvironmentGetterInstruction {
-  static type: string = 'FEEPERL2GAS';
-  static readonly opcode: Opcode = Opcode.FEEPERL2GAS;
-
-  protected getEnvironmentValue(env: AvmExecutionEnvironment) {
-    return new Field(env.feePerL2Gas);
-  }
-}
-
-export class FeePerDAGas extends EnvironmentGetterInstruction {
-  static type: string = 'FEEPERDAGAS';
-  static readonly opcode: Opcode = Opcode.FEEPERDAGAS;
+export class FunctionSelector extends EnvironmentGetterInstruction {
+  static type: string = 'FUNCTIONSELECTOR';
+  static readonly opcode: Opcode = Opcode.FUNCTIONSELECTOR;
 
   protected getEnvironmentValue(env: AvmExecutionEnvironment) {
-    return new Field(env.feePerDaGas);
+    return new Uint32(env.functionSelector.value);
   }
 }
 
@@ -101,3 +92,21 @@ export class Timestamp extends EnvironmentGetterInstruction {
     return new Uint64(env.globals.timestamp.toBigInt());
   }
 }
+
+export class FeePerL2Gas extends EnvironmentGetterInstruction {
+  static type: string = 'FEEPERL2GAS';
+  static readonly opcode: Opcode = Opcode.FEEPERL2GAS;
+
+  protected getEnvironmentValue(env: AvmExecutionEnvironment) {
+    return new Field(env.globals.gasFees.feePerL2Gas);
+  }
+}
+
+export class FeePerDAGas extends EnvironmentGetterInstruction {
+  static type: string = 'FEEPERDAGAS';
+  static readonly opcode: Opcode = Opcode.FEEPERDAGAS;
+
+  protected getEnvironmentValue(env: AvmExecutionEnvironment) {
+    return new Field(env.globals.gasFees.feePerDaGas);
+  }
+}

package/src/avm/opcodes/external_calls.ts

@@ -2,9 +2,9 @@ import { FunctionSelector, Gas } from '@aztec/circuits.js';
 import { padArrayEnd } from '@aztec/foundation/collection';
 
 import type { AvmContext } from '../avm_context.js';
+import { type AvmContractCallResult } from '../avm_contract_call_result.js';
 import { gasLeftToGas } from '../avm_gas.js';
 import { Field, TypeTag, Uint8 } from '../avm_memory_types.js';
-import { type AvmContractCallResults } from '../avm_message_call_result.js';
 import { AvmSimulator } from '../avm_simulator.js';
 import { RethrownError } from '../errors.js';
 import { Opcode, OperandType } from '../serialization/instruction_serialization.js';
@@ -88,7 +88,7 @@ abstract class ExternalCall extends Instruction {
     );
 
     const simulator = new AvmSimulator(nestedContext);
-    const nestedCallResults: AvmContractCallResults = await simulator.execute();
+    const nestedCallResults: AvmContractCallResult = await simulator.execute();
     const success = !nestedCallResults.reverted;
 
     // TRANSITIONAL: We rethrow here so that the MESSAGE gets propagated.
@@ -120,7 +120,6 @@ abstract class ExternalCall extends Instruction {
     // Accept the nested call's state and trace the nested call
     await context.persistableState.processNestedCall(
       /*nestedState=*/ nestedContext.persistableState,
-      /*success=*/ success,
       /*nestedEnvironment=*/ nestedContext.environment,
       /*startGasLeft=*/ Gas.from(allocatedGas),
       /*endGasLeft=*/ Gas.from(nestedContext.machineState.gasLeft),

package/src/avm/serialization/bytecode_serialization.ts

@@ -21,6 +21,7 @@ import {
   FeePerDAGas,
   FeePerL2Gas,
   FieldDiv,
+  FunctionSelector,
   GetContractInstance,
   InternalCall,
   InternalReturn,
@@ -85,16 +86,16 @@ const INSTRUCTION_SET = () =>
     [Address.opcode, Address],
     [StorageAddress.opcode, StorageAddress],
     [Sender.opcode, Sender],
-    [FeePerL2Gas.opcode, FeePerL2Gas],
-    [FeePerDAGas.opcode, FeePerDAGas],
+    [FunctionSelector.opcode, FunctionSelector],
     [TransactionFee.opcode, TransactionFee],
-    //[Contractcalldepth.opcode, Contractcalldepth],
     // Execution Environment - Globals
     [ChainId.opcode, ChainId],
     [Version.opcode, Version],
     [BlockNumber.opcode, BlockNumber],
     [Timestamp.opcode, Timestamp],
     //[Coinbase.opcode, Coinbase],
+    [FeePerL2Gas.opcode, FeePerL2Gas],
+    [FeePerDAGas.opcode, FeePerDAGas],
     //[Blockl2gaslimit.opcode, Blockl2gaslimit],
     //[Blockdagaslimit.opcode, Blockdagaslimit],
     // Execution Environment - Calldata

package/src/avm/serialization/instruction_serialization.ts

@@ -27,15 +27,15 @@ export enum Opcode {
   ADDRESS,
   STORAGEADDRESS,
   SENDER,
-  FEEPERL2GAS,
-  FEEPERDAGAS,
+  FUNCTIONSELECTOR,
   TRANSACTIONFEE,
-  CONTRACTCALLDEPTH,
   CHAINID,
   VERSION,
   BLOCKNUMBER,
   TIMESTAMP,
   COINBASE,
+  FEEPERL2GAS,
+  FEEPERDAGAS,
   BLOCKL2GASLIMIT,
   BLOCKDAGASLIMIT,
   CALLDATACOPY,

package/src/client/client_execution_context.ts

@@ -459,9 +459,9 @@ export class ClientExecutionContext extends ViewDataOracle {
 
   #checkValidStaticCall(childExecutionResult: ExecutionResult) {
     if (
-      childExecutionResult.callStackItem.publicInputs.newNoteHashes.some(item => !item.isEmpty()) ||
-      childExecutionResult.callStackItem.publicInputs.newNullifiers.some(item => !item.isEmpty()) ||
-      childExecutionResult.callStackItem.publicInputs.newL2ToL1Msgs.some(item => !item.isEmpty()) ||
+      childExecutionResult.callStackItem.publicInputs.noteHashes.some(item => !item.isEmpty()) ||
+      childExecutionResult.callStackItem.publicInputs.nullifiers.some(item => !item.isEmpty()) ||
+      childExecutionResult.callStackItem.publicInputs.l2ToL1Msgs.some(item => !item.isEmpty()) ||
       childExecutionResult.callStackItem.publicInputs.encryptedLogsHashes.some(item => !item.isEmpty()) ||
       childExecutionResult.callStackItem.publicInputs.unencryptedLogsHashes.some(item => !item.isEmpty())
     ) {
@@ -678,16 +678,25 @@ export class ClientExecutionContext extends ViewDataOracle {
 
   /**
    * Read the public storage data.
+   * @param contractAddress - The address to read storage from.
    * @param startStorageSlot - The starting storage slot.
+   * @param blockNumber - The block number to read storage at.
    * @param numberOfElements - Number of elements to read from the starting storage slot.
    */
-  public override async storageRead(startStorageSlot: Fr, numberOfElements: number): Promise<Fr[]> {
+  public override async storageRead(
+    contractAddress: Fr,
+    startStorageSlot: Fr,
+    blockNumber: number,
+    numberOfElements: number,
+  ): Promise<Fr[]> {
     const values = [];
     for (let i = 0n; i < numberOfElements; i++) {
       const storageSlot = new Fr(startStorageSlot.value + i);
 
-      const value = await this.aztecNode.getPublicStorageAt(this.callContext.storageContractAddress, storageSlot);
-      this.log.debug(`Oracle storage read: slot=${storageSlot.toString()} value=${value}`);
+      const value = await this.aztecNode.getPublicStorageAt(contractAddress, storageSlot, blockNumber);
+      this.log.debug(
+        `Oracle storage read: slot=${storageSlot.toString()} address-${contractAddress.toString()} value=${value}`,
+      );
 
       values.push(value);
     }

package/src/client/view_data_oracle.ts

@@ -260,16 +260,25 @@ export class ViewDataOracle extends TypedOracle {
 
   /**
    * Read the public storage data.
+   * @param contractAddress - The address to read storage from.
    * @param startStorageSlot - The starting storage slot.
+   * @param blockNumber - The block number to read storage at.
    * @param numberOfElements - Number of elements to read from the starting storage slot.
    */
-  public override async storageRead(startStorageSlot: Fr, numberOfElements: number) {
+  public override async storageRead(
+    contractAddress: Fr,
+    startStorageSlot: Fr,
+    blockNumber: number,
+    numberOfElements: number,
+  ) {
     const values = [];
     for (let i = 0n; i < numberOfElements; i++) {
       const storageSlot = new Fr(startStorageSlot.value + i);
-      const value = await this.aztecNode.getPublicStorageAt(this.contractAddress, storageSlot);
+      const value = await this.aztecNode.getPublicStorageAt(contractAddress, storageSlot, blockNumber);
 
-      this.log.debug(`Oracle storage read: slot=${storageSlot.toString()} value=${value}`);
+      this.log.debug(
+        `Oracle storage read: slot=${storageSlot.toString()} address-${contractAddress.toString()} value=${value}`,
+      );
       values.push(value);
     }
     return values;

package/src/mocks/fixtures.ts

@@ -14,10 +14,10 @@ import { makeAztecAddress, makeSelector } from '@aztec/circuits.js/testing';
 import { FunctionType } from '@aztec/foundation/abi';
 import { padArrayEnd } from '@aztec/foundation/collection';
 
-import { type PublicExecution, type PublicExecutionResult } from '../public/execution.js';
+import { type PublicExecutionRequest, type PublicExecutionResult } from '../public/execution.js';
 
 export class PublicExecutionResultBuilder {
-  private _execution: PublicExecution;
+  private _executionRequest: PublicExecutionRequest;
   private _nestedExecutions: PublicExecutionResult[] = [];
   private _contractStorageUpdateRequests: ContractStorageUpdateRequest[] = [];
   private _contractStorageReads: ContractStorageRead[] = [];
@@ -25,8 +25,8 @@ export class PublicExecutionResultBuilder {
   private _reverted = false;
   private _revertReason: SimulationError | undefined = undefined;
 
-  constructor(execution: PublicExecution) {
-    this._execution = execution;
+  constructor(executionRequest: PublicExecutionRequest) {
+    this._executionRequest = executionRequest;
   }
 
   static fromPublicCallRequest({
@@ -120,7 +120,7 @@ export class PublicExecutionResultBuilder {
 
   build(overrides: Partial<PublicExecutionResult> = {}): PublicExecutionResult {
     return {
-      execution: this._execution,
+      executionRequest: this._executionRequest,
       nestedExecutions: this._nestedExecutions,
       noteHashReadRequests: [],
       nullifierReadRequests: [],
@@ -128,9 +128,9 @@ export class PublicExecutionResultBuilder {
       l1ToL2MsgReadRequests: [],
       contractStorageUpdateRequests: this._contractStorageUpdateRequests,
       returnValues: padArrayEnd(this._returnValues, Fr.ZERO, 4), // TODO(#5450) Need to use the proper return values here
-      newNoteHashes: [],
-      newNullifiers: [],
-      newL2ToL1Messages: [],
+      noteHashes: [],
+      nullifiers: [],
+      l2ToL1Messages: [],
       contractStorageReads: [],
       unencryptedLogsHashes: [],
       unencryptedLogs: UnencryptedFunctionL2Logs.empty(),