@aztec/simulator 0.0.0-test.1 → 0.0.1-commit.023c3e5

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

@@ -1,7 +1,11 @@
+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 { TaggedMemory, type TaggedMemoryInterface } from '../avm_memory_types.js';
-import { RelativeAddressOutOfRangeError } from '../errors.js';
+import { MemoryValue, TaggedMemory, type TaggedMemoryInterface, TypeTag } from '../avm_memory_types.js';
+import { RelativeAddressOutOfRangeError, TagCheckError } from '../errors.js';
 
 export enum AddressingMode {
   DIRECT = 0,
@@ -13,21 +17,26 @@ export enum AddressingMode {
 /** A class to represent the addressing mode of an instruction. */
 export class Addressing {
   public constructor(
-    /** The addressing mode for each operand. The length of this array is the number of operands of the instruction. */
-    private readonly modePerOperand: AddressingMode[],
+    /** The addressing mode for each possible operand. */
+    private readonly modePerOperand: Tuple<AddressingMode, typeof AVM_MAX_OPERANDS>,
   ) {}
 
-  // TODO(facundo): 8 for backwards compatibility.
-  public static fromWire(wireModes: number, numOperands: number = 8): Addressing {
-    // 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 most significant bit represents the last operand.
-    const modes = new Array<AddressingMode>(numOperands);
-    for (let i = 0; i < numOperands; i++) {
+  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) & 1) * AddressingMode.INDIRECT) |
-        (((wireModes >> (i + numOperands)) & 1) * AddressingMode.RELATIVE);
+        (((wireModes >> (i * 2)) & 1) * AddressingMode.INDIRECT) |
+        (((wireModes >> (i * 2 + 1)) & 1) * AddressingMode.RELATIVE);
     }
-    return new Addressing(modes);
+    // 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 {
@@ -36,50 +45,65 @@ export class Addressing {
     let wire: number = 0;
     for (let i = 0; i < this.modePerOperand.length; i++) {
       if (this.modePerOperand[i] & AddressingMode.INDIRECT) {
-        wire |= 1 << i;
+        wire |= 1 << (i * 2);
       }
       if (this.modePerOperand[i] & AddressingMode.RELATIVE) {
-        wire |= 1 << (this.modePerOperand.length + i);
+        wire |= 1 << (i * 2 + 1);
       }
     }
     return wire;
   }
 
-  /** Returns how many operands use the given addressing mode. */
-  public count(mode: AddressingMode): number {
-    return this.modePerOperand.filter(m => (m & mode) !== 0).length;
+  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.
+   * @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[] {
-    assert(offsets.length <= this.modePerOperand.length);
-    const resolved = new Array(offsets.length);
-
-    let didRelativeOnce = false;
-    let baseAddr = 0;
+    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 (!didRelativeOnce) {
-          mem.checkIsValidMemoryOffsetTag(0);
-          baseAddr = Number(mem.get(0).toBigInt());
-          didRelativeOnce = true;
+        if (!baseAddr) {
+          baseAddr = mem.get(0);
+          const baseAddrTag = baseAddr.getTag();
+          if (!TaggedMemory.isValidMemoryAddressTag(baseAddrTag!)) {
+            throw TagCheckError.forBaseAddress(TypeTag[baseAddrTag!]);
+          }
         }
-        resolved[i] += baseAddr;
+        // 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(baseAddr, offset);
+          throw new RelativeAddressOutOfRangeError(Number(baseAddr.toBigInt()), offset);
         }
       }
       if (mode & AddressingMode.INDIRECT) {
-        mem.checkIsValidMemoryOffsetTag(resolved[i]);
-        resolved[i] = Number(mem.get(resolved[i]).toBigInt());
+        // 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.forIndirectAddress(resolved[i], TypeTag[resolvedTag]);
+        }
+
+        resolved[i] = Number(resolvedValue.toBigInt());
       }
     }
     return resolved;

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

@@ -1,6 +1,7 @@
 import type { AvmContext } from '../avm_context.js';
 import {
   type Field,
+  type IntegralValue,
   type MemoryValue,
   TaggedMemory,
   type TaggedMemoryInterface,
@@ -14,10 +15,13 @@ import { ThreeOperandInstruction } from './instruction_impl.js';
 export abstract class ThreeOperandArithmeticInstruction extends ThreeOperandInstruction {
   public async execute(context: AvmContext): Promise<void> {
     const memory = context.machineState.memory;
-    context.machineState.consumeGas(this.gasCost());
+    const addressing = Addressing.fromWire(this.addressingMode);
+
+    context.machineState.consumeGas(
+      this.baseGasCost(addressing.indirectOperandsCount(), addressing.relativeOperandsCount()),
+    );
 
     const operands = [this.aOffset, this.bOffset, this.dstOffset];
-    const addressing = Addressing.fromWire(this.indirect, operands.length);
     const [aOffset, bOffset, dstOffset] = addressing.resolve(operands, memory);
     this.checkTags(memory, aOffset, bOffset);
 
@@ -84,7 +88,9 @@ export class FieldDiv extends ThreeOperandArithmeticInstruction {
   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);
+    if (b.toBigInt() === 0n) {
+      throw new ArithmeticError('Division by zero');
+    }
     return a.fdiv(b);
   }
 
@@ -93,3 +99,31 @@ export class FieldDiv extends ThreeOperandArithmeticInstruction {
     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

@@ -1,4 +1,5 @@
 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';
@@ -8,13 +9,19 @@ import { ThreeOperandInstruction } from './instruction_impl.js';
 abstract class ThreeOperandBitwiseInstruction extends ThreeOperandInstruction {
   public async execute(context: AvmContext): Promise<void> {
     const memory = context.machineState.memory;
-    context.machineState.consumeGas(this.gasCost());
+    const addressing = Addressing.fromWire(this.addressingMode);
+
+    context.machineState.consumeGas(
+      this.baseGasCost(addressing.indirectOperandsCount(), addressing.relativeOperandsCount()),
+    );
 
     const operands = [this.aOffset, this.bOffset, this.dstOffset];
-    const addressing = Addressing.fromWire(this.indirect, operands.length);
     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);
 
@@ -27,6 +34,10 @@ abstract class ThreeOperandBitwiseInstruction extends ThreeOperandInstruction {
     TaggedMemory.checkIsIntegralTag(memory.getTag(aOffset));
     memory.checkTagsAreSame(aOffset, bOffset);
   }
+
+  protected getDynamicMultiplier(_lhsTag: TypeTag): number {
+    return 0;
+  }
 }
 
 export class And extends ThreeOperandBitwiseInstruction {
@@ -36,6 +47,10 @@ export class And extends ThreeOperandBitwiseInstruction {
   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 {
@@ -45,6 +60,10 @@ export class Or extends ThreeOperandBitwiseInstruction {
   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 {
@@ -54,31 +73,9 @@ export class Xor extends ThreeOperandBitwiseInstruction {
   protected override compute(a: IntegralValue, b: IntegralValue): IntegralValue {
     return a.xor(b);
   }
-}
 
-export class Shl extends ThreeOperandBitwiseInstruction {
-  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) {
-    TaggedMemory.checkIsIntegralTag(memory.getTag(aOffset));
-    memory.checkTag(TypeTag.UINT8, bOffset);
-  }
-}
-
-export class Shr extends ThreeOperandBitwiseInstruction {
-  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) {
-    TaggedMemory.checkIsIntegralTag(memory.getTag(aOffset));
-    memory.checkTag(TypeTag.UINT8, bOffset);
+  protected override getDynamicMultiplier(lhsTag: TypeTag): number {
+    return getBitwiseDynamicGasMultiplier(lhsTag);
   }
 }
 
@@ -89,16 +86,23 @@ export class Not extends Instruction {
   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) {
+  constructor(
+    private addressingMode: number,
+    private srcOffset: number,
+    private dstOffset: number,
+  ) {
     super();
   }
 
   public async execute(context: AvmContext): Promise<void> {
     const memory = context.machineState.memory;
-    context.machineState.consumeGas(this.gasCost());
+    const addressing = Addressing.fromWire(this.addressingMode);
+
+    context.machineState.consumeGas(
+      this.baseGasCost(addressing.indirectOperandsCount(), addressing.relativeOperandsCount()),
+    );
 
     const operands = [this.srcOffset, this.dstOffset];
-    const addressing = Addressing.fromWire(this.indirect, operands.length);
     const [srcOffset, dstOffset] = addressing.resolve(operands, memory);
     TaggedMemory.checkIsIntegralTag(memory.getTag(srcOffset));
     const value = memory.getAs<IntegralValue>(srcOffset);

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

@@ -7,12 +7,15 @@ import { ThreeOperandInstruction } from './instruction_impl.js';
 abstract class ComparatorInstruction extends ThreeOperandInstruction {
   public async execute(context: AvmContext): Promise<void> {
     const memory = context.machineState.memory;
-    context.machineState.consumeGas(this.gasCost());
+    const addressing = Addressing.fromWire(this.addressingMode);
+
+    context.machineState.consumeGas(
+      this.baseGasCost(addressing.indirectOperandsCount(), addressing.relativeOperandsCount()),
+    );
 
     const operands = [this.aOffset, this.bOffset, this.dstOffset];
-    const addressing = Addressing.fromWire(this.indirect, operands.length);
     const [aOffset, bOffset, dstOffset] = addressing.resolve(operands, memory);
-    memory.checkTagsAreSame(aOffset, bOffset);
+    memory.checkTagsAreSame(aOffset, bOffset); // Brillig semantic enforces that tags match.
 
     const a = memory.get(aOffset);
     const b = memory.get(bOffset);

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

@@ -17,18 +17,16 @@ export class GetContractInstance extends Instruction {
   // Informs (de)serialization. See Instruction.deserialize.
   static readonly wireFormat: OperandType[] = [
     OperandType.UINT8, // opcode
-    OperandType.UINT8, // indirect bits
+    OperandType.UINT8, // addressing_mode bits
     OperandType.UINT16, // addressOffset
     OperandType.UINT16, // dstOffset
-    OperandType.UINT16, // existsOfsset
     OperandType.UINT8, // member enum (immediate)
   ];
 
   constructor(
-    private indirect: number,
+    private addressingMode: number,
     private addressOffset: number,
     private dstOffset: number,
-    private existsOffset: number,
     private memberEnum: number,
   ) {
     super();
@@ -36,15 +34,18 @@ export class GetContractInstance extends Instruction {
 
   async execute(context: AvmContext): Promise<void> {
     const memory = context.machineState.memory;
-    context.machineState.consumeGas(this.gasCost());
+    const addressing = Addressing.fromWire(this.addressingMode);
+
+    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, this.existsOffset];
-    const addressing = Addressing.fromWire(this.indirect, operands.length);
-    const [addressOffset, dstOffset, existsOffset] = addressing.resolve(operands, memory);
+    const operands = [this.addressOffset, this.dstOffset];
+    const [addressOffset, dstOffset] = addressing.resolve(operands, memory);
     memory.checkTag(TypeTag.FIELD, addressOffset);
 
     const address = memory.get(addressOffset).toAztecAddress();
@@ -66,7 +67,6 @@ export class GetContractInstance extends Instruction {
       }
     }
 
-    memory.set(existsOffset, new Uint1(exists ? 1 : 0));
-    memory.set(dstOffset, memberValue);
+    memory.setSlice(dstOffset, [new Uint1(exists ? 1 : 0), memberValue]);
   }
 }

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

@@ -1,5 +1,5 @@
 import type { AvmContext } from '../avm_context.js';
-import type { IntegralValue } from '../avm_memory_types.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';
@@ -16,7 +16,7 @@ export class Jump extends Instruction {
   }
 
   public async execute(context: AvmContext): Promise<void> {
-    context.machineState.consumeGas(this.gasCost());
+    context.machineState.consumeGas(this.baseGasCost(0, 0));
 
     context.machineState.pc = this.jumpOffset;
   }
@@ -38,20 +38,29 @@ export class JumpI extends Instruction {
     OperandType.UINT32,
   ];
 
-  constructor(private indirect: number, private condOffset: number, private loc: number) {
+  constructor(
+    private addressingMode: number,
+    private condOffset: number,
+    private loc: number,
+  ) {
     super();
   }
 
   public async execute(context: AvmContext): Promise<void> {
     const memory = context.machineState.memory;
-    context.machineState.consumeGas(this.gasCost());
+    const addressing = Addressing.fromWire(this.addressingMode);
+
+    context.machineState.consumeGas(
+      this.baseGasCost(addressing.indirectOperandsCount(), addressing.relativeOperandsCount()),
+    );
 
     const operands = [this.condOffset];
-    const addressing = Addressing.fromWire(this.indirect, operands.length);
-    const [condOffset] = addressing.resolve(operands, memory);
-    const condition = memory.getAs<IntegralValue>(condOffset);
+    const [resolvedCondOffset] = addressing.resolve(operands, memory);
+
+    memory.checkTag(TypeTag.UINT1, resolvedCondOffset);
+    const condition = memory.getAs<Uint1>(resolvedCondOffset);
 
-    if (condition.toBigInt() == 0n) {
+    if (condition.toNumber() == 0) {
       context.machineState.pc = context.machineState.nextPc;
     } else {
       context.machineState.pc = this.loc;
@@ -74,7 +83,7 @@ export class InternalCall extends Instruction {
   }
 
   public async execute(context: AvmContext): Promise<void> {
-    context.machineState.consumeGas(this.gasCost());
+    context.machineState.consumeGas(this.baseGasCost(0, 0));
 
     context.machineState.internalCallStack.push({
       callPc: context.machineState.pc,
@@ -99,7 +108,7 @@ export class InternalReturn extends Instruction {
   }
 
   public async execute(context: AvmContext): Promise<void> {
-    context.machineState.consumeGas(this.gasCost());
+    context.machineState.consumeGas(this.baseGasCost(0, 0));
 
     const stackEntry = context.machineState.internalCallStack.pop();
     if (stackEntry === undefined) {

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

@@ -12,7 +12,7 @@ export class ToRadixBE extends Instruction {
   // Informs (de)serialization. See Instruction.deserialize.
   static readonly wireFormat: OperandType[] = [
     OperandType.UINT8, // Opcode
-    OperandType.UINT16, // Indirect
+    OperandType.UINT16, // addressing_mode
     OperandType.UINT16, // src memory address
     OperandType.UINT16, // radix memory address
     OperandType.UINT16, // number of limbs address
@@ -21,7 +21,7 @@ export class ToRadixBE extends Instruction {
   ];
 
   constructor(
-    private indirect: number,
+    private addressingMode: number,
     private srcOffset: number,
     private radixOffset: number,
     private numLimbsOffset: number,
@@ -33,8 +33,13 @@ export class ToRadixBE extends Instruction {
 
   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 addressing = Addressing.fromWire(this.indirect, operands.length);
     const [srcOffset, radixOffset, numLimbsOffset, outputBitsOffset, dstOffset] = addressing.resolve(operands, memory);
 
     // The radix gadget only takes in a Field
@@ -44,11 +49,13 @@ export class ToRadixBE extends Instruction {
     memory.checkTag(TypeTag.UINT1, outputBitsOffset);
 
     const numLimbs = memory.get(numLimbsOffset).toNumber();
-    context.machineState.consumeGas(this.gasCost(numLimbs));
+    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();
-    const radix: bigint = memory.get(radixOffset).toBigInt();
 
     if (radix < 2 || radix > 256) {
       throw new InvalidToRadixInputsError(`ToRadixBE instruction's radix should be in range [2,256] (was ${radix}).`);
@@ -73,8 +80,25 @@ export class ToRadixBE extends Instruction {
       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

@@ -1,8 +1,9 @@
-import { Grumpkin } from '@aztec/foundation/crypto';
-import { Point } from '@aztec/foundation/fields';
+import { Grumpkin } from '@aztec/foundation/crypto/grumpkin';
+import { Point } from '@aztec/foundation/curves/grumpkin';
 
 import type { AvmContext } from '../avm_context.js';
 import { Field, TypeTag, Uint1 } 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';
@@ -25,7 +26,7 @@ export class EcAdd extends Instruction {
   ];
 
   constructor(
-    private indirect: number,
+    private addressingMode: number,
     private p1XOffset: number,
     private p1YOffset: number,
     private p1IsInfiniteOffset: number,
@@ -39,7 +40,11 @@ export class EcAdd extends Instruction {
 
   public async execute(context: AvmContext): Promise<void> {
     const memory = context.machineState.memory;
-    context.machineState.consumeGas(this.gasCost());
+    const addressing = Addressing.fromWire(this.addressingMode);
+
+    context.machineState.consumeGas(
+      this.baseGasCost(addressing.indirectOperandsCount(), addressing.relativeOperandsCount()),
+    );
 
     const operands = [
       this.p1XOffset,
@@ -50,7 +55,6 @@ export class EcAdd extends Instruction {
       this.p2IsInfiniteOffset,
       this.dstOffset,
     ];
-    const addressing = Addressing.fromWire(this.indirect, operands.length);
     const [p1XOffset, p1YOffset, p1IsInfiniteOffset, p2XOffset, p2YOffset, p2IsInfiniteOffset, dstOffset] =
       addressing.resolve(operands, memory);
 
@@ -62,7 +66,7 @@ export class EcAdd extends Instruction {
     const p1IsInfinite = memory.get(p1IsInfiniteOffset).toNumber() === 1;
     const p1 = new Point(p1X.toFr(), p1Y.toFr(), p1IsInfinite);
     if (!p1.isOnGrumpkin()) {
-      throw new Error(`Point1 is not on the curve`);
+      throw new EcAddPointNotOnCurveError(/*pointIndex=*/ 1, p1);
     }
 
     const p2X = memory.get(p2XOffset);
@@ -71,17 +75,25 @@ export class EcAdd extends Instruction {
     const p2IsInfinite = memory.get(p2IsInfiniteOffset).toNumber() === 1;
     const p2 = new Point(p2X.toFr(), p2Y.toFr(), p2IsInfinite);
     if (!p2.isOnGrumpkin()) {
-      throw new Error(`Point1 is not on the curve`);
+      throw new EcAddPointNotOnCurveError(/*pointIndex=*/ 2, p2);
     }
 
-    const grumpkin = new Grumpkin();
     let dest;
-    if (p1IsInfinite) {
+    if (p1IsInfinite && p2IsInfinite) {
+      dest = Point.ZERO;
+    } else if (p1IsInfinite) {
       dest = p2;
     } else if (p2IsInfinite) {
       dest = p1;
     } else {
-      dest = await grumpkin.add(p1, p2);
+      // 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.ZERO;
+      } else {
+        dest = await Grumpkin.add(p1, p2);
+      }
     }
 
     // Important to use setSlice() and not set() in the two following statements as