@aztec/simulator 0.0.0-test.1 → 0.0.1-commit.017a351

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

@@ -1,7 +1,9 @@
+import { MAX_ETH_ADDRESS_VALUE } from '@aztec/constants';
+
+import { NullifierCollisionError } from '../../side_effect_errors.js';
 import type { AvmContext } from '../avm_context.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';
 import { Addressing } from './addressing_mode.js';
 import { Instruction } from './instruction.js';
@@ -19,7 +21,7 @@ export class NoteHashExists extends Instruction {
   ];
 
   constructor(
-    private indirect: number,
+    private addressingMode: number,
     private noteHashOffset: number,
     private leafIndexOffset: number,
     private existsOffset: number,
@@ -29,15 +31,19 @@ export class NoteHashExists 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.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);
+    memory.checkTag(TypeTag.FIELD, noteHashOffset);
+    memory.checkTag(TypeTag.UINT64, leafIndexOffset);
 
     // Note that this instruction accepts any type in memory, and converts to Field.
     const noteHash = memory.get(noteHashOffset).toFr();
-    const leafIndex = memory.get(leafIndexOffset).toFr();
+    const leafIndex = memory.get(leafIndexOffset).toBigInt();
 
     const exists = await context.persistableState.checkNoteHashExists(context.environment.address, noteHash, leafIndex);
     memory.set(existsOffset, exists ? new Uint1(1) : new Uint1(0));
@@ -50,16 +56,22 @@ export class EmitNoteHash extends Instruction {
   // Informs (de)serialization. See Instruction.deserialize.
   static readonly wireFormat = [OperandType.UINT8, OperandType.UINT8, OperandType.UINT16];
 
-  constructor(private indirect: number, private noteHashOffset: number) {
+  constructor(
+    private addressingMode: number,
+    private noteHashOffset: 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.noteHashOffset];
-    const addressing = Addressing.fromWire(this.indirect, operands.length);
     const [noteHashOffset] = addressing.resolve(operands, memory);
     memory.checkTag(TypeTag.FIELD, noteHashOffset);
 
@@ -76,18 +88,11 @@ export class NullifierExists extends Instruction {
   static type: string = 'NULLIFIEREXISTS';
   static readonly opcode: Opcode = Opcode.NULLIFIEREXISTS;
   // Informs (de)serialization. See Instruction.deserialize.
-  static readonly wireFormat = [
-    OperandType.UINT8,
-    OperandType.UINT8,
-    OperandType.UINT16,
-    OperandType.UINT16,
-    OperandType.UINT16,
-  ];
+  static readonly wireFormat = [OperandType.UINT8, OperandType.UINT8, OperandType.UINT16, OperandType.UINT16];
 
   constructor(
-    private indirect: number,
-    private nullifierOffset: number,
-    private addressOffset: number,
+    private addressingMode: number,
+    private siloedNullifierOffset: number,
     private existsOffset: number,
   ) {
     super();
@@ -95,16 +100,18 @@ export class NullifierExists 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);
 
-    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);
+    context.machineState.consumeGas(
+      this.baseGasCost(addressing.indirectOperandsCount(), addressing.relativeOperandsCount()),
+    );
 
-    const nullifier = memory.get(nullifierOffset).toFr();
-    const address = memory.get(addressOffset).toAztecAddress();
-    const exists = await context.persistableState.checkNullifierExists(address, nullifier);
+    const operands = [this.siloedNullifierOffset, this.existsOffset];
+    const [siloedNullifierOffset, existsOffset] = addressing.resolve(operands, memory);
+    memory.checkTag(TypeTag.FIELD, siloedNullifierOffset);
+
+    const siloedNullifier = memory.get(siloedNullifierOffset).toFr();
+    const exists = await context.persistableState.checkSiloedNullifierExists(siloedNullifier);
 
     memory.set(existsOffset, exists ? new Uint1(1) : new Uint1(0));
   }
@@ -116,7 +123,10 @@ export class EmitNullifier extends Instruction {
   // Informs (de)serialization. See Instruction.deserialize.
   static readonly wireFormat = [OperandType.UINT8, OperandType.UINT8, OperandType.UINT16];
 
-  constructor(private indirect: number, private nullifierOffset: number) {
+  constructor(
+    private addressingMode: number,
+    private nullifierOffset: number,
+  ) {
     super();
   }
 
@@ -126,10 +136,13 @@ export class EmitNullifier extends Instruction {
     }
 
     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.nullifierOffset];
-    const addressing = Addressing.fromWire(this.indirect, operands.length);
     const [nullifierOffset] = addressing.resolve(operands, memory);
     memory.checkTag(TypeTag.FIELD, nullifierOffset);
 
@@ -162,7 +175,7 @@ export class L1ToL2MessageExists extends Instruction {
   ];
 
   constructor(
-    private indirect: number,
+    private addressingMode: number,
     private msgHashOffset: number,
     private msgLeafIndexOffset: number,
     private existsOffset: number,
@@ -172,32 +185,36 @@ export class L1ToL2MessageExists 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.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);
+
+    memory.checkTag(TypeTag.FIELD, msgHashOffset);
+    memory.checkTag(TypeTag.UINT64, msgLeafIndexOffset);
 
     const msgHash = memory.get(msgHashOffset).toFr();
     const msgLeafIndex = memory.get(msgLeafIndexOffset).toFr();
-    const exists = await context.persistableState.checkL1ToL2MessageExists(
-      context.environment.address,
-      msgHash,
-      msgLeafIndex,
-    );
+    const exists = await context.persistableState.checkL1ToL2MessageExists(msgHash, msgLeafIndex);
     memory.set(existsOffset, exists ? new Uint1(1) : new Uint1(0));
   }
 }
 
-export class EmitUnencryptedLog extends Instruction {
-  // TODO(#11124): rename unencrypted -> public
-  static type: string = 'EMITUNENCRYPTEDLOG';
-  static readonly opcode: Opcode = Opcode.EMITUNENCRYPTEDLOG;
+export class EmitPublicLog extends Instruction {
+  static type: string = 'EMITPUBLICLOG';
+  static readonly opcode: Opcode = Opcode.EMITPUBLICLOG;
   // Informs (de)serialization. See Instruction.deserialize.
   static readonly wireFormat = [OperandType.UINT8, OperandType.UINT8, OperandType.UINT16, OperandType.UINT16];
 
-  constructor(private indirect: number, private logOffset: number, private logSizeOffset: number) {
+  constructor(
+    private addressingMode: number,
+    private logSizeOffset: number,
+    private logOffset: number,
+  ) {
     super();
   }
 
@@ -207,17 +224,21 @@ export class EmitUnencryptedLog extends Instruction {
     }
 
     const memory = context.machineState.memory;
+    const addressing = Addressing.fromWire(this.addressingMode);
 
-    const operands = [this.logOffset, this.logSizeOffset];
-    const addressing = Addressing.fromWire(this.indirect, operands.length);
-    const [logOffset, logSizeOffset] = addressing.resolve(operands, memory);
+    context.machineState.consumeGas(
+      this.baseGasCost(addressing.indirectOperandsCount(), addressing.relativeOperandsCount()),
+    );
+
+    const operands = [this.logSizeOffset, this.logOffset];
+    const [logSizeOffset, logOffset] = 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;
 
-    context.machineState.consumeGas(this.gasCost(logSize));
+    context.machineState.consumeGas(this.dynamicGasCost(logSize));
+    memory.checkTagsRange(TypeTag.FIELD, logOffset, logSize);
     const log = memory.getSlice(logOffset, logSize).map(f => f.toFr());
     context.persistableState.writePublicLog(contractAddress, log);
   }
@@ -229,7 +250,11 @@ export class SendL2ToL1Message extends Instruction {
   // Informs (de)serialization. See Instruction.deserialize.
   static readonly wireFormat = [OperandType.UINT8, OperandType.UINT8, OperandType.UINT16, OperandType.UINT16];
 
-  constructor(private indirect: number, private recipientOffset: number, private contentOffset: number) {
+  constructor(
+    private addressingMode: number,
+    private recipientOffset: number,
+    private contentOffset: number,
+  ) {
     super();
   }
 
@@ -239,14 +264,21 @@ export class SendL2ToL1Message extends Instruction {
     }
 
     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.recipientOffset, this.contentOffset];
-    const addressing = Addressing.fromWire(this.indirect, operands.length);
     const [recipientOffset, contentOffset] = addressing.resolve(operands, memory);
     memory.checkTags(TypeTag.FIELD, recipientOffset, contentOffset);
 
     const recipient = memory.get(recipientOffset).toFr();
+
+    if (recipient.toBigInt() > MAX_ETH_ADDRESS_VALUE) {
+      throw new InstructionExecutionError(`SENDL2TOL1MSG: Recipient address is too large`);
+    }
     const content = memory.get(contentOffset).toFr();
     context.persistableState.writeL2ToL1Message(context.environment.address, recipient, content);
   }

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);