@aztec/simulator 0.0.1-commit.343b43af6 → 0.0.1-commit.350e0a4d

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

@@ -1,262 +0,0 @@
-import type { AvmContext } from '../avm_context.js';
-import type { AvmContractCallResult } from '../avm_contract_call_result.js';
-import { type Field, TypeTag, Uint1 } from '../avm_memory_types.js';
-import { CallDataMemory, ReturnDataMemory } from '../calldata.js';
-import { Opcode, OperandType } from '../serialization/instruction_serialization.js';
-import { Addressing } from './addressing_mode.js';
-import { Instruction } from './instruction.js';
-
-abstract class ExternalCall extends Instruction {
-  // Informs (de)serialization. See Instruction.deserialize.
-  static readonly wireFormat: OperandType[] = [
-    OperandType.UINT8,
-    OperandType.UINT16, // addressing_mode
-    OperandType.UINT16, // L2 gas offset
-    OperandType.UINT16, // DA gas offset
-    OperandType.UINT16, // Address offset
-    OperandType.UINT16, // Args offset
-    OperandType.UINT16, // Args size offset
-  ];
-
-  constructor(
-    private addressingMode: number,
-    private l2GasOffset: number,
-    private daGasOffset: number,
-    private addrOffset: number,
-    private argsSizeOffset: number,
-    private argsOffset: number,
-  ) {
-    super();
-  }
-
-  public async execute(context: AvmContext) {
-    const memory = context.machineState.memory;
-    const addressing = Addressing.fromWire(this.addressingMode);
-
-    context.machineState.consumeGas(
-      this.baseGasCost(addressing.indirectOperandsCount(), addressing.relativeOperandsCount()),
-    );
-
-    const operands = [this.l2GasOffset, this.daGasOffset, this.addrOffset, this.argsSizeOffset, this.argsOffset];
-    const [l2GasOffset, daGasOffset, addrOffset, argsSizeOffset, argsOffset] = addressing.resolve(operands, memory);
-
-    memory.checkTags(TypeTag.UINT32, l2GasOffset);
-    memory.checkTags(TypeTag.UINT32, daGasOffset);
-    memory.checkTag(TypeTag.FIELD, addrOffset);
-    memory.checkTag(TypeTag.UINT32, argsSizeOffset);
-
-    const calldataSize = memory.get(argsSizeOffset).toNumber();
-
-    const calldata = new CallDataMemory(memory, argsOffset, calldataSize);
-
-    const callAddress = memory.getAs<Field>(addrOffset);
-    // If we are already in a static call, we propagate the environment.
-    const callType = context.environment.isStaticCall ? 'STATICCALL' : this.type;
-
-    // We consume the gas allocated for the nested call. The excess will be refunded later.
-    // Gas allocation is capped by the amount of gas left in the current context.
-    // We have to do some dancing here because the gas allocation is a field,
-    // but in the machine state we track gas as a number.
-    const allocatedL2Gas = Number(
-      BigIntMin(memory.get(l2GasOffset).toBigInt(), BigInt(context.machineState.l2GasLeft)),
-    );
-    const allocatedDaGas = Number(
-      BigIntMin(memory.get(daGasOffset).toBigInt(), BigInt(context.machineState.daGasLeft)),
-    );
-    const allocatedGas = { l2Gas: allocatedL2Gas, daGas: allocatedDaGas };
-    context.machineState.consumeGas(allocatedGas);
-
-    const aztecAddress = callAddress.toAztecAddress();
-    const nestedContext = await context.createNestedContractCallContext(aztecAddress, calldata, allocatedGas, callType);
-
-    const simulator = await context.provideSimulator!(nestedContext);
-    const nestedCallResults: AvmContractCallResult = await simulator.execute();
-    const success = !nestedCallResults.reverted;
-
-    // Save return/revert data for later.
-    const returnData = nestedCallResults.output;
-    context.machineState.nestedReturndata = returnData;
-
-    // Track the success status directly
-    context.machineState.nestedCallSuccess = success;
-
-    // Account for all instructions executed in the nested call
-    context.machineState.instrCounter += nestedCallResults.totalInstructions;
-
-    // If the nested call reverted, we try to save the reason and the revert data.
-    // This will be used by the caller to try to reconstruct the call stack.
-    // This is only a heuristic and may not always work. It is intended to work
-    // for the case where a nested call reverts and the caller always rethrows
-    // (in Noir code).
-    if (!success) {
-      context.machineState.collectedRevertInfo = {
-        revertDataRepresentative: returnData.bestEffortReadAll(),
-        recursiveRevertReason: nestedCallResults.revertReason!,
-      };
-    }
-
-    // Refund unused gas
-    context.machineState.refundGas(nestedCallResults.gasLeft);
-
-    // Merge nested call's state and trace based on whether it succeeded.
-    if (success) {
-      await context.persistableState.merge(nestedContext.persistableState);
-    } else {
-      await context.persistableState.reject(nestedContext.persistableState);
-    }
-  }
-
-  public abstract override get type(): 'CALL' | 'STATICCALL';
-}
-
-export class Call extends ExternalCall {
-  static type = 'CALL' as const;
-  static readonly opcode: Opcode = Opcode.CALL;
-
-  public get type() {
-    return Call.type;
-  }
-}
-
-export class StaticCall extends ExternalCall {
-  static type = 'STATICCALL' as const;
-  static readonly opcode: Opcode = Opcode.STATICCALL;
-
-  public get type() {
-    return StaticCall.type;
-  }
-}
-
-export class SuccessCopy extends Instruction {
-  static type: string = 'SUCCESSCOPY';
-  static readonly opcode: Opcode = Opcode.SUCCESSCOPY;
-  // Informs (de)serialization. See Instruction.deserialize.
-  static readonly wireFormat: OperandType[] = [
-    OperandType.UINT8,
-    OperandType.UINT8, // Indirect (8-bit)
-    OperandType.UINT16, // dstOffset (16-bit)
-  ];
-
-  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);
-
-    // Use the direct success tracking property
-    const success = context.machineState.nestedCallSuccess;
-
-    // Write the success flag to the provided memory location
-    memory.set(dstOffset, new Uint1(success ? 1 : 0));
-  }
-}
-
-export class Return extends Instruction {
-  static type: string = 'RETURN';
-  static readonly opcode: Opcode = Opcode.RETURN;
-  // Informs (de)serialization. See Instruction.deserialize.
-  static readonly wireFormat: OperandType[] = [
-    OperandType.UINT8,
-    OperandType.UINT8,
-    OperandType.UINT16,
-    OperandType.UINT16,
-  ];
-
-  constructor(
-    private addressingMode: number,
-    private returnSizeOffset: number,
-    private returnOffset: 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.returnSizeOffset, this.returnOffset];
-    const [returnSizeOffset, returnOffset] = addressing.resolve(operands, memory);
-
-    memory.checkTag(TypeTag.UINT32, returnSizeOffset);
-    const returnSize = memory.get(returnSizeOffset).toNumber();
-
-    const output = new ReturnDataMemory(memory, returnOffset, returnSize);
-
-    context.machineState.return(output);
-  }
-
-  public override handlesPC(): boolean {
-    return true;
-  }
-}
-
-export class Revert extends Instruction {
-  static type: string = 'REVERT';
-  static readonly opcode: Opcode = Opcode.REVERT_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 retSizeOffset: number,
-    private returnOffset: 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.retSizeOffset, this.returnOffset];
-    const [retSizeOffset, returnOffset] = addressing.resolve(operands, memory);
-
-    memory.checkTag(TypeTag.UINT32, retSizeOffset);
-    const retSize = memory.get(retSizeOffset).toNumber();
-    const output = new ReturnDataMemory(memory, returnOffset, retSize);
-
-    context.machineState.revert(output);
-  }
-
-  // We don't want to increase the PC after reverting because it breaks messages.
-  // Maybe we can remove this once messages don't depend on PCs.
-  public override handlesPC(): boolean {
-    return true;
-  }
-}
-
-/** Returns the smaller of two bigints. */
-function BigIntMin(a: bigint, b: bigint): bigint {
-  return a < b ? a : b;
-}

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

@@ -1,151 +0,0 @@
-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';
-import { Opcode, OperandType } from '../serialization/instruction_serialization.js';
-import { Addressing } from './addressing_mode.js';
-import { Instruction } from './instruction.js';
-
-export class Poseidon2 extends Instruction {
-  static type: string = 'POSEIDON2';
-  static readonly opcode: Opcode = Opcode.POSEIDON2;
-  static readonly stateSize = 4;
-
-  // Informs (de)serialization. See Instruction.deserialize.
-  static readonly wireFormat: OperandType[] = [
-    OperandType.UINT8,
-    OperandType.UINT8,
-    OperandType.UINT16,
-    OperandType.UINT16,
-  ];
-
-  constructor(
-    private addressingMode: number,
-    private inputStateOffset: number,
-    private outputStateOffset: 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.inputStateOffset, this.outputStateOffset];
-
-    const [inputOffset, outputOffset] = addressing.resolve(operands, memory);
-
-    const inputState = memory.getSlice(inputOffset, Poseidon2.stateSize);
-    memory.checkTagsRange(TypeTag.FIELD, inputOffset, Poseidon2.stateSize);
-
-    const outputState = await poseidon2Permutation(inputState);
-    memory.setSlice(
-      outputOffset,
-      outputState.map(word => new Field(word)),
-    );
-  }
-}
-
-export class KeccakF1600 extends Instruction {
-  static type: string = 'KECCAKF1600';
-  static readonly opcode: Opcode = Opcode.KECCAKF1600;
-
-  // Informs (de)serialization. See Instruction.deserialize.
-  static readonly wireFormat: OperandType[] = [
-    OperandType.UINT8,
-    OperandType.UINT8,
-    OperandType.UINT16,
-    OperandType.UINT16,
-  ];
-
-  constructor(
-    private addressingMode: number,
-    private dstOffset: number,
-    private inputOffset: number,
-  ) {
-    super();
-  }
-
-  // pub fn keccakf1600(input: [u64; 25]) -> [u64; 25]
-  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 [dstOffset, inputOffset] = addressing.resolve(operands, memory);
-
-    const stateData = memory.getSlice(inputOffset, inputSize).map(word => word.toBigInt());
-    memory.checkTagsRange(TypeTag.UINT64, inputOffset, inputSize);
-
-    const updatedState = keccakf1600(stateData);
-
-    const res = updatedState.map(word => new Uint64(word));
-    memory.setSlice(dstOffset, res);
-  }
-}
-
-export class Sha256Compression extends Instruction {
-  static type: string = 'SHA256COMPRESSION';
-  static readonly opcode: Opcode = Opcode.SHA256COMPRESSION;
-
-  // 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 outputOffset: number,
-    private stateOffset: number,
-    private inputsOffset: number,
-  ) {
-    super();
-  }
-
-  public async execute(context: AvmContext): Promise<void> {
-    const STATE_SIZE = 8;
-    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 [outputOffset, stateOffset, inputsOffset] = addressing.resolve(operands, memory);
-
-    // Note: size of output is same as size of state
-    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);
-
-    // 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));
-    memory.setSlice(outputOffset, res);
-  }
-}

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

@@ -1,15 +0,0 @@
-export * from './arithmetic.js';
-export * from './bitwise.js';
-export * from './control_flow.js';
-export * from './contract.js';
-export * from './conversion.js';
-export * from './instruction.js';
-export * from './comparators.js';
-export * from './memory.js';
-export * from './misc.js';
-export * from './storage.js';
-export * from './external_calls.js';
-export * from './environment_getters.js';
-export * from './accrued_substate.js';
-export * from './hashing.js';
-export * from './ec_add.js';

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

@@ -1,136 +0,0 @@
-import type { Bufferable } from '@aztec/foundation/serialize';
-
-import { strict as assert } from 'assert';
-
-import type { AvmContext } from '../avm_context.js';
-import { type Gas, computeAddressingCost, getBaseGasCost, getDynamicGasCost, mulGas, sumGas } from '../avm_gas.js';
-import type { BufferCursor } from '../serialization/buffer_cursor.js';
-import { Opcode, type OperandType, deserialize, serializeAs } from '../serialization/instruction_serialization.js';
-
-type InstructionConstructor = {
-  new (...args: any[]): Instruction;
-};
-
-/**
- * Parent class for all AVM instructions.
- * It's most important aspects are execute and (de)serialize.
- */
-export abstract class Instruction {
-  /**
-   * Consumes gas and executes the instruction.
-   * This is the main entry point for the instruction.
-   * @param context - The AvmContext in which the instruction executes.
-   */
-  public abstract execute(context: AvmContext): Promise<void>;
-
-  /**
-   * Whether the instruction will modify the PC itself.
-   */
-  public handlesPC(): boolean {
-    return false;
-  }
-
-  /**
-   * Generate a string representation of the instruction including
-   * the instruction sub-class name all of its flags and operands.
-   * @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)[]) {
-      instructionStr += `${prop}:${this[prop].toString()}, `;
-    }
-    return instructionStr;
-  }
-
-  // Default deserialization which uses Class.opcode and Class.wireFormat.
-  public static fromBuffer(
-    this: InstructionConstructor & { wireFormat: OperandType[]; as: any },
-    buf: BufferCursor | Buffer,
-  ): Instruction {
-    return this.as(this.wireFormat).fromBuffer(buf);
-  }
-
-  // Default serialization which uses Class.opcode and Class.wireFormat.
-  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).toBuffer();
-  }
-
-  /**
-   * Returns a new instruction instance that can be serialized with the given opcode and wire format.
-   * @param opcode The opcode of the instruction.
-   * @param wireFormat The wire format of the instruction.
-   * @returns The new instruction instance.
-   */
-  public as(opcode: Opcode, wireFormat: OperandType[]): Instruction & Bufferable {
-    return Object.defineProperty(this, 'toBuffer', {
-      value: (): Buffer => {
-        return serializeAs(wireFormat, opcode, this);
-      },
-      enumerable: false,
-    });
-  }
-
-  /**
-   * Returns a new instruction class that can be deserialized with the given opcode and wire format.
-   * @param opcode The opcode of the instruction.
-   * @param wireFormat The wire format of the instruction.
-   * @returns The new instruction class.
-   */
-  public static as(this: InstructionConstructor, wireFormat: OperandType[]) {
-    return Object.assign(this, {
-      fromBuffer: (buf: BufferCursor | Buffer): Instruction => {
-        const res = deserialize(buf, wireFormat);
-        const args = res.slice(1); // Remove opcode.
-        return new this(...args);
-      },
-    });
-  }
-
-  /**
-   * Returns the base gas cost for the instruction.
-   * @returns The base gas cost.
-   */
-  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);
-  }
-
-  /**
-   * Returns the stringified type of the instruction.
-   * Instruction sub-classes should have a static `type` property.
-   */
-  public get type(): string {
-    const type = 'type' in this.constructor && (this.constructor.type as string);
-    assert(!!type, `Instruction class ${this.constructor.name} does not have a static 'type' property defined.`);
-    return type;
-  }
-
-  /**
-   * Returns the opcode of the instruction.
-   * Instruction sub-classes should have a static `opcode` property.
-   */
-  public get opcode(): Opcode {
-    const opcode = 'opcode' in this.constructor ? (this.constructor.opcode as Opcode) : undefined;
-    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

@@ -1,36 +0,0 @@
-import { OperandType } from '../serialization/instruction_serialization.js';
-import { Instruction } from './instruction.js';
-
-/** Wire format that informs deserialization for instructions with three operands. */
-export const ThreeOperandWireFormat8 = [
-  OperandType.UINT8,
-  OperandType.UINT8,
-  OperandType.UINT8,
-  OperandType.UINT8,
-  OperandType.UINT8,
-];
-export const ThreeOperandWireFormat16 = [
-  OperandType.UINT8,
-  OperandType.UINT8,
-  OperandType.UINT16,
-  OperandType.UINT16,
-  OperandType.UINT16,
-];
-
-/**
- * Covers (de)serialization for an instruction with:
- * addressing mode, inTag, and three operands.
- */
-export abstract class ThreeOperandInstruction extends Instruction {
-  static readonly wireFormat8: OperandType[] = ThreeOperandWireFormat8;
-  static readonly wireFormat16: OperandType[] = ThreeOperandWireFormat16;
-
-  constructor(
-    protected addressingMode: number,
-    protected aOffset: number,
-    protected bOffset: number,
-    protected dstOffset: number,
-  ) {
-    super();
-  }
-}