@aztec/simulator 0.32.0 → 0.33.0

package/src/avm/opcodes/addressing_mode.ts

@@ -1,6 +1,6 @@
 import { strict as assert } from 'assert';
 
-import { TaggedMemory } from '../avm_memory_types.js';
+import { type TaggedMemoryInterface } from '../avm_memory_types.js';
 
 export enum AddressingMode {
   DIRECT,
@@ -12,7 +12,7 @@ export enum AddressingMode {
 export class Addressing {
   public constructor(
     /** The addressing mode for each operand. The length of this array is the number of operands of the instruction. */
-    public readonly modePerOperand: AddressingMode[],
+    private readonly modePerOperand: AddressingMode[],
   ) {
     assert(modePerOperand.length <= 8, 'At most 8 operands are supported');
   }
@@ -39,13 +39,18 @@ export class Addressing {
     return wire;
   }
 
+  /** Returns how many operands use the given addressing mode. */
+  public count(mode: AddressingMode): number {
+    return this.modePerOperand.filter(m => m === mode).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.
    */
-  public resolve(offsets: number[], mem: TaggedMemory): number[] {
+  public resolve(offsets: number[], mem: TaggedMemoryInterface): number[] {
     assert(offsets.length <= this.modePerOperand.length);
     const resolved = new Array(offsets.length);
     for (const [i, offset] of offsets.entries()) {

package/src/avm/opcodes/arithmetic.ts

@@ -1,33 +1,32 @@
 import type { AvmContext } from '../avm_context.js';
-import { GasCost, GasCostConstants, getGasCostMultiplierFromTypeTag, makeGasCost } from '../avm_gas_cost.js';
-import { Field, MemoryValue, TypeTag } from '../avm_memory_types.js';
+import { getBaseGasCost, getGasCostForTypeTag, getMemoryGasCost, sumGas } from '../avm_gas.js';
+import { type Field, type MemoryOperations, type MemoryValue, TypeTag } from '../avm_memory_types.js';
 import { Opcode, OperandType } from '../serialization/instruction_serialization.js';
-import { Addressing, AddressingMode } from './addressing_mode.js';
 import { Instruction } from './instruction.js';
 import { ThreeOperandInstruction } from './instruction_impl.js';
 
 export abstract class ThreeOperandArithmeticInstruction extends ThreeOperandInstruction {
-  async execute(context: AvmContext): Promise<void> {
-    context.machineState.memory.checkTags(this.inTag, this.aOffset, this.bOffset);
+  public async execute(context: AvmContext): Promise<void> {
+    const memoryOperations = { reads: 2, writes: 1, indirect: this.indirect };
+    const memory = context.machineState.memory.track(this.type);
+    context.machineState.consumeGas(this.gasCost(memoryOperations));
 
-    const a = context.machineState.memory.get(this.aOffset);
-    const b = context.machineState.memory.get(this.bOffset);
+    memory.checkTags(this.inTag, this.aOffset, this.bOffset);
+
+    const a = memory.get(this.aOffset);
+    const b = memory.get(this.bOffset);
 
     const dest = this.compute(a, b);
-    context.machineState.memory.set(this.dstOffset, dest);
+    memory.set(this.dstOffset, dest);
 
+    memory.assert(memoryOperations);
     context.machineState.incrementPc();
   }
 
-  protected gasCost(): GasCost {
-    const indirectCount = Addressing.fromWire(this.indirect).modePerOperand.filter(
-      mode => mode === AddressingMode.INDIRECT,
-    ).length;
-
-    const l2Gas =
-      indirectCount * GasCostConstants.ARITHMETIC_COST_PER_INDIRECT_ACCESS +
-      getGasCostMultiplierFromTypeTag(this.inTag) * GasCostConstants.ARITHMETIC_COST_PER_BYTE;
-    return makeGasCost({ l2Gas });
+  protected gasCost(memoryOps: Partial<MemoryOperations & { indirect: number }>) {
+    const baseGasCost = getGasCostForTypeTag(this.inTag, getBaseGasCost(this.opcode));
+    const memoryGasCost = getMemoryGasCost(memoryOps);
+    return sumGas(baseGasCost, memoryGasCost);
   }
 
   protected abstract compute(a: MemoryValue, b: MemoryValue): MemoryValue;
@@ -86,15 +85,26 @@ export class FieldDiv extends Instruction {
     super();
   }
 
-  async execute(context: AvmContext): Promise<void> {
-    context.machineState.memory.checkTags(TypeTag.FIELD, this.aOffset, this.bOffset);
+  public async execute(context: AvmContext): Promise<void> {
+    const memoryOperations = { reads: 2, writes: 1, indirect: this.indirect };
+    const memory = context.machineState.memory.track(this.type);
+    context.machineState.consumeGas(this.gasCost(memoryOperations));
+
+    memory.checkTags(TypeTag.FIELD, this.aOffset, this.bOffset);
 
-    const a = context.machineState.memory.getAs<Field>(this.aOffset);
-    const b = context.machineState.memory.getAs<Field>(this.bOffset);
+    const a = memory.getAs<Field>(this.aOffset);
+    const b = memory.getAs<Field>(this.bOffset);
 
     const dest = a.fdiv(b);
-    context.machineState.memory.set(this.dstOffset, dest);
+    memory.set(this.dstOffset, dest);
 
+    memory.assert(memoryOperations);
     context.machineState.incrementPc();
   }
+
+  protected gasCost(memoryOps: Partial<MemoryOperations & { indirect: number }>) {
+    const baseGasCost = getGasCostForTypeTag(TypeTag.FIELD, getBaseGasCost(this.opcode));
+    const memoryGasCost = getMemoryGasCost(memoryOps);
+    return sumGas(baseGasCost, memoryGasCost);
+  }
 }

package/src/avm/opcodes/bitwise.ts

@@ -1,68 +1,71 @@
 import type { AvmContext } from '../avm_context.js';
-import { IntegralValue } from '../avm_memory_types.js';
+import { type IntegralValue } from '../avm_memory_types.js';
 import { Opcode } from '../serialization/instruction_serialization.js';
 import { ThreeOperandInstruction, TwoOperandInstruction } from './instruction_impl.js';
 
-export class And extends ThreeOperandInstruction {
-  static readonly type: string = 'AND';
-  static readonly opcode = Opcode.AND;
-
-  constructor(indirect: number, inTag: number, aOffset: number, bOffset: number, dstOffset: number) {
-    super(indirect, inTag, aOffset, bOffset, dstOffset);
-  }
+abstract class ThreeOperandBitwiseInstruction extends ThreeOperandInstruction {
+  public async execute(context: AvmContext): Promise<void> {
+    const memoryOperations = { reads: 2, writes: 1, indirect: this.indirect };
+    const memory = context.machineState.memory.track(this.type);
+    context.machineState.consumeGas(this.gasCost(memoryOperations));
 
-  async execute(context: AvmContext): Promise<void> {
-    context.machineState.memory.checkTags(this.inTag, this.aOffset, this.bOffset);
+    memory.checkTags(this.inTag, this.aOffset, this.bOffset);
 
-    const a = context.machineState.memory.getAs<IntegralValue>(this.aOffset);
-    const b = context.machineState.memory.getAs<IntegralValue>(this.bOffset);
+    const a = memory.getAs<IntegralValue>(this.aOffset);
+    const b = memory.getAs<IntegralValue>(this.bOffset);
 
-    const res = a.and(b);
-    context.machineState.memory.set(this.dstOffset, res);
+    const res = this.compute(a, b);
+    memory.set(this.dstOffset, res);
 
+    memory.assert(memoryOperations);
     context.machineState.incrementPc();
   }
+
+  protected abstract compute(a: IntegralValue, b: IntegralValue): IntegralValue;
 }
 
-export class Or extends ThreeOperandInstruction {
-  static readonly type: string = 'OR';
-  static readonly opcode = Opcode.OR;
+export class And extends ThreeOperandBitwiseInstruction {
+  static readonly type: string = 'AND';
+  static readonly opcode = Opcode.AND;
 
-  constructor(indirect: number, inTag: number, aOffset: number, bOffset: number, dstOffset: number) {
-    super(indirect, inTag, aOffset, bOffset, dstOffset);
+  protected compute(a: IntegralValue, b: IntegralValue): IntegralValue {
+    return a.and(b);
   }
+}
 
-  async execute(context: AvmContext): Promise<void> {
-    context.machineState.memory.checkTags(this.inTag, this.aOffset, this.bOffset);
-
-    const a = context.machineState.memory.getAs<IntegralValue>(this.aOffset);
-    const b = context.machineState.memory.getAs<IntegralValue>(this.bOffset);
-
-    const res = a.or(b);
-    context.machineState.memory.set(this.dstOffset, res);
+export class Or extends ThreeOperandBitwiseInstruction {
+  static readonly type: string = 'OR';
+  static readonly opcode = Opcode.OR;
 
-    context.machineState.incrementPc();
+  protected compute(a: IntegralValue, b: IntegralValue): IntegralValue {
+    return a.or(b);
   }
 }
 
-export class Xor extends ThreeOperandInstruction {
+export class Xor extends ThreeOperandBitwiseInstruction {
   static readonly type: string = 'XOR';
   static readonly opcode = Opcode.XOR;
 
-  constructor(indirect: number, inTag: number, aOffset: number, bOffset: number, dstOffset: number) {
-    super(indirect, inTag, aOffset, bOffset, dstOffset);
+  protected compute(a: IntegralValue, b: IntegralValue): IntegralValue {
+    return a.xor(b);
   }
+}
 
-  async execute(context: AvmContext): Promise<void> {
-    context.machineState.memory.checkTags(this.inTag, this.aOffset, this.bOffset);
+export class Shl extends ThreeOperandBitwiseInstruction {
+  static readonly type: string = 'SHL';
+  static readonly opcode = Opcode.SHL;
 
-    const a = context.machineState.memory.getAs<IntegralValue>(this.aOffset);
-    const b = context.machineState.memory.getAs<IntegralValue>(this.bOffset);
+  protected compute(a: IntegralValue, b: IntegralValue): IntegralValue {
+    return a.shl(b);
+  }
+}
 
-    const res = a.xor(b);
-    context.machineState.memory.set(this.dstOffset, res);
+export class Shr extends ThreeOperandBitwiseInstruction {
+  static readonly type: string = 'SHR';
+  static readonly opcode = Opcode.SHR;
 
-    context.machineState.incrementPc();
+  protected compute(a: IntegralValue, b: IntegralValue): IntegralValue {
+    return a.shr(b);
   }
 }
 
@@ -74,56 +77,19 @@ export class Not extends TwoOperandInstruction {
     super(indirect, inTag, aOffset, dstOffset);
   }
 
-  async execute(context: AvmContext): Promise<void> {
-    context.machineState.memory.checkTags(this.inTag, this.aOffset);
-
-    const a = context.machineState.memory.getAs<IntegralValue>(this.aOffset);
-
-    const res = a.not();
-    context.machineState.memory.set(this.dstOffset, res);
-
-    context.machineState.incrementPc();
-  }
-}
-
-export class Shl extends ThreeOperandInstruction {
-  static readonly type: string = 'SHL';
-  static readonly opcode = Opcode.SHL;
-
-  constructor(indirect: number, inTag: number, aOffset: number, bOffset: number, dstOffset: number) {
-    super(indirect, inTag, aOffset, bOffset, dstOffset);
-  }
-
-  async execute(context: AvmContext): Promise<void> {
-    context.machineState.memory.checkTags(this.inTag, this.aOffset, this.bOffset);
+  public async execute(context: AvmContext): Promise<void> {
+    const memoryOperations = { reads: 1, writes: 1, indirect: this.indirect };
+    const memory = context.machineState.memory.track(this.type);
+    context.machineState.consumeGas(this.gasCost(memoryOperations));
 
-    const a = context.machineState.memory.getAs<IntegralValue>(this.aOffset);
-    const b = context.machineState.memory.getAs<IntegralValue>(this.bOffset);
+    memory.checkTags(this.inTag, this.aOffset);
 
-    const res = a.shl(b);
-    context.machineState.memory.set(this.dstOffset, res);
+    const a = memory.getAs<IntegralValue>(this.aOffset);
 
-    context.machineState.incrementPc();
-  }
-}
-
-export class Shr extends ThreeOperandInstruction {
-  static readonly type: string = 'SHR';
-  static readonly opcode = Opcode.SHR;
-
-  constructor(indirect: number, inTag: number, aOffset: number, bOffset: number, dstOffset: number) {
-    super(indirect, inTag, aOffset, bOffset, dstOffset);
-  }
-
-  async execute(context: AvmContext): Promise<void> {
-    context.machineState.memory.checkTags(this.inTag, this.aOffset, this.bOffset);
-
-    const a = context.machineState.memory.getAs<IntegralValue>(this.aOffset);
-    const b = context.machineState.memory.getAs<IntegralValue>(this.bOffset);
-
-    const res = a.shr(b);
-    context.machineState.memory.set(this.dstOffset, res);
+    const res = a.not();
+    memory.set(this.dstOffset, res);
 
+    memory.assert(memoryOperations);
     context.machineState.incrementPc();
   }
 }

package/src/avm/opcodes/comparators.ts

@@ -1,67 +1,52 @@
 import type { AvmContext } from '../avm_context.js';
-import { Uint8 } from '../avm_memory_types.js';
+import { type MemoryValue, Uint8 } from '../avm_memory_types.js';
 import { Opcode } from '../serialization/instruction_serialization.js';
 import { ThreeOperandInstruction } from './instruction_impl.js';
 
-export class Eq extends ThreeOperandInstruction {
-  static readonly type: string = 'EQ';
-  static readonly opcode = Opcode.EQ;
-
-  constructor(indirect: number, inTag: number, aOffset: number, bOffset: number, dstOffset: number) {
-    super(indirect, inTag, aOffset, bOffset, dstOffset);
-  }
+abstract class ComparatorInstruction extends ThreeOperandInstruction {
+  public async execute(context: AvmContext): Promise<void> {
+    const memoryOperations = { reads: 2, writes: 1, indirect: this.indirect };
+    const memory = context.machineState.memory.track(this.type);
+    context.machineState.consumeGas(this.gasCost(memoryOperations));
 
-  async execute(context: AvmContext): Promise<void> {
-    context.machineState.memory.checkTags(this.inTag, this.aOffset, this.bOffset);
+    memory.checkTags(this.inTag, this.aOffset, this.bOffset);
 
-    const a = context.machineState.memory.get(this.aOffset);
-    const b = context.machineState.memory.get(this.bOffset);
+    const a = memory.get(this.aOffset);
+    const b = memory.get(this.bOffset);
 
-    const dest = new Uint8(a.equals(b) ? 1 : 0);
-    context.machineState.memory.set(this.dstOffset, dest);
+    const dest = new Uint8(this.compare(a, b) ? 1 : 0);
+    memory.set(this.dstOffset, dest);
 
+    memory.assert(memoryOperations);
     context.machineState.incrementPc();
   }
+
+  protected abstract compare(a: MemoryValue, b: MemoryValue): boolean;
 }
 
-export class Lt extends ThreeOperandInstruction {
-  static readonly type: string = 'LT';
-  static readonly opcode = Opcode.LT;
+export class Eq extends ComparatorInstruction {
+  static readonly type: string = 'EQ';
+  static readonly opcode = Opcode.EQ;
 
-  constructor(indirect: number, inTag: number, aOffset: number, bOffset: number, dstOffset: number) {
-    super(indirect, inTag, aOffset, bOffset, dstOffset);
+  protected compare(a: MemoryValue, b: MemoryValue): boolean {
+    return a.equals(b);
   }
+}
 
-  async execute(context: AvmContext): Promise<void> {
-    context.machineState.memory.checkTags(this.inTag, this.aOffset, this.bOffset);
-
-    const a = context.machineState.memory.get(this.aOffset);
-    const b = context.machineState.memory.get(this.bOffset);
-
-    const dest = new Uint8(a.lt(b) ? 1 : 0);
-    context.machineState.memory.set(this.dstOffset, dest);
+export class Lt extends ComparatorInstruction {
+  static readonly type: string = 'LT';
+  static readonly opcode = Opcode.LT;
 
-    context.machineState.incrementPc();
+  protected compare(a: MemoryValue, b: MemoryValue): boolean {
+    return a.lt(b);
   }
 }
 
-export class Lte extends ThreeOperandInstruction {
+export class Lte extends ComparatorInstruction {
   static readonly type: string = 'LTE';
   static readonly opcode = Opcode.LTE;
 
-  constructor(indirect: number, inTag: number, aOffset: number, bOffset: number, dstOffset: number) {
-    super(indirect, inTag, aOffset, bOffset, dstOffset);
-  }
-
-  async execute(context: AvmContext): Promise<void> {
-    context.machineState.memory.checkTags(this.inTag, this.aOffset, this.bOffset);
-
-    const a = context.machineState.memory.get(this.aOffset);
-    const b = context.machineState.memory.get(this.bOffset);
-
-    const dest = new Uint8(a.lt(b) || a.equals(b) ? 1 : 0);
-    context.machineState.memory.set(this.dstOffset, dest);
-
-    context.machineState.incrementPc();
+  protected compare(a: MemoryValue, b: MemoryValue): boolean {
+    return a.lt(b) || a.equals(b);
   }
 }

package/src/avm/opcodes/context_getters.ts

@@ -0,0 +1,32 @@
+import type { AvmContext } from '../avm_context.js';
+import { Field, type MemoryValue } from '../avm_memory_types.js';
+import { Opcode } from '../serialization/instruction_serialization.js';
+import { GetterInstruction } from './instruction_impl.js';
+
+export class L2GasLeft extends GetterInstruction {
+  static type: string = 'L2GASLEFT';
+  static readonly opcode: Opcode = Opcode.L2GASLEFT;
+
+  // TODO(@spalladino) Yellow paper specifies that the value should be an Uint32, not a Field.
+  protected getValue(context: AvmContext): MemoryValue {
+    return new Field(context.machineState.l2GasLeft);
+  }
+}
+
+export class L1GasLeft extends GetterInstruction {
+  static type: string = 'L1GASLEFT';
+  static readonly opcode: Opcode = Opcode.L1GASLEFT;
+
+  protected getValue(context: AvmContext): MemoryValue {
+    return new Field(context.machineState.l1GasLeft);
+  }
+}
+
+export class DAGasLeft extends GetterInstruction {
+  static type: string = 'DAGASLEFT';
+  static readonly opcode: Opcode = Opcode.DAGASLEFT;
+
+  protected getValue(context: AvmContext): MemoryValue {
+    return new Field(context.machineState.daGasLeft);
+  }
+}

package/src/avm/opcodes/contract.ts

@@ -0,0 +1,58 @@
+import { AztecAddress, Fr } from '@aztec/circuits.js';
+
+import type { AvmContext } from '../avm_context.js';
+import { Field } 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 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,
+    OperandType.UINT8,
+    OperandType.UINT32,
+    OperandType.UINT32,
+  ];
+
+  constructor(private indirect: number, private addressOffset: number, private dstOffset: number) {
+    super();
+  }
+
+  async execute(context: AvmContext): Promise<void> {
+    const [addressOffset, dstOffset] = Addressing.fromWire(this.indirect).resolve(
+      [this.addressOffset, this.dstOffset],
+      context.machineState.memory,
+    );
+
+    const address = AztecAddress.fromField(context.machineState.memory.get(addressOffset).toFr());
+    const instance = await context.persistableState.hostStorage.contractsDb.getContractInstance(address);
+
+    const data =
+      instance === undefined
+        ? [
+            new Field(0), // not found
+            new Field(0),
+            new Field(0),
+            new Field(0),
+            new Field(0),
+            new Field(0),
+            new Field(0),
+          ]
+        : [
+            new Fr(1), // found
+            instance.salt,
+            instance.deployer.toField(),
+            instance.contractClassId,
+            instance.initializationHash,
+            instance.portalContractAddress.toField(),
+            instance.publicKeysHash,
+          ].map(f => new Field(f));
+
+    context.machineState.memory.setSlice(dstOffset, data);
+
+    context.machineState.incrementPc();
+  }
+}

package/src/avm/opcodes/control_flow.ts

@@ -1,5 +1,5 @@
 import type { AvmContext } from '../avm_context.js';
-import { IntegralValue } from '../avm_memory_types.js';
+import { type IntegralValue } from '../avm_memory_types.js';
 import { InstructionExecutionError } from '../errors.js';
 import { Opcode, OperandType } from '../serialization/instruction_serialization.js';
 import { Instruction } from './instruction.js';
@@ -14,8 +14,12 @@ export class Jump extends Instruction {
     super();
   }
 
-  async execute(context: AvmContext): Promise<void> {
+  public async execute(context: AvmContext): Promise<void> {
+    context.machineState.consumeGas(this.gasCost());
+
     context.machineState.pc = this.jumpOffset;
+
+    context.machineState.memory.assert({});
   }
 }
 
@@ -35,8 +39,12 @@ export class JumpI extends Instruction {
     super();
   }
 
-  async execute(context: AvmContext): Promise<void> {
-    const condition = context.machineState.memory.getAs<IntegralValue>(this.condOffset);
+  public async execute(context: AvmContext): Promise<void> {
+    const memoryOperations = { reads: 1, indirect: this.indirect };
+    const memory = context.machineState.memory.track(this.type);
+    context.machineState.consumeGas(this.gasCost(memoryOperations));
+
+    const condition = memory.getAs<IntegralValue>(this.condOffset);
 
     // TODO: reconsider this casting
     if (condition.toBigInt() == 0n) {
@@ -44,6 +52,8 @@ export class JumpI extends Instruction {
     } else {
       context.machineState.pc = this.loc;
     }
+
+    memory.assert(memoryOperations);
   }
 }
 
@@ -57,9 +67,13 @@ export class InternalCall extends Instruction {
     super();
   }
 
-  async execute(context: AvmContext): Promise<void> {
+  public async execute(context: AvmContext): Promise<void> {
+    context.machineState.consumeGas(this.gasCost());
+
     context.machineState.internalCallStack.push(context.machineState.pc + 1);
     context.machineState.pc = this.loc;
+
+    context.machineState.memory.assert({});
   }
 }
 
@@ -73,11 +87,15 @@ export class InternalReturn extends Instruction {
     super();
   }
 
-  async execute(context: AvmContext): Promise<void> {
+  public async execute(context: AvmContext): Promise<void> {
+    context.machineState.consumeGas(this.gasCost());
+
     const jumpOffset = context.machineState.internalCallStack.pop();
     if (jumpOffset === undefined) {
       throw new InstructionExecutionError('Internal call stack empty!');
     }
     context.machineState.pc = jumpOffset;
+
+    context.machineState.memory.assert({});
   }
 }