@aztec/simulator 0.0.1-commit.d431d1c → 0.0.1-commit.d58ff9d0

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,87 +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';
-
-abstract class BaseStorageInstruction extends Instruction {
-  // Informs (de)serialization. See Instruction.deserialize.
-  public static readonly wireFormat: OperandType[] = [
-    OperandType.UINT8,
-    OperandType.UINT8,
-    OperandType.UINT16,
-    OperandType.UINT16,
-  ];
-
-  constructor(
-    protected addressingMode: number,
-    protected aOffset: number,
-    protected bOffset: number,
-  ) {
-    super();
-  }
-}
-
-export class SStore extends BaseStorageInstruction {
-  static readonly type: string = 'SSTORE';
-  static readonly opcode = Opcode.SSTORE;
-
-  constructor(addressingMode: number, srcOffset: number, slotOffset: number) {
-    super(addressingMode, srcOffset, slotOffset);
-  }
-
-  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.aOffset, this.bOffset];
-    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 BaseStorageInstruction {
-  static readonly type: string = 'SLOAD';
-  static readonly opcode = Opcode.SLOAD;
-
-  constructor(addressingMode: number, slotOffset: number, dstOffset: number) {
-    super(addressingMode, slotOffset, dstOffset);
-  }
-
-  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.aOffset, this.bOffset];
-    const [slotOffset, dstOffset] = addressing.resolve(operands, memory);
-    memory.checkTag(TypeTag.FIELD, slotOffset);
-
-    const slot = memory.get(slotOffset).toFr();
-    const value = await context.persistableState.readStorage(context.environment.address, 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;
-  }
-}

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

@@ -1,215 +0,0 @@
-import { type Bufferable, serializeToBuffer } from '@aztec/foundation/serialize';
-
-import {
-  AvmExecutionError,
-  AvmParsingError,
-  InvalidOpcodeError,
-  InvalidProgramCounterError,
-  InvalidTagValueError,
-  duringInstrFetch,
-} from '../errors.js';
-import {
-  Add,
-  And,
-  Call,
-  CalldataCopy,
-  Cast,
-  DebugLog,
-  Div,
-  EcAdd,
-  EmitNoteHash,
-  EmitNullifier,
-  EmitUnencryptedLog,
-  Eq,
-  FieldDiv,
-  GetContractInstance,
-  GetEnvVar,
-  Instruction,
-  InternalCall,
-  InternalReturn,
-  Jump,
-  JumpI,
-  KeccakF1600,
-  L1ToL2MessageExists,
-  Lt,
-  Lte,
-  Mov,
-  Mul,
-  Not,
-  NoteHashExists,
-  NullifierExists,
-  Or,
-  Poseidon2,
-  Return,
-  ReturndataCopy,
-  ReturndataSize,
-  Revert,
-  SLoad,
-  SStore,
-  SendL2ToL1Message,
-  Set,
-  Sha256Compression,
-  Shl,
-  Shr,
-  StaticCall,
-  Sub,
-  SuccessCopy,
-  ToRadixBE,
-  Xor,
-} from '../opcodes/index.js';
-import { BufferCursor } from './buffer_cursor.js';
-import { MAX_OPCODE_VALUE, Opcode } from './instruction_serialization.js';
-
-export type InstructionDeserializer = (buf: BufferCursor | Buffer) => Instruction;
-
-export interface Deserializable {
-  deserialize: InstructionDeserializer;
-}
-
-export type InstructionSet = Map<Opcode, InstructionDeserializer>;
-export const INSTRUCTION_SET = new Map<Opcode, InstructionDeserializer>([
-  [Opcode.ADD_8, Add.as(Add.wireFormat8).fromBuffer],
-  [Opcode.ADD_16, Add.as(Add.wireFormat16).fromBuffer],
-  [Opcode.SUB_8, Sub.as(Sub.wireFormat8).fromBuffer],
-  [Opcode.SUB_16, Sub.as(Sub.wireFormat16).fromBuffer],
-  [Opcode.MUL_8, Mul.as(Mul.wireFormat8).fromBuffer],
-  [Opcode.MUL_16, Mul.as(Mul.wireFormat16).fromBuffer],
-  [Opcode.DIV_8, Div.as(Div.wireFormat8).fromBuffer],
-  [Opcode.DIV_16, Div.as(Div.wireFormat16).fromBuffer],
-  [Opcode.FDIV_8, FieldDiv.as(FieldDiv.wireFormat8).fromBuffer],
-  [Opcode.FDIV_16, FieldDiv.as(FieldDiv.wireFormat16).fromBuffer],
-  [Opcode.EQ_8, Eq.as(Eq.wireFormat8).fromBuffer],
-  [Opcode.EQ_16, Eq.as(Eq.wireFormat16).fromBuffer],
-  [Opcode.LT_8, Lt.as(Lt.wireFormat8).fromBuffer],
-  [Opcode.LT_16, Lt.as(Lt.wireFormat16).fromBuffer],
-  [Opcode.LTE_8, Lte.as(Lte.wireFormat8).fromBuffer],
-  [Opcode.LTE_16, Lte.as(Lte.wireFormat16).fromBuffer],
-  [Opcode.AND_8, And.as(And.wireFormat8).fromBuffer],
-  [Opcode.AND_16, And.as(And.wireFormat16).fromBuffer],
-  [Opcode.OR_8, Or.as(Or.wireFormat8).fromBuffer],
-  [Opcode.OR_16, Or.as(Or.wireFormat16).fromBuffer],
-  [Opcode.XOR_8, Xor.as(Xor.wireFormat8).fromBuffer],
-  [Opcode.XOR_16, Xor.as(Xor.wireFormat16).fromBuffer],
-  [Opcode.NOT_8, Not.as(Not.wireFormat8).fromBuffer],
-  [Opcode.NOT_16, Not.as(Not.wireFormat16).fromBuffer],
-  [Opcode.SHL_8, Shl.as(Shl.wireFormat8).fromBuffer],
-  [Opcode.SHL_16, Shl.as(Shl.wireFormat16).fromBuffer],
-  [Opcode.SHR_8, Shr.as(Shr.wireFormat8).fromBuffer],
-  [Opcode.SHR_16, Shr.as(Shr.wireFormat16).fromBuffer],
-  [Opcode.CAST_8, Cast.as(Cast.wireFormat8).fromBuffer],
-  [Opcode.CAST_16, Cast.as(Cast.wireFormat16).fromBuffer],
-  // Execution Environment
-  [Opcode.GETENVVAR_16, GetEnvVar.as(GetEnvVar.wireFormat16).fromBuffer],
-  [CalldataCopy.opcode, Instruction.fromBuffer.bind(CalldataCopy)],
-  [SuccessCopy.opcode, Instruction.fromBuffer.bind(SuccessCopy)],
-  [Opcode.RETURNDATASIZE, Instruction.fromBuffer.bind(ReturndataSize)],
-  [Opcode.RETURNDATACOPY, Instruction.fromBuffer.bind(ReturndataCopy)],
-
-  // Machine State - Internal Control Flow
-  [Jump.opcode, Instruction.fromBuffer.bind(Jump)],
-  [JumpI.opcode, Instruction.fromBuffer.bind(JumpI)],
-  [InternalCall.opcode, Instruction.fromBuffer.bind(InternalCall)],
-  [InternalReturn.opcode, Instruction.fromBuffer.bind(InternalReturn)],
-  [Opcode.SET_8, Set.as(Set.wireFormat8).fromBuffer],
-  [Opcode.SET_16, Set.as(Set.wireFormat16).fromBuffer],
-  [Opcode.SET_32, Set.as(Set.wireFormat32).fromBuffer],
-  [Opcode.SET_64, Set.as(Set.wireFormat64).fromBuffer],
-  [Opcode.SET_128, Set.as(Set.wireFormat128).fromBuffer],
-  [Opcode.SET_FF, Set.as(Set.wireFormatFF).fromBuffer],
-  [Opcode.MOV_8, Mov.as(Mov.wireFormat8).fromBuffer],
-  [Opcode.MOV_16, Mov.as(Mov.wireFormat16).fromBuffer],
-
-  // World State
-  [SLoad.opcode, Instruction.fromBuffer.bind(SLoad)], // Public Storage
-  [SStore.opcode, Instruction.fromBuffer.bind(SStore)], // Public Storage
-  [NoteHashExists.opcode, Instruction.fromBuffer.bind(NoteHashExists)], // Notes & Nullifiers
-  [EmitNoteHash.opcode, Instruction.fromBuffer.bind(EmitNoteHash)], // Notes & Nullifiers
-  [NullifierExists.opcode, Instruction.fromBuffer.bind(NullifierExists)], // Notes & Nullifiers
-  [EmitNullifier.opcode, Instruction.fromBuffer.bind(EmitNullifier)], // Notes & Nullifiers
-  [L1ToL2MessageExists.opcode, Instruction.fromBuffer.bind(L1ToL2MessageExists)], // Messages
-
-  // Accrued Substate
-  [EmitUnencryptedLog.opcode, Instruction.fromBuffer.bind(EmitUnencryptedLog)],
-  [SendL2ToL1Message.opcode, Instruction.fromBuffer.bind(SendL2ToL1Message)],
-  [GetContractInstance.opcode, Instruction.fromBuffer.bind(GetContractInstance)],
-
-  // Control Flow - Contract Calls
-  [Call.opcode, Instruction.fromBuffer.bind(Call)],
-  [StaticCall.opcode, Instruction.fromBuffer.bind(StaticCall)],
-  [Return.opcode, Instruction.fromBuffer.bind(Return)],
-  [Opcode.REVERT_8, Revert.as(Revert.wireFormat8).fromBuffer],
-  [Opcode.REVERT_16, Revert.as(Revert.wireFormat16).fromBuffer],
-
-  // Misc
-  [DebugLog.opcode, Instruction.fromBuffer.bind(DebugLog)],
-
-  // Gadgets
-  [EcAdd.opcode, Instruction.fromBuffer.bind(EcAdd)],
-  [Poseidon2.opcode, Instruction.fromBuffer.bind(Poseidon2)],
-  [Sha256Compression.opcode, Instruction.fromBuffer.bind(Sha256Compression)],
-  [KeccakF1600.opcode, Instruction.fromBuffer.bind(KeccakF1600)],
-
-  // Conversions
-  [ToRadixBE.opcode, Instruction.fromBuffer.bind(ToRadixBE)],
-]);
-
-/**
- * Serializes an array of instructions to bytecode.
- */
-export function encodeToBytecode(instructions: Bufferable[]): Buffer {
-  return serializeToBuffer(instructions);
-}
-
-// For testing only
-export function decodeFromBytecode(bytecode: Buffer, instructionSet: InstructionSet = INSTRUCTION_SET): Instruction[] {
-  const instructions: Instruction[] = [];
-  let pc = 0;
-  while (pc < bytecode.length) {
-    const [instruction, bytesConsumed] = decodeInstructionFromBytecode(bytecode, pc, instructionSet);
-    instructions.push(instruction);
-    pc += bytesConsumed;
-  }
-  return instructions;
-}
-
-// Returns the instruction and the number of bytes consumed.
-export function decodeInstructionFromBytecode(
-  bytecode: Buffer,
-  pc: number,
-  instructionSet: InstructionSet = INSTRUCTION_SET,
-): [Instruction, number] {
-  if (pc >= bytecode.length) {
-    throw new InvalidProgramCounterError(pc, bytecode.length - 1);
-  }
-
-  try {
-    const cursor = new BufferCursor(bytecode, pc);
-    const startingPosition = cursor.position();
-    const opcode: number = cursor.bufferAtPosition().readUint8(); // peek.
-
-    if (opcode > MAX_OPCODE_VALUE) {
-      throw new InvalidOpcodeError(
-        `Opcode ${opcode} (0x${opcode.toString(16)}) value is not in the range of valid opcodes (at PC ${pc}).`,
-      );
-    }
-
-    const instructionDeserializerOrUndef = instructionSet.get(opcode);
-    if (instructionDeserializerOrUndef === undefined) {
-      throw new InvalidOpcodeError(`Opcode ${Opcode[opcode]} (0x${opcode.toString(16)}) is not implemented`);
-    }
-
-    const instructionDeserializer: InstructionDeserializer = instructionDeserializerOrUndef;
-
-    const instruction = instructionDeserializer(cursor);
-    return [instruction, cursor.position() - startingPosition];
-  } catch (error) {
-    if (error instanceof InvalidTagValueError || error instanceof InvalidOpcodeError) {
-      throw duringInstrFetch(error, pc);
-    } else if (error instanceof AvmExecutionError) {
-      throw new AvmParsingError(`Instruction parsing error at pc ${pc}: ${error.message}`);
-    } else {
-      const msg = error instanceof Error ? `: ${error.message}` : '';
-      throw new AvmParsingError(`Instruction fetching error at pc ${pc}${msg}`);
-    }
-  }
-}