@aztec/simulator 0.41.0 → 0.43.0

package/src/acvm/oracle/oracle.ts

@@ -1,4 +1,5 @@
 import { MerkleTreeId, UnencryptedL2Log } from '@aztec/circuit-types';
+import { KeyValidationRequest } from '@aztec/circuits.js';
 import { EventSelector, FunctionSelector } from '@aztec/foundation/abi';
 import { AztecAddress } from '@aztec/foundation/aztec-address';
 import { Fr, Point } from '@aztec/foundation/fields';
@@ -40,12 +41,18 @@ export class Oracle {
     return unpacked.map(toACVMField);
   }
 
-  async getKeyValidationRequest([masterPublicKeyHash]: ACVMField[]): Promise<ACVMField[]> {
-    const { masterPublicKey, appSecretKey } = await this.typedOracle.getKeyValidationRequest(
-      fromACVMField(masterPublicKeyHash),
-    );
+  async getBlockNumber(): Promise<ACVMField> {
+    return toACVMField(await this.typedOracle.getBlockNumber());
+  }
+
+  async getContractAddress(): Promise<ACVMField> {
+    return toACVMField(await this.typedOracle.getContractAddress());
+  }
+
+  async getKeyValidationRequest([pkMHash]: ACVMField[]): Promise<ACVMField[]> {
+    const { pkM, skApp } = await this.typedOracle.getKeyValidationRequest(fromACVMField(pkMHash));
 
-    return [toACVMField(masterPublicKey.x), toACVMField(masterPublicKey.y), toACVMField(appSecretKey)];
+    return [toACVMField(pkM.x), toACVMField(pkM.y), toACVMField(skApp)];
   }
 
   async getContractInstance([address]: ACVMField[]) {
@@ -282,32 +289,77 @@ export class Oracle {
     return newValues.map(toACVMField);
   }
 
-  emitEncryptedLog(encryptedLog: ACVMField[], [counter]: ACVMField[]): void {
+  emitEncryptedEventLog(
+    [contractAddress]: ACVMField[],
+    [randomness]: ACVMField[],
+    encryptedEvent: ACVMField[],
+    [counter]: ACVMField[],
+  ): void {
     // Convert each field to a number and then to a buffer (1 byte is stored in 1 field)
-    const processedInput = Buffer.from(encryptedLog.map(fromACVMField).map(f => f.toNumber()));
-    this.typedOracle.emitEncryptedLog(processedInput, +counter);
+    const processedInput = Buffer.from(encryptedEvent.map(fromACVMField).map(f => f.toNumber()));
+    this.typedOracle.emitEncryptedEventLog(
+      AztecAddress.fromString(contractAddress),
+      Fr.fromString(randomness),
+      processedInput,
+      +counter,
+    );
   }
 
-  emitEncryptedNoteLog([noteHash]: ACVMField[], encryptedNote: ACVMField[], [counter]: ACVMField[]): void {
+  emitEncryptedNoteLog([noteHashCounter]: ACVMField[], encryptedNote: ACVMField[], [counter]: ACVMField[]): void {
     // Convert each field to a number and then to a buffer (1 byte is stored in 1 field)
     const processedInput = Buffer.from(encryptedNote.map(fromACVMField).map(f => f.toNumber()));
-    this.typedOracle.emitEncryptedNoteLog(fromACVMField(noteHash), processedInput, +counter);
+    this.typedOracle.emitEncryptedNoteLog(+noteHashCounter, processedInput, +counter);
+  }
+
+  computeEncryptedEventLog(
+    [contractAddress]: ACVMField[],
+    [randomness]: ACVMField[],
+    [eventTypeId]: ACVMField[],
+    [ovskApp]: ACVMField[],
+    [ovpkMX]: ACVMField[],
+    [ovpkMY]: ACVMField[],
+    [ivpkMX]: ACVMField[],
+    [ivpkMY]: ACVMField[],
+    preimage: ACVMField[],
+  ): ACVMField[] {
+    const ovpkM = new Point(fromACVMField(ovpkMX), fromACVMField(ovpkMY));
+    const ovKeys = new KeyValidationRequest(ovpkM, Fr.fromString(ovskApp));
+    const ivpkM = new Point(fromACVMField(ivpkMX), fromACVMField(ivpkMY));
+    const encLog = this.typedOracle.computeEncryptedEventLog(
+      AztecAddress.fromString(contractAddress),
+      Fr.fromString(randomness),
+      Fr.fromString(eventTypeId),
+      ovKeys,
+      ivpkM,
+      preimage.map(fromACVMField),
+    );
+    const bytes: ACVMField[] = [];
+    encLog.forEach(v => {
+      bytes.push(toACVMField(v));
+    });
+    return bytes;
   }
 
-  computeEncryptedLog(
+  computeEncryptedNoteLog(
     [contractAddress]: ACVMField[],
     [storageSlot]: ACVMField[],
     [noteTypeId]: ACVMField[],
-    [publicKeyX]: ACVMField[],
-    [publicKeyY]: ACVMField[],
+    [ovskApp]: ACVMField[],
+    [ovpkMX]: ACVMField[],
+    [ovpkMY]: ACVMField[],
+    [ivpkMX]: ACVMField[],
+    [ivpkMY]: ACVMField[],
     preimage: ACVMField[],
   ): ACVMField[] {
-    const publicKey = new Point(fromACVMField(publicKeyX), fromACVMField(publicKeyY));
-    const encLog = this.typedOracle.computeEncryptedLog(
+    const ovpkM = new Point(fromACVMField(ovpkMX), fromACVMField(ovpkMY));
+    const ovKeys = new KeyValidationRequest(ovpkM, Fr.fromString(ovskApp));
+    const ivpkM = new Point(fromACVMField(ivpkMX), fromACVMField(ivpkMY));
+    const encLog = this.typedOracle.computeEncryptedNoteLog(
       AztecAddress.fromString(contractAddress),
       Fr.fromString(storageSlot),
       Fr.fromString(noteTypeId),
-      publicKey,
+      ovKeys,
+      ivpkM,
       preimage.map(fromACVMField),
     );
     const bytes: ACVMField[] = [];

package/src/acvm/oracle/typed_oracle.ts

@@ -82,6 +82,14 @@ export abstract class TypedOracle {
     throw new OracleMethodNotAvailableError('unpackReturns');
   }
 
+  getBlockNumber(): Promise<number> {
+    throw new OracleMethodNotAvailableError('getBlockNumber');
+  }
+
+  getContractAddress(): Promise<AztecAddress> {
+    throw new OracleMethodNotAvailableError('getContractAddress');
+  }
+
   getKeyValidationRequest(_pkMHash: Fr): Promise<KeyValidationRequest> {
     throw new OracleMethodNotAvailableError('getKeyValidationRequest');
   }
@@ -176,22 +184,39 @@ export abstract class TypedOracle {
     throw new OracleMethodNotAvailableError('storageWrite');
   }
 
-  emitEncryptedLog(_encryptedNote: Buffer, _counter: number): void {
-    throw new OracleMethodNotAvailableError('emitEncryptedLog');
+  emitEncryptedEventLog(
+    _contractAddress: AztecAddress,
+    _randomness: Fr,
+    _encryptedEvent: Buffer,
+    _counter: number,
+  ): void {
+    throw new OracleMethodNotAvailableError('emitEncryptedEventLog');
   }
 
-  emitEncryptedNoteLog(_noteHash: Fr, _encryptedNote: Buffer, _counter: number): void {
+  emitEncryptedNoteLog(_noteHashCounter: number, _encryptedNote: Buffer, _counter: number): void {
     throw new OracleMethodNotAvailableError('emitEncryptedNoteLog');
   }
 
-  computeEncryptedLog(
+  computeEncryptedEventLog(
+    _contractAddress: AztecAddress,
+    _randomness: Fr,
+    _eventTypeId: Fr,
+    _ovKeys: KeyValidationRequest,
+    _ivpkM: PublicKey,
+    _preimage: Fr[],
+  ): Buffer {
+    throw new OracleMethodNotAvailableError('computeEncryptedEventLog');
+  }
+
+  computeEncryptedNoteLog(
     _contractAddress: AztecAddress,
     _storageSlot: Fr,
     _noteTypeId: Fr,
-    _publicKey: PublicKey,
+    _ovKeys: KeyValidationRequest,
+    _ivpkM: PublicKey,
     _preimage: Fr[],
   ): Buffer {
-    throw new OracleMethodNotAvailableError('computeEncryptedLog');
+    throw new OracleMethodNotAvailableError('computeEncryptedNoteLog');
   }
 
   emitUnencryptedLog(_log: UnencryptedL2Log, _counter: number): void {

package/src/acvm/serialize.ts

@@ -55,7 +55,7 @@ export function toACVMField(
 export function toAcvmEnqueuePublicFunctionResult(item: PublicCallRequest): ACVMField[] {
   const fields = [
     item.contractAddress.toField(),
-    ...item.functionData.toFields(),
+    item.functionSelector.toField(),
     ...item.callContext.toFields(),
     item.getArgsHash(),
   ];

package/src/avm/avm_gas.ts

@@ -49,93 +49,88 @@ export const EmptyGas: Gas = {
 /** Dimensions of gas usage: L1, L2, and DA. */
 export const GasDimensions = ['l2Gas', 'daGas'] as const;
 
-/** Null object to represent a gas cost that's dynamic instead of fixed for a given instruction. */
-export const DynamicGasCost = Symbol('DynamicGasCost');
-
-/** Temporary default gas cost. We should eventually remove all usage of this variable in favor of actual gas for each opcode. */
-const TemporaryDefaultGasCost = { l2Gas: 10, daGas: 0 };
+/** Default gas cost for an opcode. */
+const DefaultBaseGasCost: Gas = { l2Gas: 10, daGas: 0 };
 
 /** Base gas costs for each instruction. Additional gas cost may be added on top due to memory or storage accesses, etc. */
-export const GasCosts: Record<Opcode, Gas | typeof DynamicGasCost> = {
-  [Opcode.ADD]: TemporaryDefaultGasCost,
-  [Opcode.SUB]: TemporaryDefaultGasCost,
-  [Opcode.MUL]: TemporaryDefaultGasCost,
-  [Opcode.DIV]: TemporaryDefaultGasCost,
-  [Opcode.FDIV]: TemporaryDefaultGasCost,
-  [Opcode.EQ]: TemporaryDefaultGasCost,
-  [Opcode.LT]: TemporaryDefaultGasCost,
-  [Opcode.LTE]: TemporaryDefaultGasCost,
-  [Opcode.AND]: TemporaryDefaultGasCost,
-  [Opcode.OR]: TemporaryDefaultGasCost,
-  [Opcode.XOR]: TemporaryDefaultGasCost,
-  [Opcode.NOT]: TemporaryDefaultGasCost,
-  [Opcode.SHL]: TemporaryDefaultGasCost,
-  [Opcode.SHR]: TemporaryDefaultGasCost,
-  [Opcode.CAST]: TemporaryDefaultGasCost,
+const BaseGasCosts: Record<Opcode, Gas> = {
+  [Opcode.ADD]: DefaultBaseGasCost,
+  [Opcode.SUB]: DefaultBaseGasCost,
+  [Opcode.MUL]: DefaultBaseGasCost,
+  [Opcode.DIV]: DefaultBaseGasCost,
+  [Opcode.FDIV]: DefaultBaseGasCost,
+  [Opcode.EQ]: DefaultBaseGasCost,
+  [Opcode.LT]: DefaultBaseGasCost,
+  [Opcode.LTE]: DefaultBaseGasCost,
+  [Opcode.AND]: DefaultBaseGasCost,
+  [Opcode.OR]: DefaultBaseGasCost,
+  [Opcode.XOR]: DefaultBaseGasCost,
+  [Opcode.NOT]: DefaultBaseGasCost,
+  [Opcode.SHL]: DefaultBaseGasCost,
+  [Opcode.SHR]: DefaultBaseGasCost,
+  [Opcode.CAST]: DefaultBaseGasCost,
   // Execution environment
-  [Opcode.ADDRESS]: TemporaryDefaultGasCost,
-  [Opcode.STORAGEADDRESS]: TemporaryDefaultGasCost,
-  [Opcode.SENDER]: TemporaryDefaultGasCost,
-  [Opcode.FEEPERL2GAS]: TemporaryDefaultGasCost,
-  [Opcode.FEEPERDAGAS]: TemporaryDefaultGasCost,
-  [Opcode.TRANSACTIONFEE]: TemporaryDefaultGasCost,
-  [Opcode.CONTRACTCALLDEPTH]: TemporaryDefaultGasCost,
-  [Opcode.CHAINID]: TemporaryDefaultGasCost,
-  [Opcode.VERSION]: TemporaryDefaultGasCost,
-  [Opcode.BLOCKNUMBER]: TemporaryDefaultGasCost,
-  [Opcode.TIMESTAMP]: TemporaryDefaultGasCost,
-  [Opcode.COINBASE]: TemporaryDefaultGasCost,
-  [Opcode.BLOCKL2GASLIMIT]: TemporaryDefaultGasCost,
-  [Opcode.BLOCKDAGASLIMIT]: TemporaryDefaultGasCost,
-  [Opcode.CALLDATACOPY]: TemporaryDefaultGasCost,
+  [Opcode.ADDRESS]: DefaultBaseGasCost,
+  [Opcode.STORAGEADDRESS]: DefaultBaseGasCost,
+  [Opcode.SENDER]: DefaultBaseGasCost,
+  [Opcode.FEEPERL2GAS]: DefaultBaseGasCost,
+  [Opcode.FEEPERDAGAS]: DefaultBaseGasCost,
+  [Opcode.TRANSACTIONFEE]: DefaultBaseGasCost,
+  [Opcode.CONTRACTCALLDEPTH]: DefaultBaseGasCost,
+  [Opcode.CHAINID]: DefaultBaseGasCost,
+  [Opcode.VERSION]: DefaultBaseGasCost,
+  [Opcode.BLOCKNUMBER]: DefaultBaseGasCost,
+  [Opcode.TIMESTAMP]: DefaultBaseGasCost,
+  [Opcode.COINBASE]: DefaultBaseGasCost,
+  [Opcode.BLOCKL2GASLIMIT]: DefaultBaseGasCost,
+  [Opcode.BLOCKDAGASLIMIT]: DefaultBaseGasCost,
+  [Opcode.CALLDATACOPY]: DefaultBaseGasCost,
   // Gas
-  [Opcode.L2GASLEFT]: TemporaryDefaultGasCost,
-  [Opcode.DAGASLEFT]: TemporaryDefaultGasCost,
+  [Opcode.L2GASLEFT]: DefaultBaseGasCost,
+  [Opcode.DAGASLEFT]: DefaultBaseGasCost,
   // Control flow
-  [Opcode.JUMP]: TemporaryDefaultGasCost,
-  [Opcode.JUMPI]: TemporaryDefaultGasCost,
-  [Opcode.INTERNALCALL]: TemporaryDefaultGasCost,
-  [Opcode.INTERNALRETURN]: TemporaryDefaultGasCost,
+  [Opcode.JUMP]: DefaultBaseGasCost,
+  [Opcode.JUMPI]: DefaultBaseGasCost,
+  [Opcode.INTERNALCALL]: DefaultBaseGasCost,
+  [Opcode.INTERNALRETURN]: DefaultBaseGasCost,
   // Memory
-  [Opcode.SET]: TemporaryDefaultGasCost,
-  [Opcode.MOV]: TemporaryDefaultGasCost,
-  [Opcode.CMOV]: TemporaryDefaultGasCost,
+  [Opcode.SET]: DefaultBaseGasCost,
+  [Opcode.MOV]: DefaultBaseGasCost,
+  [Opcode.CMOV]: DefaultBaseGasCost,
   // World state
-  [Opcode.SLOAD]: TemporaryDefaultGasCost,
-  [Opcode.SSTORE]: TemporaryDefaultGasCost,
-  [Opcode.NOTEHASHEXISTS]: TemporaryDefaultGasCost,
-  [Opcode.EMITNOTEHASH]: TemporaryDefaultGasCost,
-  [Opcode.NULLIFIEREXISTS]: TemporaryDefaultGasCost,
-  [Opcode.EMITNULLIFIER]: TemporaryDefaultGasCost,
-  [Opcode.L1TOL2MSGEXISTS]: TemporaryDefaultGasCost,
-  [Opcode.HEADERMEMBER]: TemporaryDefaultGasCost,
-  [Opcode.EMITUNENCRYPTEDLOG]: TemporaryDefaultGasCost,
-  [Opcode.SENDL2TOL1MSG]: TemporaryDefaultGasCost,
-  [Opcode.GETCONTRACTINSTANCE]: TemporaryDefaultGasCost,
+  [Opcode.SLOAD]: DefaultBaseGasCost,
+  [Opcode.SSTORE]: DefaultBaseGasCost,
+  [Opcode.NOTEHASHEXISTS]: DefaultBaseGasCost,
+  [Opcode.EMITNOTEHASH]: DefaultBaseGasCost,
+  [Opcode.NULLIFIEREXISTS]: DefaultBaseGasCost,
+  [Opcode.EMITNULLIFIER]: DefaultBaseGasCost,
+  [Opcode.L1TOL2MSGEXISTS]: DefaultBaseGasCost,
+  [Opcode.HEADERMEMBER]: DefaultBaseGasCost,
+  [Opcode.EMITUNENCRYPTEDLOG]: DefaultBaseGasCost,
+  [Opcode.SENDL2TOL1MSG]: DefaultBaseGasCost,
+  [Opcode.GETCONTRACTINSTANCE]: DefaultBaseGasCost,
   // External calls
-  [Opcode.CALL]: TemporaryDefaultGasCost,
-  [Opcode.STATICCALL]: TemporaryDefaultGasCost,
-  [Opcode.DELEGATECALL]: TemporaryDefaultGasCost,
-  [Opcode.RETURN]: TemporaryDefaultGasCost,
-  [Opcode.REVERT]: TemporaryDefaultGasCost,
+  [Opcode.CALL]: DefaultBaseGasCost,
+  [Opcode.STATICCALL]: DefaultBaseGasCost,
+  [Opcode.DELEGATECALL]: DefaultBaseGasCost,
+  [Opcode.RETURN]: DefaultBaseGasCost,
+  [Opcode.REVERT]: DefaultBaseGasCost,
   // Misc
-  [Opcode.DEBUGLOG]: TemporaryDefaultGasCost,
+  [Opcode.DEBUGLOG]: DefaultBaseGasCost,
   // Gadgets
-  [Opcode.KECCAK]: TemporaryDefaultGasCost,
-  [Opcode.POSEIDON2]: TemporaryDefaultGasCost,
-  [Opcode.SHA256]: TemporaryDefaultGasCost, // temp - may be removed, but alot of contracts rely on i: TemporaryDefaultGasCost,
-  [Opcode.PEDERSEN]: TemporaryDefaultGasCost, // temp - may be removed, but alot of contracts rely on i: TemporaryDefaultGasCost,t
+  [Opcode.KECCAK]: DefaultBaseGasCost,
+  [Opcode.POSEIDON2]: DefaultBaseGasCost,
+  [Opcode.SHA256]: DefaultBaseGasCost,
+  [Opcode.PEDERSEN]: DefaultBaseGasCost,
+  [Opcode.ECADD]: DefaultBaseGasCost,
+  [Opcode.MSM]: DefaultBaseGasCost,
   // Conversions
-  [Opcode.TORADIXLE]: TemporaryDefaultGasCost,
+  [Opcode.TORADIXLE]: DefaultBaseGasCost,
 };
 
-/** Returns the fixed base gas cost for a given opcode, or throws if set to dynamic. */
+/** Returns the fixed base gas cost for a given opcode. */
 export function getBaseGasCost(opcode: Opcode): Gas {
-  const cost = GasCosts[opcode];
-  if (cost === DynamicGasCost) {
-    throw new Error(`Opcode ${Opcode[opcode]} has dynamic gas cost`);
-  }
-  return cost;
+  return BaseGasCosts[opcode];
 }
 
 /** Returns the gas cost associated with the memory operations performed. */

package/src/avm/avm_memory_types.ts

@@ -298,9 +298,7 @@ export class TaggedMemory implements TaggedMemoryInterface {
   }
 
   public checkIsValidMemoryOffsetTag(offset: number) {
-    if (this.getTag(offset) > TypeTag.UINT64) {
-      throw TagCheckError.forOffset(offset, TypeTag[this.getTag(offset)], 'UINT64');
-    }
+    this.checkTag(TypeTag.UINT32, offset);
   }
 
   public static checkIsIntegralTag(tag: TypeTag) {

package/src/avm/avm_simulator.ts

@@ -17,6 +17,7 @@ import { decodeFromBytecode } from './serialization/bytecode_serialization.js';
 
 export class AvmSimulator {
   private log: DebugLogger;
+  private bytecode: Buffer | undefined;
 
   constructor(private context: AvmContext) {
     this.log = createDebugLogger(
@@ -43,6 +44,13 @@ export class AvmSimulator {
     return await this.executeBytecode(bytecode);
   }
 
+  /**
+   * Return the bytecode used for execution, if any.
+   */
+  public getBytecode(): Buffer | undefined {
+    return this.bytecode;
+  }
+
   /**
    * Executes the provided bytecode in the current context.
    * This method is useful for testing and debugging.
@@ -51,6 +59,7 @@ export class AvmSimulator {
     const decompressedBytecode = await decompressBytecodeIfCompressed(bytecode);
     assert(isAvmBytecode(decompressedBytecode), "AVM simulator can't execute non-AVM bytecode");
 
+    this.bytecode = decompressedBytecode;
     return await this.executeInstructions(decodeFromBytecode(decompressedBytecode));
   }
 

package/src/avm/fixtures/index.ts

@@ -3,7 +3,10 @@ import { FunctionSelector } from '@aztec/foundation/abi';
 import { AztecAddress } from '@aztec/foundation/aztec-address';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { Fr } from '@aztec/foundation/fields';
+import { AvmTestContractArtifact } from '@aztec/noir-contracts.js';
+import { SerializableContractInstance } from '@aztec/types/contracts';
 
+import { strict as assert } from 'assert';
 import { mock } from 'jest-mock-extended';
 import merge from 'lodash.merge';
 
@@ -14,6 +17,7 @@ import { AvmMachineState } from '../avm_machine_state.js';
 import { Field, Uint8 } from '../avm_memory_types.js';
 import { HostStorage } from '../journal/host_storage.js';
 import { AvmPersistableStateManager } from '../journal/journal.js';
+import { type TracedContractInstance } from '../journal/trace_types.js';
 
 /**
  * Create a new AVM context with default values.
@@ -125,3 +129,23 @@ export function randomMemoryBytes(length: number): Uint8[] {
 export function randomMemoryFields(length: number): Field[] {
   return [...Array(length)].map(_ => new Field(Fr.random()));
 }
+
+export function getAvmTestContractBytecode(functionName: string): Buffer {
+  const artifact = AvmTestContractArtifact.functions.find(f => f.name === functionName)!;
+  assert(
+    !!artifact?.bytecode,
+    `No bytecode found for function ${functionName}. Try re-running bootstrap.sh on the repository root.`,
+  );
+  return artifact.bytecode;
+}
+
+export function randomTracedContractInstance(): TracedContractInstance {
+  const instance = SerializableContractInstance.random();
+  const address = AztecAddress.random();
+  return { exists: true, ...instance, address };
+}
+
+export function emptyTracedContractInstance(withAddress?: AztecAddress): TracedContractInstance {
+  const instance = SerializableContractInstance.empty().withAddress(withAddress ?? AztecAddress.zero());
+  return { exists: false, ...instance };
+}

package/src/avm/index.ts

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

package/src/avm/journal/host_storage.ts

@@ -1,4 +1,4 @@
-import { type CommitmentsDB, type PublicContractsDB, type PublicStateDB } from '../../public/db.js';
+import { type CommitmentsDB, type PublicContractsDB, type PublicStateDB } from '../../public/db_interfaces.js';
 
 /**
  * Host storage

package/src/avm/journal/journal.ts

@@ -14,6 +14,7 @@ import {
 import { EventSelector } from '@aztec/foundation/abi';
 import { Fr } from '@aztec/foundation/fields';
 import { type DebugLogger, createDebugLogger } from '@aztec/foundation/log';
+import { SerializableContractInstance } from '@aztec/types/contracts';
 
 import { type PublicExecutionResult } from '../../index.js';
 import { type HostStorage } from './host_storage.js';
@@ -21,6 +22,7 @@ import { Nullifiers } from './nullifiers.js';
 import { PublicStorage } from './public_storage.js';
 import { WorldStateAccessTrace } from './trace.js';
 import {
+  type TracedContractInstance,
   type TracedL1toL2MessageCheck,
   type TracedNoteHash,
   type TracedNoteHashCheck,
@@ -55,9 +57,11 @@ export type JournalData = {
 };
 
 // TRANSITIONAL: This should be removed once the kernel handles and entire enqueued call per circuit
-type PartialPublicExecutionResult = {
+export type PartialPublicExecutionResult = {
+  noteHashReadRequests: ReadRequest[];
   nullifierReadRequests: ReadRequest[];
   nullifierNonExistentReadRequests: ReadRequest[];
+  l1ToL2MsgReadRequests: ReadRequest[];
   newNoteHashes: NoteHash[];
   newL2ToL1Messages: L2ToL1Message[];
   startSideEffectCounter: number;
@@ -108,8 +112,10 @@ export class AvmPersistableStateManager {
     this.trace = new WorldStateAccessTrace(parent?.trace);
 
     this.transitionalExecutionResult = {
+      noteHashReadRequests: [],
       nullifierReadRequests: [],
       nullifierNonExistentReadRequests: [],
+      l1ToL2MsgReadRequests: [],
       newNoteHashes: [],
       newL2ToL1Messages: [],
       startSideEffectCounter: this.trace.accessCounter,
@@ -143,15 +149,6 @@ export class AvmPersistableStateManager {
     this.publicStorage.write(storageAddress, slot, value);
 
     // TRANSITIONAL: This should be removed once the kernel handles and entire enqueued call per circuit
-    // The current info to the kernel clears any previous read or write request.
-    this.transitionalExecutionResult.contractStorageReads =
-      this.transitionalExecutionResult.contractStorageReads.filter(
-        read => !read.storageSlot.equals(slot) || !read.contractAddress!.equals(storageAddress),
-      );
-    this.transitionalExecutionResult.contractStorageUpdateRequests =
-      this.transitionalExecutionResult.contractStorageUpdateRequests.filter(
-        update => !update.storageSlot.equals(slot) || !update.contractAddress!.equals(storageAddress),
-      );
     this.transitionalExecutionResult.contractStorageUpdateRequests.push(
       new ContractStorageUpdateRequest(slot, value, this.trace.accessCounter, storageAddress),
     );
@@ -174,17 +171,9 @@ export class AvmPersistableStateManager {
     );
 
     // TRANSITIONAL: This should be removed once the kernel handles and entire enqueued call per circuit
-    // The current info to the kernel kernel does not consider cached reads.
-    if (!cached) {
-      // The current info to the kernel removes any previous reads to the same slot.
-      this.transitionalExecutionResult.contractStorageReads =
-        this.transitionalExecutionResult.contractStorageReads.filter(
-          read => !read.storageSlot.equals(slot) || !read.contractAddress!.equals(storageAddress),
-        );
-      this.transitionalExecutionResult.contractStorageReads.push(
-        new ContractStorageRead(slot, value, this.trace.accessCounter, storageAddress),
-      );
-    }
+    this.transitionalExecutionResult.contractStorageReads.push(
+      new ContractStorageRead(slot, value, this.trace.accessCounter, storageAddress),
+    );
 
     // We want to keep track of all performed reads (even reverted ones)
     this.trace.tracePublicStorageRead(storageAddress, slot, value, exists, cached);
@@ -204,6 +193,10 @@ export class AvmPersistableStateManager {
     const gotLeafIndex = await this.hostStorage.commitmentsDb.getCommitmentIndex(noteHash);
     const exists = gotLeafIndex === leafIndex.toBigInt();
     this.log.debug(`noteHashes(${storageAddress})@${noteHash} ?? leafIndex: ${leafIndex}, exists: ${exists}.`);
+
+    // TODO: include exists here also - This can for sure come from the trace???
+    this.transitionalExecutionResult.noteHashReadRequests.push(new ReadRequest(noteHash, this.trace.accessCounter));
+
     this.trace.traceNoteHashCheck(storageAddress, noteHash, exists, leafIndex);
     return Promise.resolve(exists);
   }
@@ -275,6 +268,9 @@ export class AvmPersistableStateManager {
     this.log.debug(
       `l1ToL2Messages(@${msgLeafIndex}) ?? exists: ${exists}, expected: ${msgHash}, found: ${valueAtIndex}.`,
     );
+
+    this.transitionalExecutionResult.l1ToL2MsgReadRequests.push(new ReadRequest(msgHash, this.trace.accessCounter));
+
     this.trace.traceL1ToL2MessageCheck(msgHash, msgLeafIndex, exists);
     return Promise.resolve(exists);
   }
@@ -308,7 +304,8 @@ export class AvmPersistableStateManager {
     this.transitionalExecutionResult.allUnencryptedLogs.push(ulog);
     // this duplicates exactly what happens in the trace just for the purpose of transitional integration with the kernel
     this.transitionalExecutionResult.unencryptedLogsHashes.push(
-      new LogHash(logHash, this.trace.accessCounter, new Fr(ulog.length)),
+      // TODO(6578): explain magic number 4 here
+      new LogHash(logHash, this.trace.accessCounter, new Fr(ulog.length + 4)),
     );
     // TODO(6206): likely need to track this here and not just in the transitional logic.
 
@@ -317,6 +314,19 @@ export class AvmPersistableStateManager {
     this.trace.traceNewLog(logHash);
   }
 
+  public async getContractInstance(contractAddress: Fr): Promise<TracedContractInstance> {
+    let exists = true;
+    const aztecAddress = AztecAddress.fromField(contractAddress);
+    let instance = await this.hostStorage.contractsDb.getContractInstance(aztecAddress);
+    if (instance === undefined) {
+      instance = SerializableContractInstance.empty().withAddress(aztecAddress);
+      exists = false;
+    }
+    const tracedInstance = { ...instance, exists };
+    this.trace.traceGetContractInstance(tracedInstance);
+    return Promise.resolve(tracedInstance);
+  }
+
   /**
    * Accept nested world state modifications, merging in its trace and accrued substate
    */

package/src/avm/journal/trace.ts

@@ -1,6 +1,7 @@
 import { Fr } from '@aztec/foundation/fields';
 
 import {
+  type TracedContractInstance,
   type TracedL1toL2MessageCheck,
   type TracedNoteHash,
   type TracedNoteHashCheck,
@@ -23,6 +24,7 @@ export class WorldStateAccessTrace {
   public newNullifiers: TracedNullifier[] = [];
   public l1ToL2MessageChecks: TracedL1toL2MessageCheck[] = [];
   public newLogsHashes: TracedUnencryptedL2Log[] = [];
+  public gotContractInstances: TracedContractInstance[] = [];
 
   //public contractCalls: TracedContractCall[] = [];
   //public archiveChecks: TracedArchiveLeafCheck[] = [];
@@ -131,6 +133,7 @@ export class WorldStateAccessTrace {
       leafIndex: msgLeafIndex,
       msgHash: msgHash,
       exists: exists,
+      counter: new Fr(this.accessCounter),
       //endLifetime: Fr.ZERO, // FIXME
     };
     this.l1ToL2MessageChecks.push(traced);
@@ -146,6 +149,11 @@ export class WorldStateAccessTrace {
     this.incrementAccessCounter();
   }
 
+  public traceGetContractInstance(instance: TracedContractInstance) {
+    this.gotContractInstances.push(instance);
+    this.incrementAccessCounter();
+  }
+
   private incrementAccessCounter() {
     this.accessCounter++;
   }
@@ -166,6 +174,7 @@ export class WorldStateAccessTrace {
     this.newNullifiers.push(...incomingTrace.newNullifiers);
     this.l1ToL2MessageChecks.push(...incomingTrace.l1ToL2MessageChecks);
     this.newLogsHashes.push(...incomingTrace.newLogsHashes);
+    this.gotContractInstances.push(...incomingTrace.gotContractInstances);
     // it is assumed that the incoming trace was initialized with this as parent, so accept counter
     this.accessCounter = incomingTrace.accessCounter;
   }

package/src/avm/journal/trace_types.ts

@@ -1,4 +1,5 @@
 import { type Fr } from '@aztec/foundation/fields';
+import { type ContractInstanceWithAddress } from '@aztec/types/contracts';
 
 //export type TracedContractCall = {
 //  callPointer: Fr;
@@ -71,6 +72,7 @@ export type TracedL1toL2MessageCheck = {
   leafIndex: Fr;
   msgHash: Fr;
   exists: boolean;
+  counter: Fr;
   //endLifetime: Fr;
 };
 
@@ -85,3 +87,5 @@ export type TracedUnencryptedL2Log = {
 //  leafIndex: Fr;
 //  leaf: Fr;
 //};
+
+export type TracedContractInstance = { exists: boolean } & ContractInstanceWithAddress;