@aztec/simulator 0.0.1-commit.2f68f620 → 0.0.1-commit.3100065

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

@@ -0,0 +1,129 @@
+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.addressingMode);
+
+    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 {
+    if (b.toBigInt() === 0n) {
+      throw new ArithmeticError('Division by zero');
+    }
+    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);
+  }
+
+  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 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);
+  }
+
+  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
+  }
+}

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

@@ -0,0 +1,113 @@
+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.addressingMode);
+
+    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 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);
+    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

@@ -0,0 +1,55 @@
+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.addressingMode);
+
+    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

@@ -0,0 +1,76 @@
+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,
+  IMMUTABLES_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, // addressing_mode bits
+    OperandType.UINT16, // addressOffset
+    OperandType.UINT16, // dstOffset
+    OperandType.UINT8, // member enum (immediate)
+  ];
+
+  constructor(
+    private addressingMode: 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.addressingMode);
+
+    context.machineState.consumeGas(
+      this.baseGasCost(addressing.indirectOperandsCount(), addressing.relativeOperandsCount()),
+    );
+
+    if (!(this.memberEnum in ContractInstanceMember)) {
+      throw new InstructionExecutionError(`Invalid GETCONTRACTINSTANCE 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;
+        case ContractInstanceMember.IMMUTABLES_HASH:
+          memberValue = new Field(instance.immutablesHash);
+          break;
+      }
+    }
+
+    memory.setSlice(dstOffset, [new Uint1(exists ? 1 : 0), memberValue]);
+  }
+}

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

@@ -0,0 +1,123 @@
+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 addressingMode: 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.addressingMode);
+
+    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;
+  }
+}

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

@@ -0,0 +1,104 @@
+import type { AvmContext } from '../avm_context.js';
+import { TypeTag, Uint1, Uint8 } from '../avm_memory_types.js';
+import { InvalidToRadixInputsError } from '../errors.js';
+import { Opcode, OperandType } from '../serialization/instruction_serialization.js';
+import { Addressing } from './addressing_mode.js';
+import { Instruction } from './instruction.js';
+
+export class ToRadixBE extends Instruction {
+  static type: string = 'TORADIXBE';
+  static readonly opcode: Opcode = Opcode.TORADIXBE;
+
+  // Informs (de)serialization. See Instruction.deserialize.
+  static readonly wireFormat: OperandType[] = [
+    OperandType.UINT8, // Opcode
+    OperandType.UINT16, // addressing_mode
+    OperandType.UINT16, // src memory address
+    OperandType.UINT16, // radix memory address
+    OperandType.UINT16, // number of limbs address
+    OperandType.UINT16, // output is in "bits" mode memory address (boolean/Uint1 is stored)
+    OperandType.UINT16, // dst memory address
+  ];
+
+  constructor(
+    private addressingMode: number,
+    private srcOffset: number,
+    private radixOffset: number,
+    private numLimbsOffset: number,
+    private outputBitsOffset: 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.radixOffset, this.numLimbsOffset, this.outputBitsOffset, this.dstOffset];
+    const [srcOffset, radixOffset, numLimbsOffset, outputBitsOffset, dstOffset] = addressing.resolve(operands, memory);
+
+    // The radix gadget only takes in a Field
+    memory.checkTag(TypeTag.FIELD, srcOffset);
+    memory.checkTag(TypeTag.UINT32, radixOffset);
+    memory.checkTag(TypeTag.UINT32, numLimbsOffset);
+    memory.checkTag(TypeTag.UINT1, outputBitsOffset);
+
+    const numLimbs = memory.get(numLimbsOffset).toNumber();
+    const radix: bigint = memory.get(radixOffset).toBigInt();
+    context.machineState.consumeGas(
+      this.dynamicGasCost(Math.max(numLimbs, radix > 256n ? 32 : MODULUS_LIMBS_PER_RADIX[Number(radix)])),
+    );
+    const outputBits = memory.get(outputBitsOffset).toNumber();
+
+    let value: bigint = memory.get(srcOffset).toBigInt();
+
+    if (radix < 2 || radix > 256) {
+      throw new InvalidToRadixInputsError(`ToRadixBE instruction's radix should be in range [2,256] (was ${radix}).`);
+    }
+
+    if (numLimbs < 1 && value != BigInt(0n)) {
+      throw new InvalidToRadixInputsError(
+        `ToRadixBE instruction's input value is not zero (was ${value}) but numLimbs zero.`,
+      );
+    }
+
+    if (outputBits != 0 && radix != BigInt(2n)) {
+      throw new InvalidToRadixInputsError(`Radix ${radix} is not equal to 2 and bit mode is activated.`);
+    }
+
+    const radixBN: bigint = BigInt(radix);
+    const limbArray = new Array(numLimbs);
+
+    for (let i = numLimbs - 1; i >= 0; i--) {
+      const limb = value % radixBN;
+      limbArray[i] = limb;
+      value /= radixBN;
+    }
+
+    if (value !== 0n) {
+      throw new InvalidToRadixInputsError(`Field failed to decompose in ${numLimbs} limbs.`);
+    }
+
+    const outputType = outputBits != 0 ? Uint1 : Uint8;
+    const res = limbArray.map(byte => new outputType(byte));
+    memory.setSlice(dstOffset, res);
+  }
+}
+
+// First two are for radix = 0 and 1, which are invalid, so we have 0 limbs for those cases.
+export const MODULUS_LIMBS_PER_RADIX: number[] = [
+  0, 0, 254, 161, 127, 110, 99, 91, 85, 81, 77, 74, 71, 69, 67, 65, 64, 63, 61, 60, 59, 58, 57, 57, 56, 55, 54, 54, 53,
+  53, 52, 52, 51, 51, 50, 50, 50, 49, 49, 48, 48, 48, 48, 47, 47, 47, 46, 46, 46, 46, 45, 45, 45, 45, 45, 44, 44, 44,
+  44, 44, 43, 43, 43, 43, 43, 43, 42, 42, 42, 42, 42, 42, 42, 41, 41, 41, 41, 41, 41, 41, 41, 41, 40, 40, 40, 40, 40,
+  40, 40, 40, 40, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38,
+  37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
+  36, 36, 36, 36, 36, 36, 36, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
+  35, 35, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,
+  34, 34, 34, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
+  33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
+];

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

@@ -0,0 +1,86 @@
+import { Grumpkin } from '@aztec/foundation/crypto/grumpkin';
+import { Point } from '@aztec/foundation/curves/grumpkin';
+
+import type { AvmContext } from '../avm_context.js';
+import { Field, TypeTag } from '../avm_memory_types.js';
+import { EcAddPointNotOnCurveError } from '../errors.js';
+import { Opcode, OperandType } from '../serialization/instruction_serialization.js';
+import { Addressing } from './addressing_mode.js';
+import { Instruction } from './instruction.js';
+
+export class EcAdd extends Instruction {
+  static type: string = 'ECADD';
+  static readonly opcode = Opcode.ECADD;
+
+  // Informs (de)serialization. See Instruction.deserialize.
+  static readonly wireFormat: OperandType[] = [
+    OperandType.UINT8, // reserved
+    OperandType.UINT16, // indirect
+    OperandType.UINT16, // p1X
+    OperandType.UINT16, // p1Y
+    OperandType.UINT16, // p2X
+    OperandType.UINT16, // p2Y
+    OperandType.UINT16, // dst
+  ];
+
+  constructor(
+    private addressingMode: number,
+    private p1XOffset: number,
+    private p1YOffset: number,
+    private p2XOffset: number,
+    private p2YOffset: 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.p1XOffset, this.p1YOffset, this.p2XOffset, this.p2YOffset, this.dstOffset];
+    const [p1XOffset, p1YOffset, p2XOffset, p2YOffset, dstOffset] = addressing.resolve(operands, memory);
+
+    memory.checkTags(TypeTag.FIELD, p1XOffset, p1YOffset, p2XOffset, p2YOffset);
+
+    const p1X = memory.get(p1XOffset);
+    const p1Y = memory.get(p1YOffset);
+    const p1 = new Point(p1X.toFr(), p1Y.toFr());
+    if (!p1.isOnCurve()) {
+      throw new EcAddPointNotOnCurveError(/*pointIndex=*/ 1, p1);
+    }
+
+    const p2X = memory.get(p2XOffset);
+    const p2Y = memory.get(p2YOffset);
+    const p2 = new Point(p2X.toFr(), p2Y.toFr());
+    if (!p2.isOnCurve()) {
+      throw new EcAddPointNotOnCurveError(/*pointIndex=*/ 2, p2);
+    }
+
+    let dest;
+    if (p1.isInfinite && p2.isInfinite) {
+      dest = Point.INFINITY;
+    } else if (p1.isInfinite) {
+      dest = p2;
+    } else if (p2.isInfinite) {
+      dest = p1;
+    } else {
+      // TS<>BB ecc add communication is broken for points that add up to infinity.
+      // However, here we know that both points are on the curve, and that none is infinity
+      // so we can check for the case where you add p + (-p) = infinity.
+      if (p1.x.equals(p2.x) && !p1.y.equals(p2.y)) {
+        dest = Point.INFINITY;
+      } else {
+        dest = await Grumpkin.add(p1, p2);
+      }
+    }
+
+    // Important to use setSlice() and not set() in the two following statements as
+    // this checks that the offsets lie within memory range.
+    memory.setSlice(dstOffset, [new Field(dest.x), new Field(dest.y)]);
+  }
+}