@aztec/simulator 0.56.0 → 0.58.0

package/src/avm/opcodes/accrued_substate.ts

@@ -1,5 +1,5 @@
 import type { AvmContext } from '../avm_context.js';
-import { TypeTag, Uint8 } from '../avm_memory_types.js';
+import { TypeTag, Uint1 } from '../avm_memory_types.js';
 import { InstructionExecutionError, StaticCallAlterationError } from '../errors.js';
 import { NullifierCollisionError } from '../journal/nullifiers.js';
 import { Opcode, OperandType } from '../serialization/instruction_serialization.js';
@@ -13,9 +13,9 @@ export class NoteHashExists extends Instruction {
   static readonly wireFormat = [
     OperandType.UINT8,
     OperandType.UINT8,
-    OperandType.UINT32,
-    OperandType.UINT32,
-    OperandType.UINT32,
+    OperandType.UINT16,
+    OperandType.UINT16,
+    OperandType.UINT16,
   ];
 
   constructor(
@@ -28,13 +28,11 @@ export class NoteHashExists extends Instruction {
   }
 
   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 [noteHashOffset, leafIndexOffset, existsOffset] = Addressing.fromWire(this.indirect).resolve(
-      [this.noteHashOffset, this.leafIndexOffset, this.existsOffset],
-      memory,
-    );
+    context.machineState.consumeGas(this.gasCost());
+    const operands = [this.noteHashOffset, this.leafIndexOffset, this.existsOffset];
+    const addressing = Addressing.fromWire(this.indirect, operands.length);
+    const [noteHashOffset, leafIndexOffset, existsOffset] = addressing.resolve(operands, memory);
     memory.checkTags(TypeTag.FIELD, noteHashOffset, leafIndexOffset);
 
     // Note that this instruction accepts any type in memory, and converts to Field.
@@ -46,9 +44,9 @@ export class NoteHashExists extends Instruction {
       noteHash,
       leafIndex,
     );
-    memory.set(existsOffset, exists ? new Uint8(1) : new Uint8(0));
+    memory.set(existsOffset, exists ? new Uint1(1) : new Uint1(0));
 
-    memory.assert(memoryOperations);
+    memory.assert({ reads: 2, writes: 1, addressing });
     context.machineState.incrementPc();
   }
 }
@@ -57,18 +55,19 @@ export class EmitNoteHash extends Instruction {
   static type: string = 'EMITNOTEHASH';
   static readonly opcode: Opcode = Opcode.EMITNOTEHASH;
   // Informs (de)serialization. See Instruction.deserialize.
-  static readonly wireFormat = [OperandType.UINT8, OperandType.UINT8, OperandType.UINT32];
+  static readonly wireFormat = [OperandType.UINT8, OperandType.UINT8, OperandType.UINT16];
 
   constructor(private indirect: number, private noteHashOffset: number) {
     super();
   }
 
   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));
+    context.machineState.consumeGas(this.gasCost());
 
-    const [noteHashOffset] = Addressing.fromWire(this.indirect).resolve([this.noteHashOffset], memory);
+    const operands = [this.noteHashOffset];
+    const addressing = Addressing.fromWire(this.indirect, operands.length);
+    const [noteHashOffset] = addressing.resolve(operands, memory);
     memory.checkTag(TypeTag.FIELD, noteHashOffset);
 
     if (context.environment.isStaticCall) {
@@ -78,7 +77,7 @@ export class EmitNoteHash extends Instruction {
     const noteHash = memory.get(noteHashOffset).toFr();
     context.persistableState.writeNoteHash(context.environment.storageAddress, noteHash);
 
-    memory.assert(memoryOperations);
+    memory.assert({ reads: 1, addressing });
     context.machineState.incrementPc();
   }
 }
@@ -90,9 +89,9 @@ export class NullifierExists extends Instruction {
   static readonly wireFormat = [
     OperandType.UINT8,
     OperandType.UINT8,
-    OperandType.UINT32,
-    OperandType.UINT32,
-    OperandType.UINT32,
+    OperandType.UINT16,
+    OperandType.UINT16,
+    OperandType.UINT16,
   ];
 
   constructor(
@@ -105,23 +104,21 @@ export class NullifierExists extends Instruction {
   }
 
   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));
+    context.machineState.consumeGas(this.gasCost());
 
-    const [nullifierOffset, addressOffset, existsOffset] = Addressing.fromWire(this.indirect).resolve(
-      [this.nullifierOffset, this.addressOffset, this.existsOffset],
-      memory,
-    );
+    const operands = [this.nullifierOffset, this.addressOffset, this.existsOffset];
+    const addressing = Addressing.fromWire(this.indirect, operands.length);
+    const [nullifierOffset, addressOffset, existsOffset] = addressing.resolve(operands, memory);
     memory.checkTags(TypeTag.FIELD, nullifierOffset, addressOffset);
 
     const nullifier = memory.get(nullifierOffset).toFr();
     const address = memory.get(addressOffset).toFr();
     const exists = await context.persistableState.checkNullifierExists(address, nullifier);
 
-    memory.set(existsOffset, exists ? new Uint8(1) : new Uint8(0));
+    memory.set(existsOffset, exists ? new Uint1(1) : new Uint1(0));
 
-    memory.assert(memoryOperations);
+    memory.assert({ reads: 2, writes: 1, addressing });
     context.machineState.incrementPc();
   }
 }
@@ -130,7 +127,7 @@ export class EmitNullifier extends Instruction {
   static type: string = 'EMITNULLIFIER';
   static readonly opcode: Opcode = Opcode.EMITNULLIFIER;
   // Informs (de)serialization. See Instruction.deserialize.
-  static readonly wireFormat = [OperandType.UINT8, OperandType.UINT8, OperandType.UINT32];
+  static readonly wireFormat = [OperandType.UINT8, OperandType.UINT8, OperandType.UINT16];
 
   constructor(private indirect: number, private nullifierOffset: number) {
     super();
@@ -141,11 +138,12 @@ export class EmitNullifier extends Instruction {
       throw new StaticCallAlterationError();
     }
 
-    const memoryOperations = { reads: 1, indirect: this.indirect };
     const memory = context.machineState.memory.track(this.type);
-    context.machineState.consumeGas(this.gasCost(memoryOperations));
+    context.machineState.consumeGas(this.gasCost());
 
-    const [nullifierOffset] = Addressing.fromWire(this.indirect).resolve([this.nullifierOffset], memory);
+    const operands = [this.nullifierOffset];
+    const addressing = Addressing.fromWire(this.indirect, operands.length);
+    const [nullifierOffset] = addressing.resolve(operands, memory);
     memory.checkTag(TypeTag.FIELD, nullifierOffset);
 
     const nullifier = memory.get(nullifierOffset).toFr();
@@ -162,7 +160,7 @@ export class EmitNullifier extends Instruction {
       }
     }
 
-    memory.assert(memoryOperations);
+    memory.assert({ reads: 1, addressing });
     context.machineState.incrementPc();
   }
 }
@@ -174,9 +172,9 @@ export class L1ToL2MessageExists extends Instruction {
   static readonly wireFormat = [
     OperandType.UINT8,
     OperandType.UINT8,
-    OperandType.UINT32,
-    OperandType.UINT32,
-    OperandType.UINT32,
+    OperandType.UINT16,
+    OperandType.UINT16,
+    OperandType.UINT16,
   ];
 
   constructor(
@@ -189,14 +187,12 @@ export class L1ToL2MessageExists extends Instruction {
   }
 
   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));
+    context.machineState.consumeGas(this.gasCost());
 
-    const [msgHashOffset, msgLeafIndexOffset, existsOffset] = Addressing.fromWire(this.indirect).resolve(
-      [this.msgHashOffset, this.msgLeafIndexOffset, this.existsOffset],
-      memory,
-    );
+    const operands = [this.msgHashOffset, this.msgLeafIndexOffset, this.existsOffset];
+    const addressing = Addressing.fromWire(this.indirect, operands.length);
+    const [msgHashOffset, msgLeafIndexOffset, existsOffset] = addressing.resolve(operands, memory);
     memory.checkTags(TypeTag.FIELD, msgHashOffset, msgLeafIndexOffset);
 
     const msgHash = memory.get(msgHashOffset).toFr();
@@ -206,9 +202,9 @@ export class L1ToL2MessageExists extends Instruction {
       msgHash,
       msgLeafIndex,
     );
-    memory.set(existsOffset, exists ? new Uint8(1) : new Uint8(0));
+    memory.set(existsOffset, exists ? new Uint1(1) : new Uint1(0));
 
-    memory.assert(memoryOperations);
+    memory.assert({ reads: 2, writes: 1, addressing });
     context.machineState.incrementPc();
   }
 }
@@ -217,7 +213,7 @@ export class EmitUnencryptedLog extends Instruction {
   static type: string = 'EMITUNENCRYPTEDLOG';
   static readonly opcode: Opcode = Opcode.EMITUNENCRYPTEDLOG;
   // Informs (de)serialization. See Instruction.deserialize.
-  static readonly wireFormat = [OperandType.UINT8, OperandType.UINT8, OperandType.UINT32, OperandType.UINT32];
+  static readonly wireFormat = [OperandType.UINT8, OperandType.UINT8, OperandType.UINT16, OperandType.UINT16];
 
   constructor(private indirect: number, private logOffset: number, private logSizeOffset: number) {
     super();
@@ -230,22 +226,20 @@ export class EmitUnencryptedLog extends Instruction {
 
     const memory = context.machineState.memory.track(this.type);
 
-    const [logOffset, logSizeOffset] = Addressing.fromWire(this.indirect).resolve(
-      [this.logOffset, this.logSizeOffset],
-      memory,
-    );
+    const operands = [this.logOffset, this.logSizeOffset];
+    const addressing = Addressing.fromWire(this.indirect, operands.length);
+    const [logOffset, logSizeOffset] = addressing.resolve(operands, memory);
     memory.checkTag(TypeTag.UINT32, logSizeOffset);
     const logSize = memory.get(logSizeOffset).toNumber();
     memory.checkTagsRange(TypeTag.FIELD, logOffset, logSize);
 
     const contractAddress = context.environment.address;
 
-    const memoryOperations = { reads: 1 + logSize, indirect: this.indirect };
-    context.machineState.consumeGas(this.gasCost({ ...memoryOperations, dynMultiplier: logSize }));
+    context.machineState.consumeGas(this.gasCost(logSize));
     const log = memory.getSlice(logOffset, logSize).map(f => f.toFr());
     context.persistableState.writeUnencryptedLog(contractAddress, log);
 
-    memory.assert(memoryOperations);
+    memory.assert({ reads: 1 + logSize, addressing });
     context.machineState.incrementPc();
   }
 }
@@ -254,7 +248,7 @@ export class SendL2ToL1Message extends Instruction {
   static type: string = 'SENDL2TOL1MSG';
   static readonly opcode: Opcode = Opcode.SENDL2TOL1MSG;
   // Informs (de)serialization. See Instruction.deserialize.
-  static readonly wireFormat = [OperandType.UINT8, OperandType.UINT8, OperandType.UINT32, OperandType.UINT32];
+  static readonly wireFormat = [OperandType.UINT8, OperandType.UINT8, OperandType.UINT16, OperandType.UINT16];
 
   constructor(private indirect: number, private recipientOffset: number, private contentOffset: number) {
     super();
@@ -265,20 +259,18 @@ export class SendL2ToL1Message extends Instruction {
       throw new StaticCallAlterationError();
     }
 
-    const memoryOperations = { reads: 2, indirect: this.indirect };
     const memory = context.machineState.memory.track(this.type);
-    context.machineState.consumeGas(this.gasCost(memoryOperations));
+    context.machineState.consumeGas(this.gasCost());
 
-    const [recipientOffset, contentOffset] = Addressing.fromWire(this.indirect).resolve(
-      [this.recipientOffset, this.contentOffset],
-      memory,
-    );
+    const operands = [this.recipientOffset, this.contentOffset];
+    const addressing = Addressing.fromWire(this.indirect, operands.length);
+    const [recipientOffset, contentOffset] = addressing.resolve(operands, memory);
 
     const recipient = memory.get(recipientOffset).toFr();
     const content = memory.get(contentOffset).toFr();
-    context.persistableState.writeL2ToL1Message(recipient, content);
+    context.persistableState.writeL2ToL1Message(context.environment.address, recipient, content);
 
-    memory.assert(memoryOperations);
+    memory.assert({ reads: 2, addressing });
     context.machineState.incrementPc();
   }
 }

package/src/avm/opcodes/addressing_mode.ts

@@ -3,9 +3,10 @@ import { strict as assert } from 'assert';
 import { type TaggedMemoryInterface } from '../avm_memory_types.js';
 
 export enum AddressingMode {
-  DIRECT,
-  INDIRECT,
-  INDIRECT_PLUS_CONSTANT, // Not implemented yet.
+  DIRECT = 0,
+  INDIRECT = 1,
+  RELATIVE = 2,
+  INDIRECT_RELATIVE = 3,
 }
 
 /** A class to represent the addressing mode of an instruction. */
@@ -13,16 +14,17 @@ 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[],
-  ) {
-    assert(modePerOperand.length <= 8, 'At most 8 operands are supported');
-  }
+  ) {}
 
-  public static fromWire(wireModes: number): Addressing {
+  // 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>(8);
-    for (let i = 0; i < 8; i++) {
-      modes[i] = (wireModes & (1 << i)) === 0 ? AddressingMode.DIRECT : AddressingMode.INDIRECT;
+    const modes = new Array<AddressingMode>(numOperands);
+    for (let i = 0; i < numOperands; i++) {
+      modes[i] =
+        (((wireModes >> i) & 1) * AddressingMode.INDIRECT) |
+        (((wireModes >> (i + numOperands)) & 1) * AddressingMode.RELATIVE);
     }
     return new Addressing(modes);
   }
@@ -31,17 +33,20 @@ export class 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 least significant bit represents the last operand.
     let wire: number = 0;
-    for (let i = 0; i < 8; i++) {
-      if (this.modePerOperand[i] === AddressingMode.INDIRECT) {
+    for (let i = 0; i < this.modePerOperand.length; i++) {
+      if (this.modePerOperand[i] & AddressingMode.INDIRECT) {
         wire |= 1 << i;
       }
+      if (this.modePerOperand[i] & AddressingMode.RELATIVE) {
+        wire |= 1 << (this.modePerOperand.length + i);
+      }
     }
     return wire;
   }
 
   /** Returns how many operands use the given addressing mode. */
   public count(mode: AddressingMode): number {
-    return this.modePerOperand.filter(m => m === mode).length;
+    return this.modePerOperand.filter(m => (m & mode) !== 0).length;
   }
 
   /**
@@ -54,17 +59,15 @@ export class Addressing {
     assert(offsets.length <= this.modePerOperand.length);
     const resolved = new Array(offsets.length);
     for (const [i, offset] of offsets.entries()) {
-      switch (this.modePerOperand[i]) {
-        case AddressingMode.INDIRECT:
-          // NOTE(reviewer): less than equal is a deviation from the spec - i dont see why this shouldnt be possible!
-          mem.checkIsValidMemoryOffsetTag(offset);
-          resolved[i] = Number(mem.get(offset).toBigInt());
-          break;
-        case AddressingMode.DIRECT:
-          resolved[i] = offset;
-          break;
-        default:
-          throw new Error(`Unimplemented addressing mode: ${AddressingMode[this.modePerOperand[i]]}`);
+      const mode = this.modePerOperand[i];
+      resolved[i] = offset;
+      if (mode & AddressingMode.RELATIVE) {
+        mem.checkIsValidMemoryOffsetTag(0);
+        resolved[i] += Number(mem.get(0).toBigInt());
+      }
+      if (mode & AddressingMode.INDIRECT) {
+        mem.checkIsValidMemoryOffsetTag(resolved[i]);
+        resolved[i] = Number(mem.get(resolved[i]).toBigInt());
       }
     }
     return resolved;

package/src/avm/opcodes/arithmetic.ts

@@ -6,15 +6,13 @@ import { ThreeOperandInstruction } from './instruction_impl.js';
 
 export abstract class ThreeOperandArithmeticInstruction 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));
+    context.machineState.consumeGas(this.gasCost());
 
-    const [aOffset, bOffset, dstOffset] = Addressing.fromWire(this.indirect).resolve(
-      [this.aOffset, this.bOffset, this.dstOffset],
-      memory,
-    );
-    memory.checkTags(this.inTag, aOffset, bOffset);
+    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);
 
     const a = memory.get(aOffset);
     const b = memory.get(bOffset);
@@ -22,7 +20,7 @@ export abstract class ThreeOperandArithmeticInstruction extends ThreeOperandInst
     const dest = this.compute(a, b);
     memory.set(dstOffset, dest);
 
-    memory.assert(memoryOperations);
+    memory.assert({ reads: 2, writes: 1, addressing });
     context.machineState.incrementPc();
   }
 

package/src/avm/opcodes/bitwise.ts

@@ -7,15 +7,13 @@ import { ThreeOperandInstruction } from './instruction_impl.js';
 
 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));
+    context.machineState.consumeGas(this.gasCost());
 
-    const [aOffset, bOffset, dstOffset] = Addressing.fromWire(this.indirect).resolve(
-      [this.aOffset, this.bOffset, this.dstOffset],
-      memory,
-    );
-    this.checkTags(memory, this.inTag, aOffset, bOffset);
+    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 a = memory.getAs<IntegralValue>(aOffset);
     const b = memory.getAs<IntegralValue>(bOffset);
@@ -23,13 +21,14 @@ abstract class ThreeOperandBitwiseInstruction extends ThreeOperandInstruction {
     const res = this.compute(a, b);
     memory.set(dstOffset, res);
 
-    memory.assert(memoryOperations);
+    memory.assert({ reads: 2, writes: 1, addressing });
     context.machineState.incrementPc();
   }
 
   protected abstract compute(a: IntegralValue, b: IntegralValue): IntegralValue;
-  protected checkTags(memory: TaggedMemoryInterface, inTag: number, aOffset: number, bOffset: number) {
-    memory.checkTags(inTag, aOffset, bOffset);
+  protected checkTags(memory: TaggedMemoryInterface, aOffset: number, bOffset: number) {
+    TaggedMemory.checkIsIntegralTag(memory.getTag(aOffset));
+    memory.checkTagsAreSame(aOffset, bOffset);
   }
 }
 
@@ -67,8 +66,8 @@ export class Shl extends ThreeOperandBitwiseInstruction {
   protected override compute(a: IntegralValue, b: IntegralValue): IntegralValue {
     return a.shl(b);
   }
-  protected override checkTags(memory: TaggedMemoryInterface, inTag: number, aOffset: number, bOffset: number) {
-    memory.checkTag(inTag, aOffset);
+  protected override checkTags(memory: TaggedMemoryInterface, aOffset: number, bOffset: number) {
+    TaggedMemory.checkIsIntegralTag(memory.getTag(aOffset));
     memory.checkTag(TypeTag.UINT8, bOffset);
   }
 }
@@ -80,8 +79,8 @@ export class Shr extends ThreeOperandBitwiseInstruction {
   protected override compute(a: IntegralValue, b: IntegralValue): IntegralValue {
     return a.shr(b);
   }
-  protected override checkTags(memory: TaggedMemoryInterface, inTag: number, aOffset: number, bOffset: number) {
-    memory.checkTag(inTag, aOffset);
+  protected override checkTags(memory: TaggedMemoryInterface, aOffset: number, bOffset: number) {
+    TaggedMemory.checkIsIntegralTag(memory.getTag(aOffset));
     memory.checkTag(TypeTag.UINT8, bOffset);
   }
 }
@@ -98,18 +97,19 @@ export class Not extends Instruction {
   }
 
   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));
+    context.machineState.consumeGas(this.gasCost());
 
-    const [srcOffset, dstOffset] = Addressing.fromWire(this.indirect).resolve([this.srcOffset, this.dstOffset], memory);
+    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);
 
     const res = value.not();
     memory.set(dstOffset, res);
 
-    memory.assert(memoryOperations);
+    memory.assert({ reads: 1, writes: 1, addressing });
     context.machineState.incrementPc();
   }
 }

package/src/avm/opcodes/commitment.ts

@@ -32,10 +32,10 @@ export class PedersenCommitment extends Instruction {
 
   public async execute(context: AvmContext): Promise<void> {
     const memory = context.machineState.memory.track(this.type);
-    const [inputOffset, outputOffset, inputSizeOffset, genIndexOffset] = Addressing.fromWire(this.indirect).resolve(
-      [this.inputOffset, this.outputOffset, this.inputSizeOffset, this.genIndexOffset],
-      memory,
-    );
+
+    const operands = [this.inputOffset, this.outputOffset, this.inputSizeOffset, this.genIndexOffset];
+    const addressing = Addressing.fromWire(this.indirect, operands.length);
+    const [inputOffset, outputOffset, inputSizeOffset, genIndexOffset] = addressing.resolve(operands, memory);
 
     const inputSize = memory.get(inputSizeOffset).toNumber();
     memory.checkTag(TypeTag.UINT32, inputSizeOffset);
@@ -46,8 +46,7 @@ export class PedersenCommitment extends Instruction {
     const generatorIndex = memory.get(genIndexOffset).toNumber();
     memory.checkTag(TypeTag.UINT32, genIndexOffset);
 
-    const memoryOperations = { reads: inputSize + 2, writes: 3, indirect: this.indirect };
-    context.machineState.consumeGas(this.gasCost({ ...memoryOperations, dynMultiplier: inputSize }));
+    context.machineState.consumeGas(this.gasCost(inputSize));
 
     const inputBuffer: Buffer[] = inputs.map(input => input.toBuffer());
     // TODO: Add the generate index to the pedersenCommit function
@@ -60,7 +59,7 @@ export class PedersenCommitment extends Instruction {
     memory.set(outputOffset + 1, commitment[1]); // Field typed
     memory.set(outputOffset + 2, new Uint8(isInfinity ? 1 : 0)); // U8 typed
 
-    memory.assert(memoryOperations);
+    memory.assert({ reads: inputSize + 2, writes: 3, addressing });
     context.machineState.incrementPc();
   }
 }

package/src/avm/opcodes/comparators.ts

@@ -6,15 +6,13 @@ import { ThreeOperandInstruction } from './instruction_impl.js';
 
 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));
+    context.machineState.consumeGas(this.gasCost());
 
-    const [aOffset, bOffset, dstOffset] = Addressing.fromWire(this.indirect).resolve(
-      [this.aOffset, this.bOffset, this.dstOffset],
-      memory,
-    );
-    memory.checkTags(this.inTag, aOffset, bOffset);
+    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);
 
     const a = memory.get(aOffset);
     const b = memory.get(bOffset);
@@ -22,7 +20,7 @@ abstract class ComparatorInstruction extends ThreeOperandInstruction {
     const dest = new Uint1(this.compare(a, b) ? 1 : 0);
     memory.set(dstOffset, dest);
 
-    memory.assert(memoryOperations);
+    memory.assert({ reads: 2, writes: 1, addressing });
     context.machineState.incrementPc();
   }
 

package/src/avm/opcodes/contract.ts

@@ -22,14 +22,12 @@ export class GetContractInstance extends Instruction {
   }
 
   async execute(context: AvmContext): Promise<void> {
-    const memoryOperations = { reads: 1, writes: 6, indirect: this.indirect };
     const memory = context.machineState.memory.track(this.type);
-    context.machineState.consumeGas(this.gasCost(memoryOperations));
+    context.machineState.consumeGas(this.gasCost());
 
-    const [addressOffset, dstOffset] = Addressing.fromWire(this.indirect).resolve(
-      [this.addressOffset, this.dstOffset],
-      memory,
-    );
+    const operands = [this.addressOffset, this.dstOffset];
+    const addressing = Addressing.fromWire(this.indirect, operands.length);
+    const [addressOffset, dstOffset] = addressing.resolve(operands, memory);
     memory.checkTag(TypeTag.FIELD, addressOffset);
 
     const address = memory.get(addressOffset).toFr();
@@ -41,12 +39,13 @@ export class GetContractInstance extends Instruction {
       instance.deployer.toField(),
       instance.contractClassId,
       instance.initializationHash,
-      instance.publicKeysHash,
+      // This this okay ?
+      ...instance.publicKeys.toFields(),
     ].map(f => new Field(f));
 
     memory.setSlice(dstOffset, data);
 
-    memory.assert(memoryOperations);
+    memory.assert({ reads: 1, writes: 17, addressing });
     context.machineState.incrementPc();
   }
 }

package/src/avm/opcodes/control_flow.ts

@@ -41,21 +41,21 @@ export class JumpI extends Instruction {
   }
 
   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));
+    context.machineState.consumeGas(this.gasCost());
 
-    const [condOffset] = Addressing.fromWire(this.indirect).resolve([this.condOffset], memory);
+    const operands = [this.condOffset];
+    const addressing = Addressing.fromWire(this.indirect, operands.length);
+    const [condOffset] = addressing.resolve(operands, memory);
     const condition = memory.getAs<IntegralValue>(condOffset);
 
-    // TODO: reconsider this casting
     if (condition.toBigInt() == 0n) {
       context.machineState.incrementPc();
     } else {
       context.machineState.pc = this.loc;
     }
 
-    memory.assert(memoryOperations);
+    memory.assert({ reads: 1, addressing });
   }
 }
 
@@ -63,7 +63,7 @@ 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];
+  static readonly wireFormat: OperandType[] = [OperandType.UINT8, OperandType.UINT16];
 
   constructor(private loc: number) {
     super();

package/src/avm/opcodes/conversion.ts

@@ -13,11 +13,11 @@ export class ToRadixLE extends Instruction {
   static readonly wireFormat: OperandType[] = [
     OperandType.UINT8, // Opcode
     OperandType.UINT8, // Indirect
-    OperandType.UINT32, // src memory address
-    OperandType.UINT32, // dst memory address
-    OperandType.UINT32, // radix memory address
-    OperandType.UINT32, // number of limbs (Immediate)
-    OperandType.UINT1, // output is in "bits" mode (Immediate - Uint1 still takes up a whole byte)
+    OperandType.UINT16, // src memory address
+    OperandType.UINT16, // dst memory address
+    OperandType.UINT16, // radix memory address
+    OperandType.UINT16, // number of limbs (Immediate)
+    OperandType.UINT8, // output is in "bits" mode (Immediate - Uint1 still takes up a whole byte)
   ];
 
   constructor(
@@ -33,12 +33,10 @@ export class ToRadixLE extends Instruction {
 
   public async execute(context: AvmContext): Promise<void> {
     const memory = context.machineState.memory.track(this.type);
-    const [srcOffset, dstOffset, radixOffset] = Addressing.fromWire(this.indirect).resolve(
-      [this.srcOffset, this.dstOffset, this.radixOffset],
-      memory,
-    );
-    const memoryOperations = { reads: 2, writes: this.numLimbs, indirect: this.indirect };
-    context.machineState.consumeGas(this.gasCost({ ...memoryOperations, dynMultiplier: this.numLimbs }));
+    const operands = [this.srcOffset, this.dstOffset, this.radixOffset];
+    const addressing = Addressing.fromWire(this.indirect, operands.length);
+    const [srcOffset, dstOffset, radixOffset] = addressing.resolve(operands, memory);
+    context.machineState.consumeGas(this.gasCost(this.numLimbs));
 
     // The radix gadget only takes in a Field
     memory.checkTag(TypeTag.FIELD, srcOffset);
@@ -62,7 +60,7 @@ export class ToRadixLE extends Instruction {
     const res = limbArray.map(byte => new outputType(byte));
     memory.setSlice(dstOffset, res);
 
-    memory.assert(memoryOperations);
+    memory.assert({ reads: 2, writes: this.numLimbs, addressing });
     context.machineState.incrementPc();
   }
 }