@aztec/simulator 0.32.1 → 0.34.0

package/src/avm/opcodes/hashing.ts

@@ -29,19 +29,24 @@ export class Poseidon2 extends Instruction {
     super();
   }
 
-  async execute(context: AvmContext): Promise<void> {
+  public async execute(context: AvmContext): Promise<void> {
+    const memoryOperations = { reads: this.messageSize, writes: 1, indirect: this.indirect };
+    const memory = context.machineState.memory.track(this.type);
+    context.machineState.consumeGas(this.gasCost(memoryOperations));
+
     // We hash a set of field elements
     const [dstOffset, messageOffset] = Addressing.fromWire(this.indirect).resolve(
       [this.dstOffset, this.messageOffset],
-      context.machineState.memory,
+      memory,
     );
 
     // Memory pointer will be indirect
-    const hashData = context.machineState.memory.getSlice(messageOffset, this.messageSize).map(word => word.toBuffer());
+    const hashData = memory.getSlice(messageOffset, this.messageSize).map(word => word.toBuffer());
 
     const hash = poseidonHash(hashData);
-    context.machineState.memory.set(dstOffset, new Field(hash));
+    memory.set(dstOffset, new Field(hash));
 
+    memory.assert(memoryOperations);
     context.machineState.incrementPc();
   }
 }
@@ -69,14 +74,18 @@ export class Keccak extends Instruction {
   }
 
   // Note hash output is 32 bytes, so takes up two fields
-  async execute(context: AvmContext): Promise<void> {
+  public async execute(context: AvmContext): Promise<void> {
+    const memoryOperations = { reads: this.messageSize, writes: 2, indirect: this.indirect };
+    const memory = context.machineState.memory.track(this.type);
+    context.machineState.consumeGas(this.gasCost(memoryOperations));
+
     // We hash a set of field elements
     const [dstOffset, messageOffset] = Addressing.fromWire(this.indirect).resolve(
       [this.dstOffset, this.messageOffset],
-      context.machineState.memory,
+      memory,
     );
 
-    const hashData = context.machineState.memory.getSlice(messageOffset, this.messageSize).map(word => word.toBuffer());
+    const hashData = memory.getSlice(messageOffset, this.messageSize).map(word => word.toBuffer());
 
     const hash = keccak(Buffer.concat(hashData));
 
@@ -84,9 +93,10 @@ export class Keccak extends Instruction {
     const high = new Field(toBigIntBE(hash.subarray(0, 16)));
     const low = new Field(toBigIntBE(hash.subarray(16, 32)));
 
-    context.machineState.memory.set(dstOffset, high);
-    context.machineState.memory.set(dstOffset + 1, low);
+    memory.set(dstOffset, high);
+    memory.set(dstOffset + 1, low);
 
+    memory.assert(memoryOperations);
     context.machineState.incrementPc();
   }
 }
@@ -114,14 +124,18 @@ export class Sha256 extends Instruction {
   }
 
   // Note hash output is 32 bytes, so takes up two fields
-  async execute(context: AvmContext): Promise<void> {
+  public async execute(context: AvmContext): Promise<void> {
+    const memoryOperations = { reads: this.messageSize, writes: 2, indirect: this.indirect };
+    const memory = context.machineState.memory.track(this.type);
+    context.machineState.consumeGas(this.gasCost(memoryOperations));
+
     const [dstOffset, messageOffset] = Addressing.fromWire(this.indirect).resolve(
       [this.dstOffset, this.messageOffset],
-      context.machineState.memory,
+      memory,
     );
 
     // We hash a set of field elements
-    const hashData = context.machineState.memory.getSlice(messageOffset, this.messageSize).map(word => word.toBuffer());
+    const hashData = memory.getSlice(messageOffset, this.messageSize).map(word => word.toBuffer());
 
     const hash = sha256(Buffer.concat(hashData));
 
@@ -129,9 +143,10 @@ export class Sha256 extends Instruction {
     const high = new Field(toBigIntBE(hash.subarray(0, 16)));
     const low = new Field(toBigIntBE(hash.subarray(16, 32)));
 
-    context.machineState.memory.set(dstOffset, high);
-    context.machineState.memory.set(dstOffset + 1, low);
+    memory.set(dstOffset, high);
+    memory.set(dstOffset + 1, low);
 
+    memory.assert(memoryOperations);
     context.machineState.incrementPc();
   }
 }
@@ -147,10 +162,12 @@ export class Pedersen extends Instruction {
     OperandType.UINT32,
     OperandType.UINT32,
     OperandType.UINT32,
+    OperandType.UINT32,
   ];
 
   constructor(
     private indirect: number,
+    private genIndexOffset: number,
     private dstOffset: number,
     private messageOffset: number,
     private messageSizeOffset: number,
@@ -158,20 +175,26 @@ export class Pedersen extends Instruction {
     super();
   }
 
-  async execute(context: AvmContext): Promise<void> {
-    const [dstOffset, messageOffset, messageSizeOffset] = Addressing.fromWire(this.indirect).resolve(
-      [this.dstOffset, this.messageOffset, this.messageSizeOffset],
-      context.machineState.memory,
+  public async execute(context: AvmContext): Promise<void> {
+    const memory = context.machineState.memory.track(this.type);
+    const [genIndexOffset, dstOffset, messageOffset, messageSizeOffset] = Addressing.fromWire(this.indirect).resolve(
+      [this.genIndexOffset, this.dstOffset, this.messageOffset, this.messageSizeOffset],
+      memory,
     );
 
     // We hash a set of field elements
-    const messageSize = Number(context.machineState.memory.get(messageSizeOffset).toBigInt());
-    const hashData = context.machineState.memory.getSlice(messageOffset, messageSize);
+    const genIndex = Number(memory.get(genIndexOffset).toBigInt());
+    const messageSize = Number(memory.get(messageSizeOffset).toBigInt());
+    const hashData = memory.getSlice(messageOffset, messageSize);
+
+    const memoryOperations = { reads: messageSize + 2, writes: 1, indirect: this.indirect };
+    context.machineState.consumeGas(this.gasCost(memoryOperations));
 
     // No domain sep for now
-    const hash = pedersenHash(hashData);
-    context.machineState.memory.set(dstOffset, new Field(hash));
+    const hash = pedersenHash(hashData, genIndex);
+    memory.set(dstOffset, new Field(hash));
 
+    memory.assert(memoryOperations);
     context.machineState.incrementPc();
   }
 }

package/src/avm/opcodes/index.ts

@@ -1,6 +1,7 @@
 export * from './arithmetic.js';
 export * from './bitwise.js';
 export * from './control_flow.js';
+export * from './contract.js';
 export * from './instruction.js';
 export * from './comparators.js';
 export * from './memory.js';

package/src/avm/opcodes/instruction.ts

@@ -1,7 +1,8 @@
 import { strict as assert } from 'assert';
 
 import type { AvmContext } from '../avm_context.js';
-import { DynamicGasCost, type GasCost, GasCosts } from '../avm_gas_cost.js';
+import { getBaseGasCost, getMemoryGasCost, sumGas } from '../avm_gas.js';
+import { type MemoryOperations } from '../avm_memory_types.js';
 import { type BufferCursor } from '../serialization/buffer_cursor.js';
 import { Opcode, type OperandType, deserialize, serialize } from '../serialization/instruction_serialization.js';
 
@@ -20,31 +21,7 @@ export abstract class Instruction {
    * This is the main entry point for the instruction.
    * @param context - The AvmContext in which the instruction executes.
    */
-  public run(context: AvmContext): Promise<void> {
-    context.machineState.consumeGas(this.gasCost());
-    return this.execute(context);
-  }
-
-  /**
-   * Loads default gas cost for the instruction from the GasCosts table.
-   * Instruction sub-classes can override this if their gas cost is not fixed.
-   */
-  protected gasCost(): GasCost {
-    const gasCost = GasCosts[this.opcode];
-    if (gasCost === DynamicGasCost) {
-      throw new Error(`Instruction ${this.type} must define its own gas cost`);
-    }
-    return gasCost;
-  }
-
-  /**
-   * Execute the instruction.
-   * Instruction sub-classes must implement this.
-   * As an AvmContext executes its contract code, it calls this function for
-   * each instruction until the machine state signals "halted".
-   * @param context - The AvmContext in which the instruction executes.
-   */
-  protected abstract execute(context: AvmContext): Promise<void>;
+  public abstract execute(context: AvmContext): Promise<void>;
 
   /**
    * Generate a string representation of the instruction including
@@ -85,6 +62,17 @@ export abstract class Instruction {
     return new this(...args);
   }
 
+  /**
+   * Computes gas cost for the instruction based on its base cost and memory operations.
+   * @param memoryOps Memory operations performed by the instruction.
+   * @returns Gas cost.
+   */
+  protected gasCost(memoryOps: Partial<MemoryOperations & { indirect: number }> = {}) {
+    const baseGasCost = getBaseGasCost(this.opcode);
+    const memoryGasCost = getMemoryGasCost(memoryOps);
+    return sumGas(baseGasCost, memoryGasCost);
+  }
+
   /**
    * Returns the stringified type of the instruction.
    * Instruction sub-classes should have a static `type` property.

package/src/avm/opcodes/instruction_impl.ts

@@ -1,19 +1,34 @@
+import { type AvmContext } from '../avm_context.js';
+import { type MemoryValue } from '../avm_memory_types.js';
 import { OperandType } from '../serialization/instruction_serialization.js';
 import { Instruction } from './instruction.js';
 
+/** Wire format that informs deserialization for instructions with two operands. */
+export const TwoOperandWireFormat = [
+  OperandType.UINT8,
+  OperandType.UINT8,
+  OperandType.UINT8,
+  OperandType.UINT32,
+  OperandType.UINT32,
+];
+
+/** Wire format that informs deserialization for instructions with three operands. */
+export const ThreeOperandWireFormat = [
+  OperandType.UINT8,
+  OperandType.UINT8,
+  OperandType.UINT8,
+  OperandType.UINT32,
+  OperandType.UINT32,
+  OperandType.UINT32,
+];
+
 /**
  * Covers (de)serialization for an instruction with:
  * indirect, inTag, and two UINT32s.
  */
 export abstract class TwoOperandInstruction extends Instruction {
   // Informs (de)serialization. See Instruction.deserialize.
-  static readonly wireFormat: OperandType[] = [
-    OperandType.UINT8,
-    OperandType.UINT8,
-    OperandType.UINT8,
-    OperandType.UINT32,
-    OperandType.UINT32,
-  ];
+  static readonly wireFormat: OperandType[] = TwoOperandWireFormat;
 
   constructor(
     protected indirect: number,
@@ -31,14 +46,7 @@ export abstract class TwoOperandInstruction extends Instruction {
  */
 export abstract class ThreeOperandInstruction extends Instruction {
   // Informs (de)serialization. See Instruction.deserialize.
-  static readonly wireFormat: OperandType[] = [
-    OperandType.UINT8,
-    OperandType.UINT8,
-    OperandType.UINT8,
-    OperandType.UINT32,
-    OperandType.UINT32,
-    OperandType.UINT32,
-  ];
+  static readonly wireFormat: OperandType[] = ThreeOperandWireFormat;
 
   constructor(
     protected indirect: number,
@@ -50,3 +58,25 @@ export abstract class ThreeOperandInstruction extends Instruction {
     super();
   }
 }
+
+export abstract class GetterInstruction extends Instruction {
+  // Informs (de)serialization. See Instruction.deserialize.
+  static readonly wireFormat: OperandType[] = [OperandType.UINT8, OperandType.UINT8, OperandType.UINT32];
+
+  constructor(protected indirect: number, protected dstOffset: number) {
+    super();
+  }
+
+  public async execute(context: AvmContext): Promise<void> {
+    const memoryOperations = { writes: 1, indirect: this.indirect };
+    const memory = context.machineState.memory.track(this.type);
+    context.machineState.consumeGas(this.gasCost(memoryOperations));
+
+    memory.set(this.dstOffset, this.getValue(context));
+
+    memory.assert(memoryOperations);
+    context.machineState.incrementPc();
+  }
+
+  protected abstract getValue(env: AvmContext): MemoryValue;
+}

package/src/avm/opcodes/memory.ts

@@ -1,6 +1,6 @@
 import type { AvmContext } from '../avm_context.js';
-import { type GasCost, GasCostConstants, getGasCostMultiplierFromTypeTag, makeGasCost } from '../avm_gas_cost.js';
-import { Field, TaggedMemory, TypeTag } from '../avm_memory_types.js';
+import { getBaseGasCost, getMemoryGasCost, mulGas, sumGas } from '../avm_gas.js';
+import { Field, type MemoryOperations, TaggedMemory, TypeTag } from '../avm_memory_types.js';
 import { InstructionExecutionError } from '../errors.js';
 import { BufferCursor } from '../serialization/buffer_cursor.js';
 import { Opcode, OperandType, deserialize, serialize } from '../serialization/instruction_serialization.js';
@@ -69,21 +69,22 @@ export class Set extends Instruction {
     return new this(...args);
   }
 
-  async execute(context: AvmContext): Promise<void> {
+  public async execute(context: AvmContext): Promise<void> {
+    const memoryOperations = { writes: 1, indirect: this.indirect };
+    const memory = context.machineState.memory.track(this.type);
+    context.machineState.consumeGas(this.gasCost(memoryOperations));
+
     // Per the YP, the tag cannot be a field.
     if ([TypeTag.FIELD, TypeTag.UNINITIALIZED, TypeTag.INVALID].includes(this.inTag)) {
       throw new InstructionExecutionError(`Invalid tag ${TypeTag[this.inTag]} for SET.`);
     }
 
     const res = TaggedMemory.integralFromTag(this.value, this.inTag);
-    context.machineState.memory.set(this.dstOffset, res);
+    memory.set(this.dstOffset, res);
 
+    memory.assert(memoryOperations);
     context.machineState.incrementPc();
   }
-
-  protected gasCost(): GasCost {
-    return makeGasCost({ l2Gas: GasCostConstants.SET_COST_PER_BYTE * getGasCostMultiplierFromTypeTag(this.inTag) });
-  }
 }
 
 export class CMov extends Instruction {
@@ -109,14 +110,19 @@ export class CMov extends Instruction {
     super();
   }
 
-  async execute(context: AvmContext): Promise<void> {
-    const a = context.machineState.memory.get(this.aOffset);
-    const b = context.machineState.memory.get(this.bOffset);
-    const cond = context.machineState.memory.get(this.condOffset);
+  public async execute(context: AvmContext): Promise<void> {
+    const memoryOperations = { reads: 3, writes: 1, indirect: this.indirect };
+    const memory = context.machineState.memory.track(this.type);
+    context.machineState.consumeGas(this.gasCost(memoryOperations));
+
+    const a = memory.get(this.aOffset);
+    const b = memory.get(this.bOffset);
+    const cond = memory.get(this.condOffset);
 
     // TODO: reconsider toBigInt() here
-    context.machineState.memory.set(this.dstOffset, cond.toBigInt() > 0 ? a : b);
+    memory.set(this.dstOffset, cond.toBigInt() > 0 ? a : b);
 
+    memory.assert(memoryOperations);
     context.machineState.incrementPc();
   }
 }
@@ -129,15 +135,20 @@ export class Cast extends TwoOperandInstruction {
     super(indirect, dstTag, aOffset, dstOffset);
   }
 
-  async execute(context: AvmContext): Promise<void> {
-    const a = context.machineState.memory.get(this.aOffset);
+  public async execute(context: AvmContext): Promise<void> {
+    const memoryOperations = { reads: 1, writes: 1, indirect: this.indirect };
+    const memory = context.machineState.memory.track(this.type);
+    context.machineState.consumeGas(this.gasCost(memoryOperations));
+
+    const a = memory.get(this.aOffset);
 
     // TODO: consider not using toBigInt()
     const casted =
       this.inTag == TypeTag.FIELD ? new Field(a.toBigInt()) : TaggedMemory.integralFromTag(a.toBigInt(), this.inTag);
 
-    context.machineState.memory.set(this.dstOffset, casted);
+    memory.set(this.dstOffset, casted);
 
+    memory.assert(memoryOperations);
     context.machineState.incrementPc();
   }
 }
@@ -157,16 +168,18 @@ export class Mov extends Instruction {
     super();
   }
 
-  async execute(context: AvmContext): Promise<void> {
-    const [srcOffset, dstOffset] = Addressing.fromWire(this.indirect).resolve(
-      [this.srcOffset, this.dstOffset],
-      context.machineState.memory,
-    );
+  public async execute(context: AvmContext): Promise<void> {
+    const memoryOperations = { reads: 1, writes: 1, indirect: this.indirect };
+    const memory = context.machineState.memory.track(this.type);
+    context.machineState.consumeGas(this.gasCost(memoryOperations));
+
+    const [srcOffset, dstOffset] = Addressing.fromWire(this.indirect).resolve([this.srcOffset, this.dstOffset], memory);
 
-    const a = context.machineState.memory.get(srcOffset);
+    const a = memory.get(srcOffset);
 
-    context.machineState.memory.set(dstOffset, a);
+    memory.set(dstOffset, a);
 
+    memory.assert(memoryOperations);
     context.machineState.incrementPc();
   }
 }
@@ -187,19 +200,26 @@ export class CalldataCopy extends Instruction {
     super();
   }
 
-  async execute(context: AvmContext): Promise<void> {
-    const [dstOffset] = Addressing.fromWire(this.indirect).resolve([this.dstOffset], context.machineState.memory);
+  public async execute(context: AvmContext): Promise<void> {
+    const memoryOperations = { writes: this.copySize, indirect: this.indirect };
+    const memory = context.machineState.memory.track(this.type);
+    context.machineState.consumeGas(this.gasCost(memoryOperations));
+
+    const [dstOffset] = Addressing.fromWire(this.indirect).resolve([this.dstOffset], memory);
 
     const transformedData = context.environment.calldata
       .slice(this.cdOffset, this.cdOffset + this.copySize)
       .map(f => new Field(f));
 
-    context.machineState.memory.setSlice(dstOffset, transformedData);
+    memory.setSlice(dstOffset, transformedData);
 
+    memory.assert(memoryOperations);
     context.machineState.incrementPc();
   }
 
-  protected gasCost(): GasCost {
-    return makeGasCost({ l2Gas: GasCostConstants.CALLDATACOPY_COST_PER_BYTE * this.copySize });
+  protected gasCost(memoryOps: Partial<MemoryOperations & { indirect: number }> = {}) {
+    const baseGasCost = mulGas(getBaseGasCost(this.opcode), this.copySize);
+    const memoryGasCost = getMemoryGasCost(memoryOps);
+    return sumGas(baseGasCost, memoryGasCost);
   }
 }

package/src/avm/opcodes/storage.ts

@@ -1,7 +1,8 @@
 import { Fr } from '@aztec/foundation/fields';
 
 import type { AvmContext } from '../avm_context.js';
-import { Field } from '../avm_memory_types.js';
+import { type Gas, getBaseGasCost, getMemoryGasCost, mulGas, sumGas } from '../avm_gas.js';
+import { Field, type MemoryOperations } from '../avm_memory_types.js';
 import { InstructionExecutionError } from '../errors.js';
 import { Opcode, OperandType } from '../serialization/instruction_serialization.js';
 import { Addressing } from './addressing_mode.js';
@@ -25,6 +26,12 @@ abstract class BaseStorageInstruction extends Instruction {
   ) {
     super();
   }
+
+  protected gasCost(memoryOps: Partial<MemoryOperations & { indirect: number }>): Gas {
+    const baseGasCost = mulGas(getBaseGasCost(this.opcode), this.size);
+    const memoryGasCost = getMemoryGasCost(memoryOps);
+    return sumGas(baseGasCost, memoryGasCost);
+  }
 }
 
 export class SStore extends BaseStorageInstruction {
@@ -35,24 +42,26 @@ export class SStore extends BaseStorageInstruction {
     super(indirect, srcOffset, srcSize, slotOffset);
   }
 
-  async execute(context: AvmContext): Promise<void> {
+  public async execute(context: AvmContext): Promise<void> {
     if (context.environment.isStaticCall) {
       throw new StaticCallStorageAlterError();
     }
 
-    const [srcOffset, slotOffset] = Addressing.fromWire(this.indirect).resolve(
-      [this.aOffset, this.bOffset],
-      context.machineState.memory,
-    );
+    const memoryOperations = { reads: this.size + 1, indirect: this.indirect };
+    const memory = context.machineState.memory.track(this.type);
+    context.machineState.consumeGas(this.gasCost(memoryOperations));
 
-    const slot = context.machineState.memory.get(slotOffset).toFr();
-    const data = context.machineState.memory.getSlice(srcOffset, this.size).map(field => field.toFr());
+    const [srcOffset, slotOffset] = Addressing.fromWire(this.indirect).resolve([this.aOffset, this.bOffset], memory);
+
+    const slot = memory.get(slotOffset).toFr();
+    const data = memory.getSlice(srcOffset, this.size).map(field => field.toFr());
 
     for (const [index, value] of Object.entries(data)) {
       const adjustedSlot = slot.add(new Fr(BigInt(index)));
       context.persistableState.writeStorage(context.environment.storageAddress, adjustedSlot, value);
     }
 
+    memory.assert(memoryOperations);
     context.machineState.incrementPc();
   }
 }
@@ -65,13 +74,17 @@ export class SLoad extends BaseStorageInstruction {
     super(indirect, slotOffset, size, dstOffset);
   }
 
-  async execute(context: AvmContext): Promise<void> {
+  public async execute(context: AvmContext): Promise<void> {
+    const memoryOperations = { writes: this.size, reads: 1, indirect: this.indirect };
+    const memory = context.machineState.memory.track(this.type);
+    context.machineState.consumeGas(this.gasCost(memoryOperations));
+
     const [aOffset, size, bOffset] = Addressing.fromWire(this.indirect).resolve(
       [this.aOffset, this.size, this.bOffset],
-      context.machineState.memory,
+      memory,
     );
 
-    const slot = context.machineState.memory.get(aOffset);
+    const slot = memory.get(aOffset);
 
     // Write each read value from storage into memory
     for (let i = 0; i < size; i++) {
@@ -80,10 +93,11 @@ export class SLoad extends BaseStorageInstruction {
         new Fr(slot.toBigInt() + BigInt(i)),
       );
 
-      context.machineState.memory.set(bOffset + i, new Field(data));
+      memory.set(bOffset + i, new Field(data));
     }
 
     context.machineState.incrementPc();
+    memory.assert(memoryOperations);
   }
 }
 

package/src/avm/serialization/bytecode_serialization.ts

@@ -1,3 +1,4 @@
+import { DAGasLeft, L1GasLeft, L2GasLeft } from '../opcodes/context_getters.js';
 import { Keccak, Pedersen, Poseidon2, Sha256 } from '../opcodes/hashing.js';
 import {
   Add,
@@ -18,6 +19,7 @@ import {
   FeePerL1Gas,
   FeePerL2Gas,
   FieldDiv,
+  GetContractInstance,
   InternalCall,
   InternalReturn,
   Jump,
@@ -101,9 +103,9 @@ const INSTRUCTION_SET = () =>
 
     // Machine State
     // Machine State - Gas
-    //[L1gasleft.opcode, L1gasleft],
-    //[L2gasleft.opcode, L2gasleft],
-    //[Dagasleft.opcode, Dagasleft],
+    [L1GasLeft.opcode, L1GasLeft],
+    [L2GasLeft.opcode, L2GasLeft],
+    [DAGasLeft.opcode, DAGasLeft],
     // Machine State - Internal Control Flow
     [Jump.opcode, Jump],
     [JumpI.opcode, JumpI],
@@ -126,6 +128,7 @@ const INSTRUCTION_SET = () =>
     // Accrued Substate
     [EmitUnencryptedLog.opcode, EmitUnencryptedLog],
     [SendL2ToL1Message.opcode, SendL2ToL1Message],
+    [GetContractInstance.opcode, GetContractInstance],
 
     // Control Flow - Contract Calls
     [Call.opcode, Call],

package/src/avm/serialization/instruction_serialization.ts

@@ -64,6 +64,7 @@ export enum Opcode {
   EMITNULLIFIER,
   L1TOL2MSGEXISTS,
   HEADERMEMBER,
+  GETCONTRACTINSTANCE,
   EMITUNENCRYPTEDLOG,
   SENDL2TOL1MSG,
   // External calls

package/src/client/client_execution_context.ts

@@ -235,7 +235,7 @@ export class ClientExecutionContext extends ViewDataOracle {
       offset,
     });
 
-    this.log(
+    this.log.debug(
       `Returning ${notes.length} notes for ${this.callContext.storageContractAddress} at ${storageSlot}: ${notes
         .map(n => `${n.nonce.toString()}:[${n.note.items.map(i => i.toString()).join(',')}]`)
         .join(', ')}`,
@@ -316,7 +316,7 @@ export class ClientExecutionContext extends ViewDataOracle {
   public emitUnencryptedLog(log: UnencryptedL2Log) {
     this.unencryptedLogs.push(log);
     const text = log.toHumanReadable();
-    this.log(`Emitted unencrypted log: "${text.length > 100 ? text.slice(0, 100) + '...' : text}"`);
+    this.log.verbose(`Emitted unencrypted log: "${text.length > 100 ? text.slice(0, 100) + '...' : text}"`);
   }
 
   #checkValidStaticCall(childExecutionResult: ExecutionResult) {
@@ -349,7 +349,7 @@ export class ClientExecutionContext extends ViewDataOracle {
     isStaticCall: boolean,
     isDelegateCall: boolean,
   ) {
-    this.log(
+    this.log.debug(
       `Calling private function ${this.contractAddress}:${functionSelector} from ${this.callContext.storageContractAddress}`,
     );
 
@@ -441,7 +441,7 @@ export class ClientExecutionContext extends ViewDataOracle {
     // side-effect counter, that will leak info about how many other private
     // side-effects occurred in the TX. Ultimately the private kernel should
     // just output everything in the proper order without any counters.
-    this.log(
+    this.log.verbose(
       `Enqueued call to public function (with side-effect counter #${sideEffectCounter}) ${targetContractAddress}:${functionSelector}(${targetArtifact.name})`,
     );
 
@@ -497,7 +497,7 @@ export class ClientExecutionContext extends ViewDataOracle {
         throw new Error(`No witness for slot ${storageSlot.toString()}`);
       }
       const value = witness.leafPreimage.value;
-      this.log(`Oracle storage read: slot=${storageSlot.toString()} value=${value}`);
+      this.log.debug(`Oracle storage read: slot=${storageSlot.toString()} value=${value}`);
       values.push(value);
     }
     return values;

package/src/client/private_execution.ts

@@ -1,5 +1,5 @@
 import { type FunctionData, PrivateCallStackItem, PrivateCircuitPublicInputs } from '@aztec/circuits.js';
-import { type FunctionArtifactWithDebugMetadata, decodeReturnValues } from '@aztec/foundation/abi';
+import { type AbiType, type FunctionArtifactWithDebugMetadata, decodeReturnValues } from '@aztec/foundation/abi';
 import { type AztecAddress } from '@aztec/foundation/aztec-address';
 import { Fr } from '@aztec/foundation/fields';
 import { createDebugLogger } from '@aztec/foundation/log';
@@ -22,7 +22,7 @@ export async function executePrivateFunction(
   log = createDebugLogger('aztec:simulator:secret_execution'),
 ): Promise<ExecutionResult> {
   const functionSelector = functionData.selector;
-  log(`Executing external function ${contractAddress}:${functionSelector}(${artifact.name})`);
+  log.verbose(`Executing external function ${contractAddress}:${functionSelector}(${artifact.name})`);
   const acir = artifact.bytecode;
   const initialWitness = context.getInitialWitness(artifact);
   const acvmCallback = new Oracle(context);
@@ -52,7 +52,13 @@ export async function executePrivateFunction(
   publicInputs.unencryptedLogPreimagesLength = new Fr(unencryptedLogs.getSerializedLength());
 
   const callStackItem = new PrivateCallStackItem(contractAddress, functionData, publicInputs);
-  const returnValues = decodeReturnValues(artifact, publicInputs.returnValues);
+
+  // Mocking the return type to be an array of 4 fields
+  // TODO: @LHerskind must be updated as we are progressing with the macros to get the information
+  const returnTypes: AbiType[] = [{ kind: 'array', length: 4, type: { kind: 'field' } }];
+  const mockArtifact = { ...artifact, returnTypes };
+  const returnValues = decodeReturnValues(mockArtifact, publicInputs.returnValues);
+
   const noteHashReadRequestPartialWitnesses = context.getNoteHashReadRequestPartialWitnesses(
     publicInputs.noteHashReadRequests,
   );
@@ -60,7 +66,7 @@ export async function executePrivateFunction(
   const nestedExecutions = context.getNestedExecutions();
   const enqueuedPublicFunctionCalls = context.getEnqueuedPublicFunctionCalls();
 
-  log(`Returning from call to ${contractAddress.toString()}:${functionSelector}`);
+  log.debug(`Returning from call to ${contractAddress.toString()}:${functionSelector}`);
 
   return {
     acir,

package/src/client/unconstrained_execution.ts

@@ -23,7 +23,7 @@ export async function executeUnconstrainedFunction(
   log = createDebugLogger('aztec:simulator:unconstrained_execution'),
 ): Promise<DecodedReturn> {
   const functionSelector = functionData.selector;
-  log(`Executing unconstrained function ${contractAddress}:${functionSelector}`);
+  log.verbose(`Executing unconstrained function ${contractAddress}:${functionSelector}(${artifact.name})`);
 
   const acir = artifact.bytecode;
   const initialWitness = toACVMWitness(0, args);