@aztec/simulator 0.40.1 → 0.42.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,15 +41,18 @@ export class Oracle {
     return unpacked.map(toACVMField);
   }
 
-  async getNullifierKeys([accountAddress]: ACVMField[]): Promise<ACVMField[]> {
-    const { masterNullifierPublicKey, appNullifierSecretKey } = await this.typedOracle.getNullifierKeys(
-      fromACVMField(accountAddress),
-    );
-    return [
-      toACVMField(masterNullifierPublicKey.x),
-      toACVMField(masterNullifierPublicKey.y),
-      toACVMField(appNullifierSecretKey),
-    ];
+  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(pkM.x), toACVMField(pkM.y), toACVMField(skApp)];
   }
 
   async getContractInstance([address]: ACVMField[]) {
@@ -286,32 +290,54 @@ export class Oracle {
   }
 
   emitEncryptedLog(
+    [contractAddress]: ACVMField[],
+    [randomness]: ACVMField[],
+    encryptedLog: 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(
+      AztecAddress.fromString(contractAddress),
+      Fr.fromString(randomness),
+      processedInput,
+      +counter,
+    );
+  }
+
+  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(+noteHashCounter, processedInput, +counter);
+  }
+
+  computeEncryptedLog(
     [contractAddress]: ACVMField[],
     [storageSlot]: ACVMField[],
     [noteTypeId]: ACVMField[],
-    [publicKeyX]: ACVMField[],
-    [publicKeyY]: ACVMField[],
-    log: ACVMField[],
-    [counter]: 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.emitEncryptedLog(
+    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.computeEncryptedLog(
       AztecAddress.fromString(contractAddress),
       Fr.fromString(storageSlot),
       Fr.fromString(noteTypeId),
-      publicKey,
-      log.map(fromACVMField),
-      +counter,
+      ovKeys,
+      ivpkM,
+      preimage.map(fromACVMField),
     );
-    // TODO(1139): We should encrypt in the circuit, but instead we inject here
-    // encryption output is 112 + 32 * (N + 3) bytes, for log len N
-    // so split into N + 7 fields (gross but avoids 300+ ACVMFields)
-    const encLogFields = [];
-    for (let i = 0; i < Math.ceil(encLog.length / 31); i++) {
-      encLogFields.push(toACVMField(encLog.subarray(31 * i, Math.min(31 * (i + 1), encLog.length))));
-    }
-
-    return encLogFields;
+    const bytes: ACVMField[] = [];
+    encLog.forEach(v => {
+      bytes.push(toACVMField(v));
+    });
+    return bytes;
   }
 
   emitUnencryptedLog(

package/src/acvm/oracle/typed_oracle.ts

@@ -11,6 +11,7 @@ import {
 } from '@aztec/circuit-types';
 import {
   type Header,
+  type KeyValidationRequest,
   type L1_TO_L2_MSG_TREE_HEIGHT,
   type PrivateCallStackItem,
   type PublicCallRequest,
@@ -20,14 +21,6 @@ import { type AztecAddress } from '@aztec/foundation/aztec-address';
 import { Fr } from '@aztec/foundation/fields';
 import { type ContractInstance } from '@aztec/types/contracts';
 
-/** Nullifier keys which both correspond to the same master nullifier secret key. */
-export interface NullifierKeys {
-  /** Master nullifier public key. */
-  masterNullifierPublicKey: PublicKey;
-  /** App nullifier secret key. */
-  appNullifierSecretKey: Fr;
-}
-
 /**
  * Information about a note needed during execution.
  */
@@ -89,8 +82,16 @@ export abstract class TypedOracle {
     throw new OracleMethodNotAvailableError('unpackReturns');
   }
 
-  getNullifierKeys(_accountAddress: AztecAddress): Promise<NullifierKeys> {
-    throw new OracleMethodNotAvailableError('getNullifierKeys');
+  getBlockNumber(): Promise<number> {
+    throw new OracleMethodNotAvailableError('getBlockNumber');
+  }
+
+  getContractAddress(): Promise<AztecAddress> {
+    throw new OracleMethodNotAvailableError('getContractAddress');
+  }
+
+  getKeyValidationRequest(_pkMHash: Fr): Promise<KeyValidationRequest> {
+    throw new OracleMethodNotAvailableError('getKeyValidationRequest');
   }
 
   getContractInstance(_address: AztecAddress): Promise<ContractInstance> {
@@ -124,7 +125,7 @@ export abstract class TypedOracle {
     throw new OracleMethodNotAvailableError('getHeader');
   }
 
-  getCompleteAddress(_address: AztecAddress): Promise<CompleteAddress> {
+  getCompleteAddress(_account: AztecAddress): Promise<CompleteAddress> {
     throw new OracleMethodNotAvailableError('getCompleteAddress');
   }
 
@@ -183,15 +184,23 @@ export abstract class TypedOracle {
     throw new OracleMethodNotAvailableError('storageWrite');
   }
 
-  emitEncryptedLog(
+  emitEncryptedLog(_contractAddress: AztecAddress, _randomness: Fr, _encryptedNote: Buffer, _counter: number): void {
+    throw new OracleMethodNotAvailableError('emitEncryptedLog');
+  }
+
+  emitEncryptedNoteLog(_noteHashCounter: number, _encryptedNote: Buffer, _counter: number): void {
+    throw new OracleMethodNotAvailableError('emitEncryptedNoteLog');
+  }
+
+  computeEncryptedLog(
     _contractAddress: AztecAddress,
     _storageSlot: Fr,
     _noteTypeId: Fr,
-    _publicKey: PublicKey,
-    _log: Fr[],
-    _counter: number,
+    _ovKeys: KeyValidationRequest,
+    _ivpkM: PublicKey,
+    _preimage: Fr[],
   ): Buffer {
-    throw new OracleMethodNotAvailableError('emitEncryptedLog');
+    throw new OracleMethodNotAvailableError('computeEncryptedLog');
   }
 
   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_execution_environment.ts

@@ -1,15 +1,15 @@
 import { FunctionSelector, type GasSettings, type GlobalVariables, type Header } from '@aztec/circuits.js';
 import { computeVarArgsHash } from '@aztec/circuits.js/hash';
 import { type AztecAddress } from '@aztec/foundation/aztec-address';
-import { type Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/fields';
 
 export class AvmContextInputs {
-  static readonly SIZE = 2;
+  static readonly SIZE = 3;
 
-  constructor(private selector: Fr, private argsHash: Fr) {}
+  constructor(private selector: Fr, private argsHash: Fr, private isStaticCall: boolean) {}
 
   public toFields(): Fr[] {
-    return [this.selector, this.argsHash];
+    return [this.selector, this.argsHash, new Fr(this.isStaticCall)];
   }
 }
 
@@ -41,7 +41,11 @@ export class AvmExecutionEnvironment {
   ) {
     // 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));
+    const inputs = new AvmContextInputs(
+      temporaryFunctionSelector.toField(),
+      computeVarArgsHash(calldata),
+      isStaticCall,
+    );
     this.calldata = [...inputs.toFields(), ...calldata];
   }
 

package/src/avm/avm_gas.ts

@@ -49,93 +49,86 @@ 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,
   // 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_simulator.ts

@@ -2,7 +2,7 @@ import { type DebugLogger, createDebugLogger } from '@aztec/foundation/log';
 
 import { strict as assert } from 'assert';
 
-import { isAvmBytecode } from '../public/transitional_adaptors.js';
+import { decompressBytecodeIfCompressed, isAvmBytecode } from '../public/transitional_adaptors.js';
 import type { AvmContext } from './avm_context.js';
 import { AvmContractCallResults } from './avm_message_call_result.js';
 import {
@@ -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(
@@ -39,17 +40,27 @@ export class AvmSimulator {
     if (!bytecode) {
       throw new NoBytecodeForContractError(this.context.environment.address);
     }
-    assert(isAvmBytecode(bytecode), "AVM simulator can't execute non-AVM bytecode");
 
     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.
    */
   public async executeBytecode(bytecode: Buffer): Promise<AvmContractCallResults> {
-    return await this.executeInstructions(decodeFromBytecode(bytecode));
+    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/errors.ts

@@ -68,6 +68,16 @@ export class OutOfGasError extends AvmExecutionError {
   }
 }
 
+/**
+ * Error is thrown when a static call attempts to alter some state
+ */
+export class StaticCallAlterationError extends InstructionExecutionError {
+  constructor() {
+    super('Static call cannot update the state, emit L2->L1 messages or generate logs');
+    this.name = 'StaticCallAlterationError';
+  }
+}
+
 /**
  * Error thrown to propagate a nested call's revert.
  * @param message - the error's message

package/src/avm/fixtures/index.ts

@@ -3,7 +3,9 @@ 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 { AvmNestedCallsTestContractArtifact, AvmTestContractArtifact } from '@aztec/noir-contracts.js';
 
+import { strict as assert } from 'assert';
 import { mock } from 'jest-mock-extended';
 import merge from 'lodash.merge';
 
@@ -90,8 +92,8 @@ export function initGlobalVariables(overrides?: Partial<GlobalVariables>): Globa
  */
 export function initMachineState(overrides?: Partial<AvmMachineState>): AvmMachineState {
   return AvmMachineState.fromState({
-    l2GasLeft: overrides?.l2GasLeft ?? 100e6,
-    daGasLeft: overrides?.daGasLeft ?? 100e6,
+    l2GasLeft: overrides?.l2GasLeft ?? 1e8,
+    daGasLeft: overrides?.daGasLeft ?? 1e8,
   });
 }
 
@@ -125,3 +127,21 @@ 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 getAvmNestedCallsTestContractBytecode(functionName: string): Buffer {
+  const artifact = AvmNestedCallsTestContractArtifact.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;
+}

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

@@ -6,10 +6,10 @@ import {
   ContractStorageUpdateRequest,
   EthAddress,
   L2ToL1Message,
+  LogHash,
   NoteHash,
   Nullifier,
   ReadRequest,
-  SideEffect,
 } from '@aztec/circuits.js';
 import { EventSelector } from '@aztec/foundation/abi';
 import { Fr } from '@aztec/foundation/fields';
@@ -56,17 +56,18 @@ export type JournalData = {
 
 // TRANSITIONAL: This should be removed once the kernel handles and entire enqueued call per circuit
 type PartialPublicExecutionResult = {
+  noteHashReadRequests: ReadRequest[];
   nullifierReadRequests: ReadRequest[];
   nullifierNonExistentReadRequests: ReadRequest[];
+  l1ToL2MsgReadRequests: ReadRequest[];
   newNoteHashes: NoteHash[];
   newL2ToL1Messages: L2ToL1Message[];
   startSideEffectCounter: number;
   newNullifiers: Nullifier[];
   contractStorageReads: ContractStorageRead[];
   contractStorageUpdateRequests: ContractStorageUpdateRequest[];
-  unencryptedLogsHashes: SideEffect[];
+  unencryptedLogsHashes: LogHash[];
   unencryptedLogs: UnencryptedL2Log[];
-  unencryptedLogPreimagesLength: Fr;
   allUnencryptedLogs: UnencryptedL2Log[];
   nestedExecutions: PublicExecutionResult[];
 };
@@ -109,8 +110,10 @@ export class AvmPersistableStateManager {
     this.trace = new WorldStateAccessTrace(parent?.trace);
 
     this.transitionalExecutionResult = {
+      noteHashReadRequests: [],
       nullifierReadRequests: [],
       nullifierNonExistentReadRequests: [],
+      l1ToL2MsgReadRequests: [],
       newNoteHashes: [],
       newL2ToL1Messages: [],
       startSideEffectCounter: this.trace.accessCounter,
@@ -119,8 +122,6 @@ export class AvmPersistableStateManager {
       contractStorageUpdateRequests: [],
       unencryptedLogsHashes: [],
       unencryptedLogs: [],
-      // The length starts at 4 because it will always include the size.
-      unencryptedLogPreimagesLength: new Fr(4),
       allUnencryptedLogs: [],
       nestedExecutions: [],
     };
@@ -141,7 +142,7 @@ export class AvmPersistableStateManager {
    * @param value - the value being written to the slot
    */
   public writeStorage(storageAddress: Fr, slot: Fr, value: Fr) {
-    this.log.debug(`storage(${storageAddress})@${slot} <- ${value}`);
+    this.log.debug(`Storage write (address=${storageAddress}, slot=${slot}): value=${value}`);
     // Cache storage writes for later reference/reads
     this.publicStorage.write(storageAddress, slot, value);
 
@@ -172,7 +173,9 @@ export class AvmPersistableStateManager {
    */
   public async readStorage(storageAddress: Fr, slot: Fr): Promise<Fr> {
     const { value, exists, cached } = await this.publicStorage.read(storageAddress, slot);
-    this.log.debug(`storage(${storageAddress})@${slot} ?? value: ${value}, exists: ${exists}, cached: ${cached}.`);
+    this.log.debug(
+      `Storage read  (address=${storageAddress}, slot=${slot}): value=${value}, exists=${exists}, cached=${cached}`,
+    );
 
     // 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.
@@ -253,7 +256,9 @@ export class AvmPersistableStateManager {
    */
   public async writeNullifier(storageAddress: Fr, nullifier: Fr) {
     // TRANSITIONAL: This should be removed once the kernel handles and entire enqueued call per circuit
-    this.transitionalExecutionResult.newNullifiers.push(new Nullifier(nullifier, this.trace.accessCounter, Fr.ZERO));
+    this.transitionalExecutionResult.newNullifiers.push(
+      new Nullifier(nullifier, this.trace.accessCounter, /*noteHash=*/ Fr.ZERO),
+    );
 
     this.log.debug(`nullifiers(${storageAddress}) += ${nullifier}.`);
     // Cache pending nullifiers for later access
@@ -307,12 +312,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 SideEffect(logHash, new Fr(this.trace.accessCounter)),
-    );
-    // Duplicates computation performed in public_context.nr::emit_unencrypted_log
-    // 44 = addr (32) + selector (4) + raw log len (4) + processed log len (4).
-    this.transitionalExecutionResult.unencryptedLogPreimagesLength = new Fr(
-      this.transitionalExecutionResult.unencryptedLogPreimagesLength.toNumber() + 44 + log.length * Fr.SIZE_IN_BYTES,
+      // 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.