@aztec/simulator 0.0.1-commit.4d3c002 → 0.0.1-commit.4d9804df

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

@@ -1,293 +0,0 @@
-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';
-import { Addressing } from './addressing_mode.js';
-import { Instruction } from './instruction.js';
-
-export class Set extends Instruction {
-  static readonly type: string = 'SET';
-  // Required for gas.
-  static readonly opcode: Opcode = Opcode.SET_8;
-
-  public static readonly wireFormat8: OperandType[] = [
-    OperandType.UINT8, // opcode
-    OperandType.UINT8, // addressing_mode
-    OperandType.UINT8, // dstOffset
-    OperandType.TAG, // tag
-    OperandType.UINT8, // const (value)
-  ];
-  public static readonly wireFormat16: OperandType[] = [
-    OperandType.UINT8, // opcode
-    OperandType.UINT8, // addressing_mode
-    OperandType.UINT16, // dstOffset
-    OperandType.TAG, // tag
-    OperandType.UINT16, // const (value)
-  ];
-  public static readonly wireFormat32: OperandType[] = [
-    OperandType.UINT8, // opcode
-    OperandType.UINT8, // addressing_mode
-    OperandType.UINT16, // dstOffset
-    OperandType.TAG, // tag
-    OperandType.UINT32, // const (value)
-  ];
-  public static readonly wireFormat64: OperandType[] = [
-    OperandType.UINT8, // opcode
-    OperandType.UINT8, // addressing_mode
-    OperandType.UINT16, // dstOffset
-    OperandType.TAG, // tag
-    OperandType.UINT64, // const (value)
-  ];
-  public static readonly wireFormat128: OperandType[] = [
-    OperandType.UINT8, // opcode
-    OperandType.UINT8, // addressing_mode
-    OperandType.UINT16, // dstOffset
-    OperandType.TAG, // tag
-    OperandType.UINT128, // const (value)
-  ];
-  public static readonly wireFormatFF: OperandType[] = [
-    OperandType.UINT8, // opcode
-    OperandType.UINT8, // addressing_mode
-    OperandType.UINT16, // dstOffset
-    OperandType.TAG, // tag
-    OperandType.FF, // const (value)
-  ];
-
-  constructor(
-    private addressingMode: number,
-    private dstOffset: number,
-    private inTag: number,
-    private value: bigint | number,
-  ) {
-    super();
-    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> {
-    // Constructor ensured that this.inTag is a valid tag
-    const res = TaggedMemory.buildFromTagTruncating(this.value, this.inTag);
-
-    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 [dstOffset] = addressing.resolve(operands, memory);
-    memory.set(dstOffset, res);
-  }
-}
-
-export class Cast extends Instruction {
-  static readonly type: string = 'CAST';
-  static readonly opcode = Opcode.CAST_8;
-
-  static readonly wireFormat8 = [
-    OperandType.UINT8,
-    OperandType.UINT8,
-    OperandType.UINT8,
-    OperandType.UINT8,
-    OperandType.TAG,
-  ];
-  static readonly wireFormat16 = [
-    OperandType.UINT8,
-    OperandType.UINT8,
-    OperandType.UINT16,
-    OperandType.UINT16,
-    OperandType.TAG,
-  ];
-
-  constructor(
-    private addressingMode: number,
-    private srcOffset: number,
-    private dstOffset: number,
-    private dstTag: 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.srcOffset, this.dstOffset];
-    const [srcOffset, dstOffset] = addressing.resolve(operands, memory);
-
-    const a = memory.get(srcOffset);
-    // Constructor ensured that this.dstTag is a valid tag
-    const casted = TaggedMemory.buildFromTagTruncating(a.toBigInt(), this.dstTag);
-
-    memory.set(dstOffset, casted);
-  }
-}
-
-export class Mov extends Instruction {
-  static readonly type: string = 'MOV';
-  // FIXME: This is needed for gas.
-  static readonly opcode: Opcode = Opcode.MOV_8;
-
-  static readonly wireFormat8: OperandType[] = [
-    OperandType.UINT8,
-    OperandType.UINT8,
-    OperandType.UINT8,
-    OperandType.UINT8,
-  ];
-  static readonly wireFormat16: OperandType[] = [
-    OperandType.UINT8,
-    OperandType.UINT8,
-    OperandType.UINT16,
-    OperandType.UINT16,
-  ];
-
-  constructor(
-    private addressingMode: number,
-    private srcOffset: 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.srcOffset, this.dstOffset];
-    const [srcOffset, dstOffset] = addressing.resolve(operands, memory);
-    const a = memory.get(srcOffset);
-    memory.set(dstOffset, a);
-  }
-}
-
-export class CalldataCopy extends Instruction {
-  static readonly type: string = 'CALLDATACOPY';
-  static readonly opcode: Opcode = Opcode.CALLDATACOPY;
-  // Informs (de)serialization. See Instruction.deserialize.
-  static readonly wireFormat: OperandType[] = [
-    OperandType.UINT8,
-    OperandType.UINT8,
-    OperandType.UINT16,
-    OperandType.UINT16,
-    OperandType.UINT16,
-  ];
-
-  constructor(
-    private addressingMode: number,
-    private copySizeOffset: number,
-    private cdStartOffset: 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.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.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));
-    // slice has size = MIN(copySize, calldata.length - cdStart) as TS truncates out-of-range portion
-    const transformedData = [...slice, ...Array(copySize - slice.length).fill(new Field(0))];
-
-    memory.setSlice(dstOffset, transformedData);
-  }
-}
-
-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 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 [dstOffset] = addressing.resolve(operands, memory);
-
-    memory.set(dstOffset, new Uint32(context.machineState.nestedReturndata.length()));
-  }
-}
-
-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 addressingMode: number,
-    private copySizeOffset: number,
-    private rdStartOffset: 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.copySizeOffset, this.rdStartOffset, this.dstOffset];
-    const [copySizeOffset, rdStartOffset, dstOffset] = addressing.resolve(operands, memory);
-
-    memory.checkTags(TypeTag.UINT32, rdStartOffset, copySizeOffset);
-    const copySize = memory.get(copySizeOffset).toNumber();
-    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));
-    // slice has size = MIN(copySize, returndata.length - rdStart) as TS truncates out-of-range portion
-    const transformedData = [...slice, ...Array(copySize - slice.length).fill(new Field(0))];
-
-    memory.setSlice(dstOffset, transformedData);
-  }
-}

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

@@ -1,102 +0,0 @@
-import { LogLevels, applyStringFormatting, createLogger } from '@aztec/foundation/log';
-
-import type { AvmContext } from '../avm_context.js';
-import { TypeTag } from '../avm_memory_types.js';
-import { Opcode, OperandType } from '../serialization/instruction_serialization.js';
-import { Addressing } from './addressing_mode.js';
-import { Instruction } from './instruction.js';
-
-export class DebugLog extends Instruction {
-  static type: string = 'DEBUGLOG';
-  static readonly opcode: Opcode = Opcode.DEBUGLOG;
-  static readonly logger = createLogger('simulator:avm:debug_log');
-
-  // Informs (de)serialization. See Instruction.deserialize.
-  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
-    OperandType.UINT16, // message size
-  ];
-
-  constructor(
-    private addressingMode: number,
-    private levelOffset: number,
-    private messageOffset: number,
-    private fieldsOffset: number,
-    private fieldsSizeOffset: number,
-    private messageSize: 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.levelOffset, this.messageOffset, this.fieldsOffset, this.fieldsSizeOffset];
-    const [levelOffset, messageOffset, fieldsOffset, fieldsSizeOffset] = addressing.resolve(operands, memory);
-
-    // 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();
-
-      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);
-
-      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[level](formattedStr);
-      }
-    }
-  }
-}

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

@@ -1,95 +0,0 @@
-import type { AvmContext } from '../avm_context.js';
-import { Field, TypeTag } from '../avm_memory_types.js';
-import { StaticCallAlterationError } from '../errors.js';
-import { Opcode, OperandType } from '../serialization/instruction_serialization.js';
-import { Addressing } from './addressing_mode.js';
-import { Instruction } from './instruction.js';
-
-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,
-    OperandType.UINT8,
-    OperandType.UINT16,
-    OperandType.UINT16,
-  ];
-
-  constructor(
-    private addressingMode: number,
-    private srcOffset: number,
-    private slotOffset: number,
-  ) {
-    super();
-  }
-
-  public async execute(context: AvmContext): Promise<void> {
-    if (context.environment.isStaticCall) {
-      throw new StaticCallAlterationError();
-    }
-
-    const memory = context.machineState.memory;
-    const addressing = Addressing.fromWire(this.addressingMode);
-
-    context.machineState.consumeGas(
-      this.baseGasCost(addressing.indirectOperandsCount(), addressing.relativeOperandsCount()),
-    );
-
-    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 value = memory.get(srcOffset).toFr();
-    await context.persistableState.writeStorage(context.environment.address, slot, value);
-  }
-}
-
-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(
-    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;
-    const addressing = Addressing.fromWire(this.addressingMode);
-
-    context.machineState.consumeGas(
-      this.baseGasCost(addressing.indirectOperandsCount(), addressing.relativeOperandsCount()),
-    );
-
-    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 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

@@ -1,58 +0,0 @@
-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

@@ -1,118 +0,0 @@
-/*
- * A Buffer-like class that automatically advances the position.
- */
-export class BufferCursor {
-  constructor(
-    private _buffer: Buffer,
-    private _position: number = 0,
-  ) {}
-
-  public position(): number {
-    return this._position;
-  }
-
-  public buffer(): Buffer {
-    return this._buffer;
-  }
-
-  public eof(): boolean {
-    return this._position === this._buffer.length;
-  }
-
-  public bufferAtPosition(): Buffer {
-    return this._buffer.subarray(this._position);
-  }
-
-  public advance(n: number): void {
-    this._position += n;
-  }
-
-  public peekUint8(): number {
-    const ret = this._buffer.readUint8(this._position);
-    return ret;
-  }
-
-  public readUint8(): number {
-    const ret = this._buffer.readUint8(this._position);
-    this._position += 1;
-    return ret;
-  }
-
-  public readUint16LE(): number {
-    const ret = this._buffer.readUint16LE(this._position);
-    this._position += 2;
-    return ret;
-  }
-
-  public readUint16BE(): number {
-    const ret = this._buffer.readUint16BE(this._position);
-    this._position += 2;
-    return ret;
-  }
-
-  public readUint32LE(): number {
-    const ret = this._buffer.readUint32LE(this._position);
-    this._position += 4;
-    return ret;
-  }
-
-  public readUint32BE(): number {
-    const ret = this._buffer.readUint32BE(this._position);
-    this._position += 4;
-    return ret;
-  }
-
-  public readBigInt64LE(): bigint {
-    const ret = this._buffer.readBigInt64LE(this._position);
-    this._position += 8;
-    return ret;
-  }
-
-  public readBigInt64BE(): bigint {
-    const ret = this._buffer.readBigInt64BE(this._position);
-    this._position += 8;
-    return ret;
-  }
-
-  public writeUint8(v: number) {
-    const ret = this._buffer.writeUint8(v, this._position);
-    this._position += 1;
-    return ret;
-  }
-
-  public writeUint16LE(v: number) {
-    const ret = this._buffer.writeUint16LE(v, this._position);
-    this._position += 2;
-    return ret;
-  }
-
-  public writeUint16BE(v: number) {
-    const ret = this._buffer.writeUint16BE(v, this._position);
-    this._position += 2;
-    return ret;
-  }
-
-  public writeUint32LE(v: number) {
-    const ret = this._buffer.writeUint32LE(v, this._position);
-    this._position += 4;
-    return ret;
-  }
-
-  public writeUint32BE(v: number) {
-    const ret = this._buffer.writeUint32BE(v, this._position);
-    this._position += 4;
-    return ret;
-  }
-
-  public writeBigInt64LE(v: bigint) {
-    const ret = this._buffer.writeBigInt64LE(v, this._position);
-    this._position += 8;
-    return ret;
-  }
-
-  public writeBigInt64BE(v: bigint) {
-    const ret = this._buffer.writeBigInt64BE(v, this._position);
-    this._position += 8;
-    return ret;
-  }
-}