@aztec/simulator 0.60.0 → 0.62.0

package/src/avm/opcodes/external_calls.ts

@@ -1,10 +1,9 @@
-import { FunctionSelector, Gas } from '@aztec/circuits.js';
-import { padArrayEnd } from '@aztec/foundation/collection';
+import { Fr, FunctionSelector, Gas, PUBLIC_DISPATCH_SELECTOR } from '@aztec/circuits.js';
 
 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 Field, TypeTag, Uint1 } from '../avm_memory_types.js';
 import { AvmSimulator } from '../avm_simulator.js';
 import { RethrownError } from '../errors.js';
 import { Opcode, OperandType } from '../serialization/instruction_serialization.js';
@@ -21,58 +20,39 @@ abstract class ExternalCall extends Instruction {
     OperandType.UINT16,
     OperandType.UINT16,
     OperandType.UINT16,
-    OperandType.UINT16,
-    OperandType.UINT16,
-    OperandType.UINT16,
   ];
 
   constructor(
     private indirect: number,
-    private gasOffset: number /* Unused due to no formal gas implementation at this moment */,
+    private gasOffset: number,
     private addrOffset: number,
     private argsOffset: number,
     private argsSizeOffset: number,
-    private retOffset: number,
-    private retSize: number,
     private successOffset: number,
-    // NOTE: Function selector is likely 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)
-    private functionSelectorOffset: number,
   ) {
     super();
   }
 
   public async execute(context: AvmContext) {
     const memory = context.machineState.memory.track(this.type);
-    const operands = [
-      this.gasOffset,
-      this.addrOffset,
-      this.argsOffset,
-      this.argsSizeOffset,
-      this.retOffset,
-      this.successOffset,
-      this.functionSelectorOffset,
-    ];
+    const operands = [this.gasOffset, this.addrOffset, this.argsOffset, this.argsSizeOffset, this.successOffset];
     const addressing = Addressing.fromWire(this.indirect, operands.length);
-    const [gasOffset, addrOffset, argsOffset, argsSizeOffset, retOffset, successOffset, functionSelectorOffset] =
-      addressing.resolve(operands, memory);
+    const [gasOffset, addrOffset, argsOffset, argsSizeOffset, successOffset] = addressing.resolve(operands, memory);
     memory.checkTags(TypeTag.FIELD, gasOffset, gasOffset + 1);
     memory.checkTag(TypeTag.FIELD, addrOffset);
     memory.checkTag(TypeTag.UINT32, argsSizeOffset);
-    memory.checkTag(TypeTag.FIELD, functionSelectorOffset);
 
     const calldataSize = memory.get(argsSizeOffset).toNumber();
     memory.checkTagsRange(TypeTag.FIELD, argsOffset, calldataSize);
 
     const callAddress = memory.getAs<Field>(addrOffset);
     const calldata = memory.getSlice(argsOffset, calldataSize).map(f => f.toFr());
-    const functionSelector = memory.getAs<Field>(functionSelectorOffset).toFr();
+    const functionSelector = new Fr(PUBLIC_DISPATCH_SELECTOR);
     // If we are already in a static call, we propagate the environment.
     const callType = context.environment.isStaticCall ? 'STATICCALL' : this.type;
 
     // First we consume the gas for this operation.
-    context.machineState.consumeGas(this.gasCost(calldataSize + this.retSize));
+    context.machineState.consumeGas(this.gasCost(calldataSize));
     // Then we consume the gas allocated for the nested call. The excess will be refunded later.
     // Gas allocation is capped by the amount of gas left in the current context.
     // We have to do some dancing here because the gas allocation is a field,
@@ -106,18 +86,12 @@ abstract class ExternalCall extends Instruction {
       throw new RethrownError(nestedCallResults.revertReason.message, nestedCallResults.revertReason);
     }
 
-    // We only take as much data as was specified in the return size and pad with zeroes if the return data is smaller
-    // than the specified size in order to prevent that memory to be left with garbage
-    const returnData = nestedCallResults.output.slice(0, this.retSize);
-    const convertedReturnData = padArrayEnd(
-      returnData.map(f => new Field(f)),
-      new Field(0),
-      this.retSize,
-    );
+    // Save return/revert data for later.
+    const fullReturnData = nestedCallResults.output;
+    context.machineState.nestedReturndata = fullReturnData;
 
-    // Write our return data into memory
-    memory.set(successOffset, new Uint8(success ? 1 : 0));
-    memory.setSlice(retOffset, convertedReturnData);
+    // Write our success flag into memory.
+    memory.set(successOffset, new Uint1(success ? 1 : 0));
 
     // Refund unused gas
     context.machineState.refundGas(gasLeftToGas(nestedContext.machineState));
@@ -132,7 +106,7 @@ abstract class ExternalCall extends Instruction {
       /*avmCallResults=*/ nestedCallResults,
     );
 
-    memory.assert({ reads: calldataSize + 5, writes: 1 + this.retSize, addressing });
+    memory.assert({ reads: calldataSize + 4, writes: 1, addressing });
     context.machineState.incrementPc();
   }
 
@@ -204,22 +178,24 @@ export class Revert extends Instruction {
     OperandType.UINT16,
   ];
 
-  constructor(private indirect: number, private returnOffset: number, private retSize: number) {
+  constructor(private indirect: number, private returnOffset: number, private retSizeOffset: number) {
     super();
   }
 
   public async execute(context: AvmContext): Promise<void> {
     const memory = context.machineState.memory.track(this.type);
-    context.machineState.consumeGas(this.gasCost(this.retSize));
 
-    const operands = [this.returnOffset];
+    const operands = [this.returnOffset, this.retSizeOffset];
     const addressing = Addressing.fromWire(this.indirect, operands.length);
-    const [returnOffset] = addressing.resolve(operands, memory);
+    const [returnOffset, retSizeOffset] = addressing.resolve(operands, memory);
 
-    const output = memory.getSlice(returnOffset, this.retSize).map(word => word.toFr());
+    memory.checkTag(TypeTag.UINT32, retSizeOffset);
+    const retSize = memory.get(retSizeOffset).toNumber();
+    context.machineState.consumeGas(this.gasCost(retSize));
+    const output = memory.getSlice(returnOffset, retSize).map(word => word.toFr());
 
     context.machineState.revert(output);
-    memory.assert({ reads: this.retSize, addressing });
+    memory.assert({ reads: retSize + 1, addressing });
   }
 }
 

package/src/avm/opcodes/memory.ts

@@ -1,5 +1,5 @@
 import type { AvmContext } from '../avm_context.js';
-import { Field, TaggedMemory } from '../avm_memory_types.js';
+import { Field, TaggedMemory, TypeTag, Uint32 } from '../avm_memory_types.js';
 import { Opcode, OperandType } from '../serialization/instruction_serialization.js';
 import { Addressing } from './addressing_mode.js';
 import { Instruction } from './instruction.js';
@@ -179,11 +179,11 @@ export class CalldataCopy extends Instruction {
 
   public async execute(context: AvmContext): Promise<void> {
     const memory = context.machineState.memory.track(this.type);
-    // We don't need to check tags here because: (1) the calldata is NOT in memory, and (2) we are the ones writing to destination.
     const operands = [this.cdStartOffset, this.copySizeOffset, this.dstOffset];
     const addressing = Addressing.fromWire(this.indirect, operands.length);
     const [cdStartOffset, copySizeOffset, dstOffset] = addressing.resolve(operands, memory);
 
+    memory.checkTags(TypeTag.UINT32, cdStartOffset, copySizeOffset);
     const cdStart = memory.get(cdStartOffset).toNumber();
     const copySize = memory.get(copySizeOffset).toNumber();
     context.machineState.consumeGas(this.gasCost(copySize));
@@ -196,3 +196,70 @@ export class CalldataCopy extends Instruction {
     context.machineState.incrementPc();
   }
 }
+
+export class ReturndataSize extends Instruction {
+  static readonly type: string = 'RETURNDATASIZE';
+  static readonly opcode: Opcode = Opcode.RETURNDATASIZE;
+  // Informs (de)serialization. See Instruction.deserialize.
+  static readonly wireFormat: OperandType[] = [OperandType.UINT8, OperandType.UINT8, OperandType.UINT16];
+
+  constructor(private indirect: number, private dstOffset: number) {
+    super();
+  }
+
+  public async execute(context: AvmContext): Promise<void> {
+    const memory = context.machineState.memory.track(this.type);
+    const operands = [this.dstOffset];
+    const addressing = Addressing.fromWire(this.indirect, operands.length);
+    const [dstOffset] = addressing.resolve(operands, memory);
+    context.machineState.consumeGas(this.gasCost());
+
+    memory.set(dstOffset, new Uint32(context.machineState.nestedReturndata.length));
+
+    memory.assert({ writes: 1, addressing });
+    context.machineState.incrementPc();
+  }
+}
+
+export class ReturndataCopy extends Instruction {
+  static readonly type: string = 'RETURNDATACOPY';
+  static readonly opcode: Opcode = Opcode.RETURNDATACOPY;
+  // Informs (de)serialization. See Instruction.deserialize.
+  static readonly wireFormat: OperandType[] = [
+    OperandType.UINT8,
+    OperandType.UINT8,
+    OperandType.UINT16,
+    OperandType.UINT16,
+    OperandType.UINT16,
+  ];
+
+  constructor(
+    private indirect: number,
+    private rdStartOffset: number,
+    private copySizeOffset: number,
+    private dstOffset: number,
+  ) {
+    super();
+  }
+
+  public async execute(context: AvmContext): Promise<void> {
+    const memory = context.machineState.memory.track(this.type);
+    const operands = [this.rdStartOffset, this.copySizeOffset, this.dstOffset];
+    const addressing = Addressing.fromWire(this.indirect, operands.length);
+    const [rdStartOffset, copySizeOffset, dstOffset] = addressing.resolve(operands, memory);
+
+    memory.checkTags(TypeTag.UINT32, rdStartOffset, copySizeOffset);
+    const rdStart = memory.get(rdStartOffset).toNumber();
+    const copySize = memory.get(copySizeOffset).toNumber();
+    context.machineState.consumeGas(this.gasCost(copySize));
+
+    const transformedData = context.machineState.nestedReturndata
+      .slice(rdStart, rdStart + copySize)
+      .map(f => new Field(f));
+
+    memory.setSlice(dstOffset, transformedData);
+
+    memory.assert({ reads: 2, writes: copySize, addressing });
+    context.machineState.incrementPc();
+  }
+}

package/src/avm/serialization/bytecode_serialization.ts

@@ -31,6 +31,8 @@ import {
   Or,
   Poseidon2,
   Return,
+  ReturndataCopy,
+  ReturndataSize,
   Revert,
   SLoad,
   SStore,
@@ -41,7 +43,7 @@ import {
   Shr,
   StaticCall,
   Sub,
-  ToRadixLE,
+  ToRadixBE,
   Xor,
 } from '../opcodes/index.js';
 import { MultiScalarMul } from '../opcodes/multi_scalar_mul.js';
@@ -96,6 +98,8 @@ const INSTRUCTION_SET = () =>
     // Execution Environment
     [Opcode.GETENVVAR_16, GetEnvVar.as(GetEnvVar.wireFormat16).deserialize],
     [CalldataCopy.opcode, Instruction.deserialize.bind(CalldataCopy)],
+    [Opcode.RETURNDATASIZE, Instruction.deserialize.bind(ReturndataSize)],
+    [Opcode.RETURNDATACOPY, Instruction.deserialize.bind(ReturndataCopy)],
 
     // Machine State - Internal Control Flow
     [Jump.opcode, Instruction.deserialize.bind(Jump)],
@@ -141,7 +145,7 @@ const INSTRUCTION_SET = () =>
     [Sha256Compression.opcode, Instruction.deserialize.bind(Sha256Compression)],
     [MultiScalarMul.opcode, Instruction.deserialize.bind(MultiScalarMul)],
     // Conversions
-    [ToRadixLE.opcode, Instruction.deserialize.bind(ToRadixLE)],
+    [ToRadixBE.opcode, Instruction.deserialize.bind(ToRadixBE)],
     // Future Gadgets -- pending changes in noir
     // SHA256COMPRESSION,
     [KeccakF1600.opcode, Instruction.deserialize.bind(KeccakF1600)],

package/src/avm/serialization/instruction_serialization.ts

@@ -41,9 +41,11 @@ export enum Opcode {
   // Execution environment
   GETENVVAR_16,
   CALLDATACOPY,
+  RETURNDATASIZE,
+  RETURNDATACOPY,
   // Control flow
-  JUMP_16,
-  JUMPI_16,
+  JUMP_32,
+  JUMPI_32,
   INTERNALCALL,
   INTERNALRETURN,
   // Memory
@@ -81,7 +83,7 @@ export enum Opcode {
   ECADD,
   MSM,
   // Conversion
-  TORADIXLE,
+  TORADIXBE,
 }
 
 // Possible types for an instruction's operand in its wire format. (Keep in sync with CPP code.

package/src/avm/test_utils.ts

@@ -1,4 +1,4 @@
-import { type ContractInstanceWithAddress, Fr } from '@aztec/circuits.js';
+import { type ContractClassPublic, type ContractInstanceWithAddress, Fr } from '@aztec/circuits.js';
 
 import { type jest } from '@jest/globals';
 import { mock } from 'jest-mock-extended';
@@ -61,3 +61,7 @@ export function mockL1ToL2MessageExists(
 export function mockGetContractInstance(worldStateDB: WorldStateDB, contractInstance: ContractInstanceWithAddress) {
   (worldStateDB as jest.Mocked<WorldStateDB>).getContractInstance.mockResolvedValue(contractInstance);
 }
+
+export function mockGetContractClass(worldStateDB: WorldStateDB, contractClass: ContractClassPublic) {
+  (worldStateDB as jest.Mocked<WorldStateDB>).getContractClass.mockResolvedValue(contractClass);
+}

package/src/client/client_execution_context.ts

@@ -602,33 +602,6 @@ 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(
-    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(contractAddress, storageSlot, blockNumber);
-      this.log.debug(
-        `Oracle storage read: slot=${storageSlot.toString()} address-${contractAddress.toString()} value=${value}`,
-      );
-
-      values.push(value);
-    }
-    return values;
-  }
-
   public override debugLog(message: string, fields: Fr[]) {
     this.log.verbose(`debug_log ${applyStringFormatting(message, fields)}`);
   }
@@ -636,4 +609,8 @@ export class ClientExecutionContext extends ViewDataOracle {
   public getDebugFunctionName() {
     return this.db.getDebugFunctionName(this.contractAddress, this.callContext.functionSelector);
   }
+
+  public override async incrementAppTaggingSecret(sender: AztecAddress, recipient: AztecAddress) {
+    await this.db.incrementAppTaggingSecret(this.contractAddress, sender, recipient);
+  }
 }

package/src/client/db_oracle.ts

@@ -9,6 +9,7 @@ import {
   type CompleteAddress,
   type ContractInstance,
   type Header,
+  type IndexedTaggingSecret,
   type KeyValidationRequest,
 } from '@aztec/circuits.js';
 import { type FunctionArtifact, type FunctionSelector } from '@aztec/foundation/abi';
@@ -193,4 +194,41 @@ export interface DBOracle extends CommitmentsDB {
    * @returns The block number.
    */
   getBlockNumber(): Promise<number>;
+
+  /**
+   * Returns the tagging secret for a given sender and recipient pair. For this to work, the ivpsk_m of the sender must be known.
+   * Includes the last known index used for tagging with this secret.
+   * @param contractAddress - The contract address to silo the secret for
+   * @param sender - The address sending the note
+   * @param recipient - The address receiving the note
+   * @returns A tagging secret that can be used to tag notes.
+   */
+  getAppTaggingSecret(
+    contractAddress: AztecAddress,
+    sender: AztecAddress,
+    recipient: AztecAddress,
+  ): Promise<IndexedTaggingSecret>;
+
+  /**
+   * Increments the tagging secret for a given sender and recipient pair. For this to work, the ivpsk_m of the sender must be known.
+   * @param contractAddress - The contract address to silo the secret for
+   * @param sender - The address sending the note
+   * @param recipient - The address receiving the note
+   */
+  incrementAppTaggingSecret(
+    contractAddress: AztecAddress,
+    sender: AztecAddress,
+    recipient: AztecAddress,
+  ): Promise<void>;
+
+  /**
+   * Returns the siloed tagging secrets for a given recipient and all the senders in the address book
+   * @param contractAddress - The contract address to silo the secret for
+   * @param recipient - The address receiving the notes
+   * @returns A list of siloed tagging secrets
+   */
+  getAppTaggingSecretsForSenders(
+    contractAddress: AztecAddress,
+    recipient: AztecAddress,
+  ): Promise<IndexedTaggingSecret[]>;
 }

package/src/client/view_data_oracle.ts

@@ -7,7 +7,12 @@ import {
   type NullifierMembershipWitness,
   type PublicDataWitness,
 } from '@aztec/circuit-types';
-import { type ContractInstance, type Header, type KeyValidationRequest } from '@aztec/circuits.js';
+import {
+  type ContractInstance,
+  type Header,
+  type IndexedTaggingSecret,
+  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';
@@ -288,4 +293,29 @@ export class ViewDataOracle extends TypedOracle {
     const formattedStr = applyStringFormatting(message, fields);
     this.log.verbose(`debug_log ${formattedStr}`);
   }
+
+  /**
+   * Returns the tagging secret for a given sender and recipient pair, siloed to the current contract address.
+   * Includes the last known index used for tagging with this secret.
+   * For this to work, the ivpsk_m of the sender must be known.
+   * @param sender - The address sending the note
+   * @param recipient - The address receiving the note
+   * @returns A tagging secret that can be used to tag notes.
+   */
+  public override async getAppTaggingSecret(
+    sender: AztecAddress,
+    recipient: AztecAddress,
+  ): Promise<IndexedTaggingSecret> {
+    return await this.db.getAppTaggingSecret(this.contractAddress, sender, recipient);
+  }
+
+  /**
+   * Returns the siloed tagging secrets for a given recipient and all the senders in the address book
+   * @param contractAddress - The contract address to silo the secret for
+   * @param recipient - The address receiving the notes
+   * @returns A list of siloed tagging secrets
+   */
+  public override async getAppTaggingSecretsForSenders(recipient: AztecAddress): Promise<IndexedTaggingSecret[]> {
+    return await this.db.getAppTaggingSecretsForSenders(this.contractAddress, recipient);
+  }
 }

package/src/common/index.ts

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

package/src/public/dual_side_effect_trace.ts

@@ -1,7 +1,8 @@
 import {
   type CombinedConstantData,
-  type ContractInstanceWithAddress,
+  type ContractClassIdPreimage,
   type Gas,
+  type SerializableContractInstance,
   type VMCircuitPublicInputs,
 } from '@aztec/circuits.js';
 import { type Fr } from '@aztec/foundation/fields';
@@ -15,8 +16,6 @@ import { type PublicExecutionResult } from './execution.js';
 import { type PublicSideEffectTrace } from './side_effect_trace.js';
 import { type PublicSideEffectTraceInterface } from './side_effect_trace_interface.js';
 
-export type TracedContractInstance = { exists: boolean } & ContractInstanceWithAddress;
-
 export class DualSideEffectTrace implements PublicSideEffectTraceInterface {
   constructor(
     public readonly innerCallTrace: PublicSideEffectTrace,
@@ -78,9 +77,24 @@ export class DualSideEffectTrace implements PublicSideEffectTraceInterface {
     this.enqueuedCallTrace.traceUnencryptedLog(contractAddress, log);
   }
 
-  public traceGetContractInstance(instance: TracedContractInstance) {
-    this.innerCallTrace.traceGetContractInstance(instance);
-    this.enqueuedCallTrace.traceGetContractInstance(instance);
+  public traceGetContractInstance(
+    contractAddress: Fr,
+    exists: boolean,
+    instance: SerializableContractInstance | undefined,
+  ) {
+    this.innerCallTrace.traceGetContractInstance(contractAddress, exists, instance);
+    this.enqueuedCallTrace.traceGetContractInstance(contractAddress, exists, instance);
+  }
+
+  public traceGetBytecode(
+    contractAddress: Fr,
+    exists: boolean,
+    bytecode: Buffer,
+    contractInstance: SerializableContractInstance | undefined,
+    contractClass: ContractClassIdPreimage | undefined,
+  ) {
+    this.innerCallTrace.traceGetBytecode(contractAddress, exists, bytecode, contractInstance, contractClass);
+    this.enqueuedCallTrace.traceGetBytecode(contractAddress, exists, bytecode, contractInstance, contractClass);
   }
 
   /**

package/src/public/enqueued_call_side_effect_trace.ts

@@ -1,5 +1,6 @@
 import { UnencryptedL2Log } from '@aztec/circuit-types';
 import {
+  AvmContractBytecodeHints,
   AvmContractInstanceHint,
   AvmExecutionHints,
   AvmExternalCallHint,
@@ -7,7 +8,7 @@ import {
   AztecAddress,
   CallContext,
   type CombinedConstantData,
-  type ContractInstanceWithAddress,
+  type ContractClassIdPreimage,
   ContractStorageRead,
   ContractStorageUpdateRequest,
   EthAddress,
@@ -44,6 +45,7 @@ import {
   ScopedNoteHash,
   type ScopedNullifier,
   ScopedReadRequest,
+  SerializableContractInstance,
   TreeLeafReadRequest,
   VMCircuitPublicInputs,
 } from '@aztec/circuits.js';
@@ -58,8 +60,6 @@ import { type AvmExecutionEnvironment } from '../avm/avm_execution_environment.j
 import { SideEffectLimitReachedError } from './side_effect_errors.js';
 import { type PublicSideEffectTraceInterface } from './side_effect_trace_interface.js';
 
-export type TracedContractInstance = { exists: boolean } & ContractInstanceWithAddress;
-
 /**
  * A struct containing just the side effects as regular arrays
  * as opposed to "Tuple" arrays used by circuit public inputs.
@@ -307,14 +307,17 @@ export class PublicEnqueuedCallSideEffectTrace implements PublicSideEffectTraceI
     this.incrementSideEffectCounter();
   }
 
-  public traceGetContractInstance(instance: TracedContractInstance) {
+  public traceGetContractInstance(
+    contractAddress: Fr,
+    exists: boolean,
+    instance: SerializableContractInstance = SerializableContractInstance.default(),
+  ) {
     this.enforceLimitOnNullifierChecks('(contract address nullifier from GETCONTRACTINSTANCE)');
-    // TODO(dbanks12): should emit a nullifier read request
 
     this.avmCircuitHints.contractInstances.items.push(
       new AvmContractInstanceHint(
-        instance.address,
-        new Fr(instance.exists ? 1 : 0),
+        contractAddress,
+        exists,
         instance.salt,
         instance.deployer,
         instance.contractClassId,
@@ -326,6 +329,40 @@ export class PublicEnqueuedCallSideEffectTrace implements PublicSideEffectTraceI
     this.incrementSideEffectCounter();
   }
 
+  // This tracing function gets called everytime we start simulation/execution.
+  // This happens both when starting a new top-level trace and the start of every nested trace
+  // We use this to collect the AvmContractBytecodeHints
+  public traceGetBytecode(
+    contractAddress: Fr,
+    exists: boolean,
+    bytecode: Buffer = Buffer.alloc(0),
+    contractInstance: SerializableContractInstance = SerializableContractInstance.default(),
+    contractClass: ContractClassIdPreimage = {
+      artifactHash: Fr.zero(),
+      privateFunctionsRoot: Fr.zero(),
+      publicBytecodeCommitment: Fr.zero(),
+    },
+  ) {
+    const instance = new AvmContractInstanceHint(
+      contractAddress,
+      exists,
+      contractInstance.salt,
+      contractInstance.deployer,
+      contractInstance.contractClassId,
+      contractInstance.initializationHash,
+      contractInstance.publicKeys,
+    );
+    // We need to deduplicate the contract instances based on addresses
+    this.avmCircuitHints.contractBytecodeHints.items.push(
+      new AvmContractBytecodeHints(bytecode, instance, contractClass),
+    );
+    this.log.debug(
+      `Bytecode retrieval for contract execution traced: exists=${exists}, instance=${JSON.stringify(
+        contractInstance,
+      )}`,
+    );
+  }
+
   /**
    * Trace a nested call.
    * Accept some results from a finished nested call's trace into this one.
@@ -334,7 +371,7 @@ export class PublicEnqueuedCallSideEffectTrace implements PublicSideEffectTraceI
     /** The trace of the nested call. */
     nestedCallTrace: this,
     /** The execution environment of the nested call. */
-    _nestedEnvironment: AvmExecutionEnvironment,
+    nestedEnvironment: AvmExecutionEnvironment,
     /** How much gas was available for this public execution. */
     startGasLeft: Gas,
     /** How much gas was left after this public execution. */
@@ -368,6 +405,7 @@ export class PublicEnqueuedCallSideEffectTrace implements PublicSideEffectTraceI
         avmCallResults.output,
         gasUsed,
         endSideEffectCounter,
+        nestedEnvironment.address,
       ),
     );
   }