@aztec/simulator 0.0.0-test.0 → 0.0.1-commit.0208eb9

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);
+      }
+    }
   }
 }

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

@@ -5,7 +5,9 @@ import { Opcode, OperandType } from '../serialization/instruction_serialization.
 import { Addressing } from './addressing_mode.js';
 import { Instruction } from './instruction.js';
 
-abstract class BaseStorageInstruction extends Instruction {
+export class SStore extends Instruction {
+  static readonly type: string = 'SSTORE';
+  static readonly opcode = Opcode.SSTORE;
   // Informs (de)serialization. See Instruction.deserialize.
   public static readonly wireFormat: OperandType[] = [
     OperandType.UINT8,
@@ -14,18 +16,13 @@ abstract class BaseStorageInstruction extends Instruction {
     OperandType.UINT16,
   ];
 
-  constructor(protected indirect: number, protected aOffset: number, protected bOffset: number) {
+  constructor(
+    private addressingMode: number,
+    private srcOffset: number,
+    private slotOffset: number,
+  ) {
     super();
   }
-}
-
-export class SStore extends BaseStorageInstruction {
-  static readonly type: string = 'SSTORE';
-  static readonly opcode = Opcode.SSTORE;
-
-  constructor(indirect: number, srcOffset: number, slotOffset: number) {
-    super(indirect, srcOffset, slotOffset);
-  }
 
   public async execute(context: AvmContext): Promise<void> {
     if (context.environment.isStaticCall) {
@@ -33,39 +30,66 @@ export class SStore extends BaseStorageInstruction {
     }
 
     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.aOffset, this.bOffset];
-    const addressing = Addressing.fromWire(this.indirect, operands.length);
+    const operands = [this.srcOffset, this.slotOffset];
     const [srcOffset, slotOffset] = addressing.resolve(operands, memory);
+    // We read before tag checking since it's needed for gas cost calculation
+    const slot = memory.get(slotOffset).toFr();
+
+    context.machineState.consumeGas(
+      this.dynamicGasCost(Number(context.persistableState.isStorageCold(context.environment.address, slot))),
+    );
+
     memory.checkTag(TypeTag.FIELD, slotOffset);
     memory.checkTag(TypeTag.FIELD, srcOffset);
 
-    const slot = memory.get(slotOffset).toFr();
     const value = memory.get(srcOffset).toFr();
     await context.persistableState.writeStorage(context.environment.address, slot, value);
   }
 }
 
-export class SLoad extends BaseStorageInstruction {
+export class SLoad extends Instruction {
   static readonly type: string = 'SLOAD';
   static readonly opcode = Opcode.SLOAD;
+  // Informs (de)serialization. See Instruction.deserialize.
+  public static readonly wireFormat: OperandType[] = [
+    OperandType.UINT8,
+    OperandType.UINT8,
+    OperandType.UINT16,
+    OperandType.UINT16,
+    OperandType.UINT16,
+  ];
 
-  constructor(indirect: number, slotOffset: number, dstOffset: number) {
-    super(indirect, slotOffset, dstOffset);
+  constructor(
+    private addressingMode: number,
+    private slotOffset: number,
+    private contractAddressOffset: 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.aOffset, this.bOffset];
-    const addressing = Addressing.fromWire(this.indirect, operands.length);
-    const [slotOffset, dstOffset] = addressing.resolve(operands, memory);
+    const operands = [this.slotOffset, this.contractAddressOffset, this.dstOffset];
+    const [slotOffset, contractAddressOffset, dstOffset] = addressing.resolve(operands, memory);
     memory.checkTag(TypeTag.FIELD, slotOffset);
+    memory.checkTag(TypeTag.FIELD, contractAddressOffset);
 
     const slot = memory.get(slotOffset).toFr();
-    const value = await context.persistableState.readStorage(context.environment.address, slot);
+    const contractAddress = memory.get(contractAddressOffset).toAztecAddress();
+    const value = await context.persistableState.readStorage(contractAddress, slot);
     memory.set(dstOffset, new Field(value));
   }
 }

package/src/public/avm/revert_reason.ts

@@ -0,0 +1,58 @@
+import type { Fr } from '@aztec/foundation/curves/bn254';
+
+import type { AvmContext } from './avm_context.js';
+import { type AvmExecutionError, AvmRevertReason } from './errors.js';
+
+async function createRevertReason(message: string, revertData: Fr[], context: AvmContext): Promise<AvmRevertReason> {
+  // We drop the returnPc information.
+  const internalCallStack = context.machineState.internalCallStack.map(entry => entry.callPc);
+
+  // If we are reverting due to the same error that we have been tracking, we use the nested error as the cause.
+  let nestedError = undefined;
+  const revertDataEquals = (a: Fr[], b: Fr[]) => a.length === b.length && a.every((v, i) => v.equals(b[i]));
+  if (
+    context.machineState.collectedRevertInfo &&
+    revertDataEquals(context.machineState.collectedRevertInfo.revertDataRepresentative, revertData)
+  ) {
+    nestedError = context.machineState.collectedRevertInfo.recursiveRevertReason;
+    message = context.machineState.collectedRevertInfo.recursiveRevertReason.message;
+  }
+
+  const { functionSelector, functionName } = await context.persistableState.getPublicFunctionSelectorAndName(
+    context.environment,
+  );
+
+  return new AvmRevertReason(
+    message,
+    /*failingFunction=*/ {
+      contractAddress: context.environment.address,
+      functionSelector,
+      functionName,
+    },
+    /*noirCallStack=*/ [...internalCallStack, context.machineState.pc].map(pc => `0.${pc}`),
+    /*options=*/ { cause: nestedError },
+  );
+}
+
+/**
+ * Create a "revert reason" error for an exceptional halt.
+ *
+ * @param haltingError - the lower-level error causing the exceptional halt
+ * @param context - the context of the AVM execution used to extract the failingFunction and noirCallStack
+ */
+export async function revertReasonFromExceptionalHalt(
+  haltingError: AvmExecutionError,
+  context: AvmContext,
+): Promise<AvmRevertReason> {
+  return await createRevertReason(haltingError.message, [], context);
+}
+
+/**
+ * Create a "revert reason" error for an explicit revert (a root cause).
+ *
+ * @param revertData - output data of the explicit REVERT instruction
+ * @param context - the context of the AVM execution used to extract the failingFunction and noirCallStack
+ */
+export async function revertReasonFromExplicitRevert(revertData: Fr[], context: AvmContext): Promise<AvmRevertReason> {
+  return await createRevertReason('Assertion failed: ', revertData, context);
+}

package/src/public/avm/serialization/buffer_cursor.ts

@@ -2,7 +2,10 @@
  * A Buffer-like class that automatically advances the position.
  */
 export class BufferCursor {
-  constructor(private _buffer: Buffer, private _position: number = 0) {}
+  constructor(
+    private _buffer: Buffer,
+    private _position: number = 0,
+  ) {}
 
   public position(): number {
     return this._position;