@aztec/simulator 0.0.1-commit.b655e406 → 0.0.1-commit.b8a057fa

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

@@ -1,111 +0,0 @@
-import { AVM_MAX_OPERANDS } from '@aztec/constants';
-import { padArrayEnd } from '@aztec/foundation/collection';
-import type { Tuple } from '@aztec/foundation/serialize';
-
-import { strict as assert } from 'assert';
-
-import { MemoryValue, TaggedMemory, type TaggedMemoryInterface, TypeTag } from '../avm_memory_types.js';
-import { RelativeAddressOutOfRangeError, TagCheckError } from '../errors.js';
-
-export enum AddressingMode {
-  DIRECT = 0,
-  INDIRECT = 1,
-  RELATIVE = 2,
-  INDIRECT_RELATIVE = 3,
-}
-
-/** A class to represent the addressing mode of an instruction. */
-export class Addressing {
-  public constructor(
-    /** The addressing mode for each possible operand. */
-    private readonly modePerOperand: Tuple<AddressingMode, typeof AVM_MAX_OPERANDS>,
-  ) {}
-
-  public static fromModes(modes: AddressingMode[]): Addressing {
-    assert(modes.length <= AVM_MAX_OPERANDS, 'Too many operands for addressing mode');
-    return new Addressing(padArrayEnd(modes, AddressingMode.DIRECT, AVM_MAX_OPERANDS));
-  }
-
-  public static fromWire(wireModes: number): Addressing {
-    // The modes are stored in the wire format as one or two bytes, with each two bits representing the modes for an operand.
-    // Even bits are indirect, odd bits are relative.
-    const modes = new Array<AddressingMode>(AVM_MAX_OPERANDS);
-    for (let i = 0; i < AVM_MAX_OPERANDS; i++) {
-      modes[i] =
-        (((wireModes >> (i * 2)) & 1) * AddressingMode.INDIRECT) |
-        (((wireModes >> (i * 2 + 1)) & 1) * AddressingMode.RELATIVE);
-    }
-    // Casting the array to tuple since it should be more performant than using makeTuple
-    return new Addressing(modes as Tuple<AddressingMode, typeof AVM_MAX_OPERANDS>);
-  }
-
-  public toWire(): number {
-    // The modes are stored in the wire format as a byte, with each bit representing the mode for an operand.
-    // The least significant bit represents the zeroth operand, and the least significant bit represents the last operand.
-    let wire: number = 0;
-    for (let i = 0; i < this.modePerOperand.length; i++) {
-      if (this.modePerOperand[i] & AddressingMode.INDIRECT) {
-        wire |= 1 << (i * 2);
-      }
-      if (this.modePerOperand[i] & AddressingMode.RELATIVE) {
-        wire |= 1 << (i * 2 + 1);
-      }
-    }
-    return wire;
-  }
-
-  public indirectOperandsCount(): number {
-    return this.modePerOperand.filter(mode => mode & AddressingMode.INDIRECT).length;
-  }
-
-  public relativeOperandsCount(): number {
-    return this.modePerOperand.filter(mode => mode & AddressingMode.RELATIVE).length;
-  }
-
-  /**
-   * Resolves the offsets using the addressing mode.
-   * @param offsets The offsets to resolve.
-   * @param mem The memory to use for resolution.
-   * @returns The resolved offsets. The length of the returned array is the same as the length of the input array and the resolved offsets are guaranteed to be valid addresses.
-   * @throws An error if any step failed. Should be treated as a black box.
-   */
-  public resolve(offsets: number[], mem: TaggedMemoryInterface): number[] {
-    const resolved: number[] = new Array(offsets.length);
-    // These will be read (once) if we have any relative operands.
-    let baseAddr: MemoryValue | undefined;
-
-    for (const [i, offset] of offsets.entries()) {
-      const mode = this.modePerOperand[i];
-      // The given offsets are assumed to be valid addresses.
-      resolved[i] = offset;
-      if (mode & AddressingMode.RELATIVE) {
-        if (!baseAddr) {
-          baseAddr = mem.get(0);
-          const baseAddrTag = baseAddr.getTag();
-          if (!TaggedMemory.isValidMemoryAddressTag(baseAddrTag!)) {
-            throw TagCheckError.forOffset(0, TypeTag[baseAddrTag!], TypeTag[TypeTag.UINT32]);
-          }
-        }
-        // Here we know that resolved[i] is at most 32 bits and baseAddr is at most 32 bits.
-        // Therefore, the addition is safe since the `number` type fits more than 33 bits.
-        resolved[i] += Number(baseAddr.toBigInt());
-        if (resolved[i] >= TaggedMemory.MAX_MEMORY_SIZE) {
-          throw new RelativeAddressOutOfRangeError(Number(baseAddr.toBigInt()), offset);
-        }
-      }
-      if (mode & AddressingMode.INDIRECT) {
-        // At this point we know that resolved[i] is a valid memory address.
-        const resolvedValue = mem.get(resolved[i]);
-        const resolvedTag = resolvedValue.getTag();
-
-        // Final check.
-        if (!TaggedMemory.isValidMemoryAddressTag(resolvedTag)) {
-          throw TagCheckError.forOffset(resolved[i], TypeTag[resolvedTag], TypeTag[TypeTag.UINT32]);
-        }
-
-        resolved[i] = Number(resolvedValue.toBigInt());
-      }
-    }
-    return resolved;
-  }
-}

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

@@ -1,117 +0,0 @@
-import type { AvmContext } from '../avm_context.js';
-import {
-  type Field,
-  type IntegralValue,
-  type MemoryValue,
-  TaggedMemory,
-  type TaggedMemoryInterface,
-  TypeTag,
-} from '../avm_memory_types.js';
-import { ArithmeticError } from '../errors.js';
-import { Opcode } from '../serialization/instruction_serialization.js';
-import { Addressing } from './addressing_mode.js';
-import { ThreeOperandInstruction } from './instruction_impl.js';
-
-export abstract class ThreeOperandArithmeticInstruction extends ThreeOperandInstruction {
-  public async execute(context: AvmContext): Promise<void> {
-    const memory = context.machineState.memory;
-    const addressing = Addressing.fromWire(this.indirect);
-
-    context.machineState.consumeGas(
-      this.baseGasCost(addressing.indirectOperandsCount(), addressing.relativeOperandsCount()),
-    );
-
-    const operands = [this.aOffset, this.bOffset, this.dstOffset];
-    const [aOffset, bOffset, dstOffset] = addressing.resolve(operands, memory);
-    this.checkTags(memory, aOffset, bOffset);
-
-    const a = memory.get(aOffset);
-    const b = memory.get(bOffset);
-
-    const dest = this.compute(a, b);
-    memory.set(dstOffset, dest);
-  }
-
-  protected abstract compute(a: MemoryValue, b: MemoryValue): MemoryValue;
-  protected checkTags(memory: TaggedMemoryInterface, aOffset: number, bOffset: number) {
-    memory.checkTagsAreSame(aOffset, bOffset);
-  }
-}
-
-export class Add extends ThreeOperandArithmeticInstruction {
-  static readonly type: string = 'ADD';
-  static readonly opcode = Opcode.ADD_8; // FIXME: needed for gas.
-
-  protected compute(a: MemoryValue, b: MemoryValue): MemoryValue {
-    return a.add(b);
-  }
-}
-
-export class Sub extends ThreeOperandArithmeticInstruction {
-  static readonly type: string = 'SUB';
-  static readonly opcode = Opcode.SUB_8; // FIXME: needed for gas.
-
-  protected compute(a: MemoryValue, b: MemoryValue): MemoryValue {
-    return a.sub(b);
-  }
-}
-
-export class Mul extends ThreeOperandArithmeticInstruction {
-  static type: string = 'MUL';
-  static readonly opcode = Opcode.MUL_8; // FIXME: needed for gas.
-
-  protected compute(a: MemoryValue, b: MemoryValue): MemoryValue {
-    return a.mul(b);
-  }
-}
-
-export class Div extends ThreeOperandArithmeticInstruction {
-  static type: string = 'DIV';
-  static readonly opcode = Opcode.DIV_8; // FIXME: needed for gas.
-
-  protected compute(a: MemoryValue, b: MemoryValue): MemoryValue {
-    if (b.toBigInt() === 0n) {
-      throw new ArithmeticError('Division by zero');
-    }
-
-    return a.div(b);
-  }
-
-  protected override checkTags(memory: TaggedMemoryInterface, aOffset: number, bOffset: number) {
-    memory.checkTagsAreSame(aOffset, bOffset);
-    TaggedMemory.checkIsIntegralTag(memory.getTag(aOffset)); // Follows that bOffset tag is also of integral type
-  }
-}
-
-export class FieldDiv extends ThreeOperandArithmeticInstruction {
-  static type: string = 'FDIV';
-  static readonly opcode = Opcode.FDIV_8; // FIXME: needed for gas.
-
-  protected compute(a: Field, b: Field): Field {
-    // return (a as Field).fdiv(b as Field);
-    return a.fdiv(b);
-  }
-
-  protected override checkTags(memory: TaggedMemoryInterface, aOffset: number, bOffset: number) {
-    memory.checkTagsAreSame(aOffset, bOffset);
-    memory.checkTag(TypeTag.FIELD, aOffset); // Follows that bOffset has also tag of type Field
-  }
-}
-
-export class Shl extends ThreeOperandArithmeticInstruction {
-  static readonly type: string = 'SHL';
-  static readonly opcode = Opcode.SHL_8; // FIXME: needed for gas.
-
-  protected override compute(a: IntegralValue, b: IntegralValue): IntegralValue {
-    return a.shl(b);
-  }
-}
-
-export class Shr extends ThreeOperandArithmeticInstruction {
-  static readonly type: string = 'SHR';
-  static readonly opcode = Opcode.SHR_8; // FIXME: needed for gas.
-
-  protected override compute(a: IntegralValue, b: IntegralValue): IntegralValue {
-    return a.shr(b);
-  }
-}

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

@@ -1,113 +0,0 @@
-import type { AvmContext } from '../avm_context.js';
-import { getBitwiseDynamicGasMultiplier } from '../avm_gas.js';
-import { type IntegralValue, TaggedMemory, type TaggedMemoryInterface, 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';
-import { ThreeOperandInstruction } from './instruction_impl.js';
-
-abstract class ThreeOperandBitwiseInstruction extends ThreeOperandInstruction {
-  public async execute(context: AvmContext): Promise<void> {
-    const memory = context.machineState.memory;
-    const addressing = Addressing.fromWire(this.indirect);
-
-    context.machineState.consumeGas(
-      this.baseGasCost(addressing.indirectOperandsCount(), addressing.relativeOperandsCount()),
-    );
-
-    const operands = [this.aOffset, this.bOffset, this.dstOffset];
-    const [aOffset, bOffset, dstOffset] = addressing.resolve(operands, memory);
-    this.checkTags(memory, aOffset, bOffset);
-
-    const multiplier = this.getDynamicMultiplier(memory.getTag(aOffset));
-    context.machineState.consumeGas(this.dynamicGasCost(multiplier));
-
-    const a = memory.getAs<IntegralValue>(aOffset);
-    const b = memory.getAs<IntegralValue>(bOffset);
-
-    const res = this.compute(a, b);
-    memory.set(dstOffset, res);
-  }
-
-  protected abstract compute(a: IntegralValue, b: IntegralValue): IntegralValue;
-  protected checkTags(memory: TaggedMemoryInterface, aOffset: number, bOffset: number) {
-    TaggedMemory.checkIsIntegralTag(memory.getTag(aOffset));
-    memory.checkTagsAreSame(aOffset, bOffset);
-  }
-
-  protected getDynamicMultiplier(_lhsTag: TypeTag): number {
-    return 0;
-  }
-}
-
-export class And extends ThreeOperandBitwiseInstruction {
-  static readonly type: string = 'AND';
-  static readonly opcode = Opcode.AND_8; // FIXME: needed for gas.
-
-  protected override compute(a: IntegralValue, b: IntegralValue): IntegralValue {
-    return a.and(b);
-  }
-
-  protected override getDynamicMultiplier(lhsTag: TypeTag): number {
-    return getBitwiseDynamicGasMultiplier(lhsTag);
-  }
-}
-
-export class Or extends ThreeOperandBitwiseInstruction {
-  static readonly type: string = 'OR';
-  static readonly opcode = Opcode.OR_8; // FIXME: needed for gas.
-
-  protected override compute(a: IntegralValue, b: IntegralValue): IntegralValue {
-    return a.or(b);
-  }
-
-  protected override getDynamicMultiplier(lhsTag: TypeTag): number {
-    return getBitwiseDynamicGasMultiplier(lhsTag);
-  }
-}
-
-export class Xor extends ThreeOperandBitwiseInstruction {
-  static readonly type: string = 'XOR';
-  static readonly opcode = Opcode.XOR_8; // FIXME: needed for gas.
-
-  protected override compute(a: IntegralValue, b: IntegralValue): IntegralValue {
-    return a.xor(b);
-  }
-
-  protected override getDynamicMultiplier(lhsTag: TypeTag): number {
-    return getBitwiseDynamicGasMultiplier(lhsTag);
-  }
-}
-
-export class Not extends Instruction {
-  static readonly type: string = 'NOT';
-  static readonly opcode = Opcode.NOT_8;
-
-  static readonly wireFormat8 = [OperandType.UINT8, OperandType.UINT8, OperandType.UINT8, OperandType.UINT8];
-  static readonly wireFormat16 = [OperandType.UINT8, OperandType.UINT8, OperandType.UINT16, OperandType.UINT16];
-
-  constructor(
-    private indirect: 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.indirect);
-
-    context.machineState.consumeGas(
-      this.baseGasCost(addressing.indirectOperandsCount(), addressing.relativeOperandsCount()),
-    );
-
-    const operands = [this.srcOffset, this.dstOffset];
-    const [srcOffset, dstOffset] = addressing.resolve(operands, memory);
-    TaggedMemory.checkIsIntegralTag(memory.getTag(srcOffset));
-    const value = memory.getAs<IntegralValue>(srcOffset);
-
-    const res = value.not();
-    memory.set(dstOffset, res);
-  }
-}

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

@@ -1,55 +0,0 @@
-import type { AvmContext } from '../avm_context.js';
-import { type MemoryValue, Uint1 } from '../avm_memory_types.js';
-import { Opcode } from '../serialization/instruction_serialization.js';
-import { Addressing } from './addressing_mode.js';
-import { ThreeOperandInstruction } from './instruction_impl.js';
-
-abstract class ComparatorInstruction extends ThreeOperandInstruction {
-  public async execute(context: AvmContext): Promise<void> {
-    const memory = context.machineState.memory;
-    const addressing = Addressing.fromWire(this.indirect);
-
-    context.machineState.consumeGas(
-      this.baseGasCost(addressing.indirectOperandsCount(), addressing.relativeOperandsCount()),
-    );
-
-    const operands = [this.aOffset, this.bOffset, this.dstOffset];
-    const [aOffset, bOffset, dstOffset] = addressing.resolve(operands, memory);
-    memory.checkTagsAreSame(aOffset, bOffset); // Brillig semantic enforces that tags match.
-
-    const a = memory.get(aOffset);
-    const b = memory.get(bOffset);
-
-    const dest = new Uint1(this.compare(a, b) ? 1 : 0);
-    memory.set(dstOffset, dest);
-  }
-
-  protected abstract compare(a: MemoryValue, b: MemoryValue): boolean;
-}
-
-export class Eq extends ComparatorInstruction {
-  static readonly type: string = 'EQ';
-  static readonly opcode = Opcode.EQ_8; // FIXME: needed for gas.
-
-  protected compare(a: MemoryValue, b: MemoryValue): boolean {
-    return a.equals(b);
-  }
-}
-
-export class Lt extends ComparatorInstruction {
-  static readonly type: string = 'LT';
-  static readonly opcode = Opcode.LT_8; // FIXME: needed for gas.
-
-  protected compare(a: MemoryValue, b: MemoryValue): boolean {
-    return a.lt(b);
-  }
-}
-
-export class Lte extends ComparatorInstruction {
-  static readonly type: string = 'LTE';
-  static readonly opcode = Opcode.LTE_8; // FIXME: needed for gas.
-
-  protected compare(a: MemoryValue, b: MemoryValue): boolean {
-    return a.lt(b) || a.equals(b);
-  }
-}

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

@@ -1,75 +0,0 @@
-import type { AvmContext } from '../avm_context.js';
-import { Field, TypeTag, Uint1 } from '../avm_memory_types.js';
-import { InstructionExecutionError } from '../errors.js';
-import { Opcode, OperandType } from '../serialization/instruction_serialization.js';
-import { Addressing } from './addressing_mode.js';
-import { Instruction } from './instruction.js';
-
-export enum ContractInstanceMember {
-  DEPLOYER,
-  CLASS_ID,
-  INIT_HASH,
-}
-
-export class GetContractInstance extends Instruction {
-  static readonly type: string = 'GETCONTRACTINSTANCE';
-  static readonly opcode: Opcode = Opcode.GETCONTRACTINSTANCE;
-  // Informs (de)serialization. See Instruction.deserialize.
-  static readonly wireFormat: OperandType[] = [
-    OperandType.UINT8, // opcode
-    OperandType.UINT8, // indirect bits
-    OperandType.UINT16, // addressOffset
-    OperandType.UINT16, // dstOffset
-    OperandType.UINT8, // member enum (immediate)
-  ];
-
-  constructor(
-    private indirect: number,
-    private addressOffset: number,
-    private dstOffset: number,
-    private memberEnum: number,
-  ) {
-    super();
-  }
-
-  async execute(context: AvmContext): Promise<void> {
-    const memory = context.machineState.memory;
-    const addressing = Addressing.fromWire(this.indirect);
-
-    context.machineState.consumeGas(
-      this.baseGasCost(addressing.indirectOperandsCount(), addressing.relativeOperandsCount()),
-    );
-
-    if (!(this.memberEnum in ContractInstanceMember)) {
-      throw new InstructionExecutionError(`Invalid GETCONSTRACTINSTANCE member enum ${this.memberEnum}`);
-    }
-
-    const operands = [this.addressOffset, this.dstOffset];
-    const [addressOffset, dstOffset] = addressing.resolve(operands, memory);
-    memory.checkTag(TypeTag.FIELD, addressOffset);
-
-    const address = memory.get(addressOffset).toAztecAddress();
-    const instance = await context.persistableState.getContractInstance(address);
-    const exists = instance !== undefined;
-
-    let memberValue = new Field(0);
-    if (exists) {
-      switch (this.memberEnum as ContractInstanceMember) {
-        case ContractInstanceMember.DEPLOYER:
-          memberValue = new Field(instance.deployer.toField());
-          break;
-        case ContractInstanceMember.CLASS_ID:
-          memberValue = new Field(instance.currentContractClassId.toField());
-          break;
-        case ContractInstanceMember.INIT_HASH:
-          memberValue = new Field(instance.initializationHash);
-          break;
-      }
-    }
-
-    const existsOffset = dstOffset;
-    const memberValueOffset = dstOffset + 1;
-    memory.set(existsOffset, new Uint1(exists ? 1 : 0));
-    memory.set(memberValueOffset, memberValue);
-  }
-}

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

@@ -1,123 +0,0 @@
-import type { AvmContext } from '../avm_context.js';
-import { TypeTag, type Uint1 } from '../avm_memory_types.js';
-import { InstructionExecutionError } from '../errors.js';
-import { Opcode, OperandType } from '../serialization/instruction_serialization.js';
-import { Addressing } from './addressing_mode.js';
-import { Instruction } from './instruction.js';
-
-export class Jump extends Instruction {
-  static type: string = 'JUMP';
-  static readonly opcode: Opcode = Opcode.JUMP_32;
-  // Informs (de)serialization. See Instruction.deserialize.
-  static readonly wireFormat: OperandType[] = [OperandType.UINT8, OperandType.UINT32];
-
-  constructor(private jumpOffset: number) {
-    super();
-  }
-
-  public async execute(context: AvmContext): Promise<void> {
-    context.machineState.consumeGas(this.baseGasCost(0, 0));
-
-    context.machineState.pc = this.jumpOffset;
-  }
-
-  public override handlesPC(): boolean {
-    return true;
-  }
-}
-
-export class JumpI extends Instruction {
-  static type: string = 'JUMPI';
-  static readonly opcode: Opcode = Opcode.JUMPI_32;
-
-  // Instruction wire format with opcode.
-  static readonly wireFormat: OperandType[] = [
-    OperandType.UINT8,
-    OperandType.UINT8,
-    OperandType.UINT16,
-    OperandType.UINT32,
-  ];
-
-  constructor(
-    private indirect: number,
-    private condOffset: number,
-    private loc: number,
-  ) {
-    super();
-  }
-
-  public async execute(context: AvmContext): Promise<void> {
-    const memory = context.machineState.memory;
-    const addressing = Addressing.fromWire(this.indirect);
-
-    context.machineState.consumeGas(
-      this.baseGasCost(addressing.indirectOperandsCount(), addressing.relativeOperandsCount()),
-    );
-
-    const operands = [this.condOffset];
-    const [resolvedCondOffset] = addressing.resolve(operands, memory);
-
-    memory.checkTag(TypeTag.UINT1, resolvedCondOffset);
-    const condition = memory.getAs<Uint1>(resolvedCondOffset);
-
-    if (condition.toNumber() == 0) {
-      context.machineState.pc = context.machineState.nextPc;
-    } else {
-      context.machineState.pc = this.loc;
-    }
-  }
-
-  public override handlesPC(): boolean {
-    return true;
-  }
-}
-
-export class InternalCall extends Instruction {
-  static readonly type: string = 'INTERNALCALL';
-  static readonly opcode: Opcode = Opcode.INTERNALCALL;
-  // Informs (de)serialization. See Instruction.deserialize.
-  static readonly wireFormat: OperandType[] = [OperandType.UINT8, OperandType.UINT32];
-
-  constructor(private loc: number) {
-    super();
-  }
-
-  public async execute(context: AvmContext): Promise<void> {
-    context.machineState.consumeGas(this.baseGasCost(0, 0));
-
-    context.machineState.internalCallStack.push({
-      callPc: context.machineState.pc,
-      returnPc: context.machineState.nextPc,
-    });
-    context.machineState.pc = this.loc;
-  }
-
-  public override handlesPC(): boolean {
-    return true;
-  }
-}
-
-export class InternalReturn extends Instruction {
-  static readonly type: string = 'INTERNALRETURN';
-  static readonly opcode: Opcode = Opcode.INTERNALRETURN;
-  // Informs (de)serialization. See Instruction.deserialize.
-  static readonly wireFormat: OperandType[] = [OperandType.UINT8];
-
-  constructor() {
-    super();
-  }
-
-  public async execute(context: AvmContext): Promise<void> {
-    context.machineState.consumeGas(this.baseGasCost(0, 0));
-
-    const stackEntry = context.machineState.internalCallStack.pop();
-    if (stackEntry === undefined) {
-      throw new InstructionExecutionError('Internal call stack empty!');
-    }
-    context.machineState.pc = stackEntry.returnPc;
-  }
-
-  public override handlesPC(): boolean {
-    return true;
-  }
-}