@aztec/simulator 0.0.0-test.1 → 0.0.1-commit.017a351

package/src/public/avm/opcodes/hashing.ts

@@ -1,4 +1,6 @@
-import { keccakf1600, poseidon2Permutation, sha256Compression } from '@aztec/foundation/crypto';
+import { keccakf1600 } from '@aztec/foundation/crypto/keccak';
+import { poseidon2Permutation } from '@aztec/foundation/crypto/poseidon';
+import { sha256Compression } from '@aztec/foundation/crypto/sha256';
 
 import type { AvmContext } from '../avm_context.js';
 import { Field, TypeTag, Uint32, Uint64 } from '../avm_memory_types.js';
@@ -19,16 +21,24 @@ export class Poseidon2 extends Instruction {
     OperandType.UINT16,
   ];
 
-  constructor(private indirect: number, private inputStateOffset: number, private outputStateOffset: number) {
+  constructor(
+    private addressingMode: number,
+    private inputStateOffset: number,
+    private outputStateOffset: number,
+  ) {
     super();
   }
 
   public async execute(context: AvmContext): Promise<void> {
     const memory = context.machineState.memory;
-    context.machineState.consumeGas(this.gasCost());
+    const addressing = Addressing.fromWire(this.addressingMode);
+
+    context.machineState.consumeGas(
+      this.baseGasCost(addressing.indirectOperandsCount(), addressing.relativeOperandsCount()),
+    );
 
     const operands = [this.inputStateOffset, this.outputStateOffset];
-    const addressing = Addressing.fromWire(this.indirect, operands.length);
+
     const [inputOffset, outputOffset] = addressing.resolve(operands, memory);
 
     const inputState = memory.getSlice(inputOffset, Poseidon2.stateSize);
@@ -54,7 +64,11 @@ export class KeccakF1600 extends Instruction {
     OperandType.UINT16,
   ];
 
-  constructor(private indirect: number, private dstOffset: number, private inputOffset: number) {
+  constructor(
+    private addressingMode: number,
+    private dstOffset: number,
+    private inputOffset: number,
+  ) {
     super();
   }
 
@@ -62,10 +76,14 @@ export class KeccakF1600 extends Instruction {
   public async execute(context: AvmContext): Promise<void> {
     const inputSize = 25;
     const memory = context.machineState.memory;
+    const addressing = Addressing.fromWire(this.addressingMode);
+
+    context.machineState.consumeGas(
+      this.baseGasCost(addressing.indirectOperandsCount(), addressing.relativeOperandsCount()),
+    );
+
     const operands = [this.dstOffset, this.inputOffset];
-    const addressing = Addressing.fromWire(this.indirect, operands.length);
     const [dstOffset, inputOffset] = addressing.resolve(operands, memory);
-    context.machineState.consumeGas(this.gasCost());
 
     const stateData = memory.getSlice(inputOffset, inputSize).map(word => word.toBigInt());
     memory.checkTagsRange(TypeTag.UINT64, inputOffset, inputSize);
@@ -91,7 +109,7 @@ export class Sha256Compression extends Instruction {
   ];
 
   constructor(
-    private indirect: number,
+    private addressingMode: number,
     private outputOffset: number,
     private stateOffset: number,
     private inputsOffset: number,
@@ -104,19 +122,27 @@ export class Sha256Compression extends Instruction {
     const INPUTS_SIZE = 16;
 
     const memory = context.machineState.memory;
+    const addressing = Addressing.fromWire(this.addressingMode);
+
+    context.machineState.consumeGas(
+      this.baseGasCost(addressing.indirectOperandsCount(), addressing.relativeOperandsCount()),
+    );
+
     const operands = [this.outputOffset, this.stateOffset, this.inputsOffset];
-    const addressing = Addressing.fromWire(this.indirect, operands.length);
     const [outputOffset, stateOffset, inputsOffset] = addressing.resolve(operands, memory);
 
     // Note: size of output is same as size of state
-    context.machineState.consumeGas(this.gasCost());
-    const inputs = Uint32Array.from(memory.getSlice(inputsOffset, INPUTS_SIZE).map(word => word.toNumber()));
-    const state = Uint32Array.from(memory.getSlice(stateOffset, STATE_SIZE).map(word => word.toNumber()));
+    const inputs = memory.getSlice(inputsOffset, INPUTS_SIZE).map(word => word.toBigInt());
+    const state = memory.getSlice(stateOffset, STATE_SIZE).map(word => word.toBigInt());
 
     memory.checkTagsRange(TypeTag.UINT32, inputsOffset, INPUTS_SIZE);
     memory.checkTagsRange(TypeTag.UINT32, stateOffset, STATE_SIZE);
 
-    const output = sha256Compression(state, inputs);
+    // At this point both state and inputs are Uint32Array-compatible
+    const inputsArray = new Uint32Array(inputs.map(i => Number(i)));
+    const stateArray = new Uint32Array(state.map(i => Number(i)));
+
+    const output = sha256Compression(stateArray, inputsArray);
 
     // Conversion required from Uint32Array to Uint32[] (can't map directly, need `...`)
     const res = [...output].map(word => new Uint32(word));

package/src/public/avm/opcodes/instruction.ts

@@ -1,9 +1,10 @@
+import type { Bufferable } from '@aztec/foundation/serialize';
+
 import { strict as assert } from 'assert';
 
 import type { AvmContext } from '../avm_context.js';
-import { type Gas, getBaseGasCost, getDynamicGasCost, mulGas, sumGas } from '../avm_gas.js';
+import { type Gas, computeAddressingCost, getBaseGasCost, getDynamicGasCost, mulGas, sumGas } from '../avm_gas.js';
 import type { BufferCursor } from '../serialization/buffer_cursor.js';
-import type { Serializable } from '../serialization/bytecode_serialization.js';
 import { Opcode, type OperandType, deserialize, serializeAs } from '../serialization/instruction_serialization.js';
 
 type InstructionConstructor = {
@@ -35,6 +36,8 @@ export abstract class Instruction {
    * @returns Thee string representation.
    */
   public toString(): string {
+    // Note: we could have this be the actual wire opcode if `bytecode_serialization.ts` were to
+    // pass it into the class' static `Instruction.as(this, wireFormat)` method.
     let instructionStr = this.constructor.name + ': ';
     // assumes that all properties are flags or operands
     for (const prop of Object.getOwnPropertyNames(this) as (keyof Instruction)[]) {
@@ -44,19 +47,19 @@ export abstract class Instruction {
   }
 
   // Default deserialization which uses Class.opcode and Class.wireFormat.
-  public static deserialize(
+  public static fromBuffer(
     this: InstructionConstructor & { wireFormat: OperandType[]; as: any },
     buf: BufferCursor | Buffer,
   ): Instruction {
-    return this.as(this.wireFormat).deserialize(buf);
+    return this.as(this.wireFormat).fromBuffer(buf);
   }
 
   // Default serialization which uses Class.opcode and Class.wireFormat.
-  public serialize(): Buffer {
+  public toBuffer(): Buffer {
     const klass = this.constructor as any;
     assert(klass.opcode !== undefined && klass.opcode !== null);
     assert(klass.wireFormat !== undefined && klass.wireFormat !== null);
-    return this.as(klass.opcode, klass.wireFormat).serialize();
+    return this.as(klass.opcode, klass.wireFormat).toBuffer();
   }
 
   /**
@@ -65,8 +68,8 @@ export abstract class Instruction {
    * @param wireFormat The wire format of the instruction.
    * @returns The new instruction instance.
    */
-  public as(opcode: Opcode, wireFormat: OperandType[]): Instruction & Serializable {
-    return Object.defineProperty(this, 'serialize', {
+  public as(opcode: Opcode, wireFormat: OperandType[]): Instruction & Bufferable {
+    return Object.defineProperty(this, 'toBuffer', {
       value: (): Buffer => {
         return serializeAs(wireFormat, opcode, this);
       },
@@ -82,7 +85,7 @@ export abstract class Instruction {
    */
   public static as(this: InstructionConstructor, wireFormat: OperandType[]) {
     return Object.assign(this, {
-      deserialize: (buf: BufferCursor | Buffer): Instruction => {
+      fromBuffer: (buf: BufferCursor | Buffer): Instruction => {
         const res = deserialize(buf, wireFormat);
         const args = res.slice(1); // Remove opcode.
         return new this(...args);
@@ -91,13 +94,20 @@ export abstract class Instruction {
   }
 
   /**
-   * Computes gas cost for the instruction based on its base cost and memory operations.
-   * @returns Gas cost.
+   * Returns the base gas cost for the instruction.
+   * @returns The base gas cost.
    */
-  protected gasCost(dynMultiplier: number = 0): Gas {
-    const baseGasCost = getBaseGasCost(this.opcode);
-    const dynGasCost = mulGas(getDynamicGasCost(this.opcode), dynMultiplier);
-    return sumGas(baseGasCost, dynGasCost);
+  protected baseGasCost(indirectOperandsCount: number, relativeOperandsCount: number): Gas {
+    return sumGas(getBaseGasCost(this.opcode), computeAddressingCost(indirectOperandsCount, relativeOperandsCount));
+  }
+
+  /**
+   * Computes the dynamic gas cost for the instruction
+   * @param dynMultiplier - The multiplier for the dynamic gas cost.
+   * @returns The dynamic gas cost.
+   */
+  protected dynamicGasCost(dynMultiplier: number = 0): Gas {
+    return mulGas(getDynamicGasCost(this.opcode), dynMultiplier);
   }
 
   /**
@@ -106,9 +116,7 @@ export abstract class Instruction {
    */
   public get type(): string {
     const type = 'type' in this.constructor && (this.constructor.type as string);
-    if (!type) {
-      throw new Error(`Instruction class ${this.constructor.name} does not have a static 'type' property defined.`);
-    }
+    assert(!!type, `Instruction class ${this.constructor.name} does not have a static 'type' property defined.`);
     return type;
   }
 
@@ -118,9 +126,11 @@ export abstract class Instruction {
    */
   public get opcode(): Opcode {
     const opcode = 'opcode' in this.constructor ? (this.constructor.opcode as Opcode) : undefined;
-    if (opcode === undefined || Opcode[opcode] === undefined) {
-      throw new Error(`Instruction class ${this.constructor.name} does not have a static 'opcode' property defined.`);
-    }
+    assert(
+      opcode !== undefined,
+      `Instruction class ${this.constructor.name} does not have a static 'opcode' property defined.`,
+    );
+    assert(Opcode[opcode] !== undefined, `Invalid opcode ${opcode} for instruction class ${this.constructor.name}.`);
     return opcode;
   }
 }

package/src/public/avm/opcodes/instruction_impl.ts

@@ -19,14 +19,14 @@ export const ThreeOperandWireFormat16 = [
 
 /**
  * Covers (de)serialization for an instruction with:
- * indirect, inTag, and three operands.
+ * addressing mode, inTag, and three operands.
  */
 export abstract class ThreeOperandInstruction extends Instruction {
   static readonly wireFormat8: OperandType[] = ThreeOperandWireFormat8;
   static readonly wireFormat16: OperandType[] = ThreeOperandWireFormat16;
 
   constructor(
-    protected indirect: number,
+    protected addressingMode: number,
     protected aOffset: number,
     protected bOffset: number,
     protected dstOffset: number,

package/src/public/avm/opcodes/memory.ts

@@ -1,3 +1,7 @@
+import { Fr } from '@aztec/foundation/curves/bn254';
+
+import { strict as assert } from 'assert';
+
 import type { AvmContext } from '../avm_context.js';
 import { Field, TaggedMemory, TypeTag, Uint32 } from '../avm_memory_types.js';
 import { Opcode, OperandType } from '../serialization/instruction_serialization.js';
@@ -11,55 +15,56 @@ export class Set extends Instruction {
 
   public static readonly wireFormat8: OperandType[] = [
     OperandType.UINT8, // opcode
-    OperandType.UINT8, // indirect
+    OperandType.UINT8, // addressing_mode
     OperandType.UINT8, // dstOffset
-    OperandType.UINT8, // tag
+    OperandType.TAG, // tag
     OperandType.UINT8, // const (value)
   ];
   public static readonly wireFormat16: OperandType[] = [
     OperandType.UINT8, // opcode
-    OperandType.UINT8, // indirect
+    OperandType.UINT8, // addressing_mode
     OperandType.UINT16, // dstOffset
-    OperandType.UINT8, // tag
+    OperandType.TAG, // tag
     OperandType.UINT16, // const (value)
   ];
   public static readonly wireFormat32: OperandType[] = [
     OperandType.UINT8, // opcode
-    OperandType.UINT8, // indirect
+    OperandType.UINT8, // addressing_mode
     OperandType.UINT16, // dstOffset
-    OperandType.UINT8, // tag
+    OperandType.TAG, // tag
     OperandType.UINT32, // const (value)
   ];
   public static readonly wireFormat64: OperandType[] = [
     OperandType.UINT8, // opcode
-    OperandType.UINT8, // indirect
+    OperandType.UINT8, // addressing_mode
     OperandType.UINT16, // dstOffset
-    OperandType.UINT8, // tag
+    OperandType.TAG, // tag
     OperandType.UINT64, // const (value)
   ];
   public static readonly wireFormat128: OperandType[] = [
     OperandType.UINT8, // opcode
-    OperandType.UINT8, // indirect
+    OperandType.UINT8, // addressing_mode
     OperandType.UINT16, // dstOffset
-    OperandType.UINT8, // tag
+    OperandType.TAG, // tag
     OperandType.UINT128, // const (value)
   ];
   public static readonly wireFormatFF: OperandType[] = [
     OperandType.UINT8, // opcode
-    OperandType.UINT8, // indirect
+    OperandType.UINT8, // addressing_mode
     OperandType.UINT16, // dstOffset
-    OperandType.UINT8, // tag
+    OperandType.TAG, // tag
     OperandType.FF, // const (value)
   ];
 
   constructor(
-    private indirect: number,
+    private addressingMode: number,
     private dstOffset: number,
     private inTag: number,
     private value: bigint | number,
   ) {
     super();
-    TaggedMemory.checkIsValidTag(inTag);
+    assert(this.value >= 0, `Value ${this.value} is negative`);
+    assert(this.value < Fr.MODULUS, `Value ${this.value} is larger than Fr.MODULUS`);
   }
 
   public async execute(context: AvmContext): Promise<void> {
@@ -67,10 +72,13 @@ export class Set extends Instruction {
     const res = TaggedMemory.buildFromTagTruncating(this.value, this.inTag);
 
     const memory = context.machineState.memory;
-    context.machineState.consumeGas(this.gasCost());
+    const addressing = Addressing.fromWire(this.addressingMode);
+
+    context.machineState.consumeGas(
+      this.baseGasCost(addressing.indirectOperandsCount(), addressing.relativeOperandsCount()),
+    );
 
     const operands = [this.dstOffset];
-    const addressing = Addressing.fromWire(this.indirect, operands.length);
     const [dstOffset] = addressing.resolve(operands, memory);
     memory.set(dstOffset, res);
   }
@@ -85,27 +93,34 @@ export class Cast extends Instruction {
     OperandType.UINT8,
     OperandType.UINT8,
     OperandType.UINT8,
-    OperandType.UINT8,
+    OperandType.TAG,
   ];
   static readonly wireFormat16 = [
     OperandType.UINT8,
     OperandType.UINT8,
     OperandType.UINT16,
     OperandType.UINT16,
-    OperandType.UINT8,
+    OperandType.TAG,
   ];
 
-  constructor(private indirect: number, private srcOffset: number, private dstOffset: number, private dstTag: number) {
+  constructor(
+    private addressingMode: number,
+    private srcOffset: number,
+    private dstOffset: number,
+    private dstTag: number,
+  ) {
     super();
-    TaggedMemory.checkIsValidTag(dstTag);
   }
 
   public async execute(context: AvmContext): Promise<void> {
     const memory = context.machineState.memory;
-    context.machineState.consumeGas(this.gasCost());
+    const addressing = Addressing.fromWire(this.addressingMode);
+
+    context.machineState.consumeGas(
+      this.baseGasCost(addressing.indirectOperandsCount(), addressing.relativeOperandsCount()),
+    );
 
     const operands = [this.srcOffset, this.dstOffset];
-    const addressing = Addressing.fromWire(this.indirect, operands.length);
     const [srcOffset, dstOffset] = addressing.resolve(operands, memory);
 
     const a = memory.get(srcOffset);
@@ -134,16 +149,23 @@ export class Mov extends Instruction {
     OperandType.UINT16,
   ];
 
-  constructor(private indirect: number, private srcOffset: number, private dstOffset: number) {
+  constructor(
+    private addressingMode: number,
+    private srcOffset: number,
+    private dstOffset: number,
+  ) {
     super();
   }
 
   public async execute(context: AvmContext): Promise<void> {
     const memory = context.machineState.memory;
-    context.machineState.consumeGas(this.gasCost());
+    const addressing = Addressing.fromWire(this.addressingMode);
+
+    context.machineState.consumeGas(
+      this.baseGasCost(addressing.indirectOperandsCount(), addressing.relativeOperandsCount()),
+    );
 
     const operands = [this.srcOffset, this.dstOffset];
-    const addressing = Addressing.fromWire(this.indirect, operands.length);
     const [srcOffset, dstOffset] = addressing.resolve(operands, memory);
     const a = memory.get(srcOffset);
     memory.set(dstOffset, a);
@@ -163,9 +185,9 @@ export class CalldataCopy extends Instruction {
   ];
 
   constructor(
-    private indirect: number,
-    private cdStartOffset: number,
+    private addressingMode: number,
     private copySizeOffset: number,
+    private cdStartOffset: number,
     private dstOffset: number,
   ) {
     super();
@@ -173,14 +195,19 @@ export class CalldataCopy extends Instruction {
 
   public async execute(context: AvmContext): Promise<void> {
     const memory = context.machineState.memory;
-    const operands = [this.cdStartOffset, this.copySizeOffset, this.dstOffset];
-    const addressing = Addressing.fromWire(this.indirect, operands.length);
-    const [cdStartOffset, copySizeOffset, dstOffset] = addressing.resolve(operands, memory);
+    const addressing = Addressing.fromWire(this.addressingMode);
+
+    context.machineState.consumeGas(
+      this.baseGasCost(addressing.indirectOperandsCount(), addressing.relativeOperandsCount()),
+    );
+
+    const operands = [this.copySizeOffset, this.cdStartOffset, this.dstOffset];
+    const [copySizeOffset, cdStartOffset, 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));
+    context.machineState.consumeGas(this.dynamicGasCost(copySize));
 
     // Values which are out-of-range of the calldata array will be set with Field(0);
     const slice = context.environment.calldata.slice(cdStart, cdStart + copySize).map(f => new Field(f));
@@ -197,18 +224,25 @@ export class ReturndataSize extends Instruction {
   // Informs (de)serialization. See Instruction.deserialize.
   static readonly wireFormat: OperandType[] = [OperandType.UINT8, OperandType.UINT8, OperandType.UINT16];
 
-  constructor(private indirect: number, private dstOffset: number) {
+  constructor(
+    private addressingMode: number,
+    private dstOffset: number,
+  ) {
     super();
   }
 
   public async execute(context: AvmContext): Promise<void> {
     const memory = context.machineState.memory;
+    const addressing = Addressing.fromWire(this.addressingMode);
+
+    context.machineState.consumeGas(
+      this.baseGasCost(addressing.indirectOperandsCount(), addressing.relativeOperandsCount()),
+    );
+
     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.set(dstOffset, new Uint32(context.machineState.nestedReturndata.length()));
   }
 }
 
@@ -225,9 +259,9 @@ export class ReturndataCopy extends Instruction {
   ];
 
   constructor(
-    private indirect: number,
-    private rdStartOffset: number,
+    private addressingMode: number,
     private copySizeOffset: number,
+    private rdStartOffset: number,
     private dstOffset: number,
   ) {
     super();
@@ -235,14 +269,19 @@ export class ReturndataCopy extends Instruction {
 
   public async execute(context: AvmContext): Promise<void> {
     const memory = context.machineState.memory;
-    const operands = [this.rdStartOffset, this.copySizeOffset, this.dstOffset];
-    const addressing = Addressing.fromWire(this.indirect, operands.length);
-    const [rdStartOffset, copySizeOffset, dstOffset] = addressing.resolve(operands, memory);
+    const addressing = Addressing.fromWire(this.addressingMode);
+
+    context.machineState.consumeGas(
+      this.baseGasCost(addressing.indirectOperandsCount(), addressing.relativeOperandsCount()),
+    );
+
+    const operands = [this.copySizeOffset, this.rdStartOffset, this.dstOffset];
+    const [copySizeOffset, rdStartOffset, 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 rdStart = memory.get(rdStartOffset).toNumber();
+    context.machineState.consumeGas(this.dynamicGasCost(copySize));
 
     // Values which are out-of-range of the returndata array will be set with Field(0);
     const slice = context.machineState.nestedReturndata.slice(rdStart, rdStart + copySize).map(f => new Field(f));

package/src/public/avm/opcodes/misc.ts

@@ -1,4 +1,4 @@
-import { applyStringFormatting, createLogger } from '@aztec/foundation/log';
+import { LogLevels, applyStringFormatting, createLogger } from '@aztec/foundation/log';
 
 import type { AvmContext } from '../avm_context.js';
 import { TypeTag } from '../avm_memory_types.js';
@@ -15,6 +15,7 @@ export class DebugLog extends Instruction {
   static readonly wireFormat: OperandType[] = [
     OperandType.UINT8, // Opcode
     OperandType.UINT8, // Indirect
+    OperandType.UINT16, // level memory address
     OperandType.UINT16, // message memory address
     OperandType.UINT16, // fields memory address
     OperandType.UINT16, // fields size address
@@ -22,7 +23,8 @@ export class DebugLog extends Instruction {
   ];
 
   constructor(
-    private indirect: number,
+    private addressingMode: number,
+    private levelOffset: number,
     private messageOffset: number,
     private fieldsOffset: number,
     private fieldsSizeOffset: number,
@@ -33,28 +35,68 @@ export class DebugLog extends Instruction {
 
   public async execute(context: AvmContext): Promise<void> {
     const memory = context.machineState.memory;
-    const operands = [this.messageOffset, this.fieldsOffset, this.fieldsSizeOffset];
-    const addressing = Addressing.fromWire(this.indirect, operands.length);
-    const [messageOffset, fieldsOffset, fieldsSizeOffset] = addressing.resolve(operands, memory);
+    const addressing = Addressing.fromWire(this.addressingMode);
 
-    memory.checkTag(TypeTag.UINT32, fieldsSizeOffset);
-    const fieldsSize = memory.get(fieldsSizeOffset).toNumber();
+    context.machineState.consumeGas(
+      this.baseGasCost(addressing.indirectOperandsCount(), addressing.relativeOperandsCount()),
+    );
 
-    const rawMessage = memory.getSlice(messageOffset, this.messageSize);
-    const fields = memory.getSlice(fieldsOffset, fieldsSize);
+    const operands = [this.levelOffset, this.messageOffset, this.fieldsOffset, this.fieldsSizeOffset];
+    const [levelOffset, messageOffset, fieldsOffset, fieldsSizeOffset] = addressing.resolve(operands, memory);
 
-    memory.checkTagsRange(TypeTag.UINT8, messageOffset, this.messageSize);
-    memory.checkTagsRange(TypeTag.FIELD, fieldsOffset, fieldsSize);
+    // DebugLog is a no-op except unless the config is set to collect debug logs.
+    // Note that we still do address resolution and basic tag-checking (above)
+    // To avoid a special-case in the witness generator and circuit.
+    if (context.environment.config.collectDebugLogs) {
+      memory.checkTag(TypeTag.UINT8, levelOffset);
+      const levelNumber = memory.get(levelOffset).toNumber();
+      memory.checkTag(TypeTag.UINT32, fieldsSizeOffset);
+      const fieldsSize = memory.get(fieldsSizeOffset).toNumber();
 
-    context.machineState.consumeGas(this.gasCost(this.messageSize + fieldsSize));
+      const memoryReads = 1 /* level */ + 1 /* fieldsSize */ + this.messageSize /* message */ + fieldsSize; /* fields */
+      if (
+        context.persistableState.getDebugLogMemoryReads() + memoryReads >
+        context.environment.config.collectionLimits.maxDebugLogMemoryReads
+      ) {
+        // Regular error on purpose: this is not a recoverable error.
+        throw new Error(
+          `Max debug log memory reads exceeded: ${context.persistableState.getDebugLogMemoryReads() + memoryReads} > ${context.environment.config.collectionLimits.maxDebugLogMemoryReads}`,
+        );
+      }
+      context.persistableState.writeDebugLogMemoryReads(memoryReads);
 
-    // Interpret str<N> = [u8; N] to string.
-    const messageAsStr = rawMessage.map(field => String.fromCharCode(field.toNumber())).join('');
-    const formattedStr = applyStringFormatting(
-      messageAsStr,
-      fields.map(field => field.toFr()),
-    );
+      const rawMessage = memory.getSlice(messageOffset, this.messageSize);
+      const fields = memory.getSlice(fieldsOffset, fieldsSize);
+
+      memory.checkTagsRange(TypeTag.UINT8, messageOffset, this.messageSize);
+      memory.checkTagsRange(TypeTag.FIELD, fieldsOffset, fieldsSize);
+
+      // Interpret str<N> = [u8; N] to string.
+      const messageAsStr = rawMessage.map(field => String.fromCharCode(field.toNumber())).join('');
+
+      if (!LogLevels[levelNumber]) {
+        // Regular error on purpose: this is not a recoverable error.
+        throw new Error(`Invalid debug log level: ${levelNumber}`);
+      }
+
+      const level = LogLevels[levelNumber];
+
+      context.persistableState.writeDebugLog(
+        context.environment.address,
+        level,
+        messageAsStr,
+        fields.map(field => field.toFr()),
+      );
+
+      // Skips string formatting if the level is disabled.
+      if (DebugLog.logger.isLevelEnabled(level)) {
+        const formattedStr = applyStringFormatting(
+          messageAsStr,
+          fields.map(field => field.toFr()),
+        );
 
-    DebugLog.logger.verbose(formattedStr);
+        DebugLog.logger[level](formattedStr);
+      }
+    }
   }
 }