@aztec/simulator 0.53.0 → 0.54.0

package/src/avm/avm_gas.ts

@@ -57,20 +57,33 @@ export const GasDimensions = ['l2Gas', 'daGas'] as const;
 
 /** Base gas costs for each instruction. Additional gas cost may be added on top due to memory or storage accesses, etc. */
 const BaseGasCosts: Record<Opcode, Gas> = {
-  [Opcode.ADD]: makeCost(c.AVM_ADD_BASE_L2_GAS, 0),
-  [Opcode.SUB]: makeCost(c.AVM_SUB_BASE_L2_GAS, 0),
-  [Opcode.MUL]: makeCost(c.AVM_MUL_BASE_L2_GAS, 0),
-  [Opcode.DIV]: makeCost(c.AVM_DIV_BASE_L2_GAS, 0),
-  [Opcode.FDIV]: makeCost(c.AVM_FDIV_BASE_L2_GAS, 0),
-  [Opcode.EQ]: makeCost(c.AVM_EQ_BASE_L2_GAS, 0),
-  [Opcode.LT]: makeCost(c.AVM_LT_BASE_L2_GAS, 0),
-  [Opcode.LTE]: makeCost(c.AVM_LTE_BASE_L2_GAS, 0),
-  [Opcode.AND]: makeCost(c.AVM_AND_BASE_L2_GAS, 0),
-  [Opcode.OR]: makeCost(c.AVM_OR_BASE_L2_GAS, 0),
-  [Opcode.XOR]: makeCost(c.AVM_XOR_BASE_L2_GAS, 0),
+  [Opcode.ADD_8]: makeCost(c.AVM_ADD_BASE_L2_GAS, 0),
+  [Opcode.ADD_16]: makeCost(c.AVM_ADD_BASE_L2_GAS, 0),
+  [Opcode.SUB_8]: makeCost(c.AVM_SUB_BASE_L2_GAS, 0),
+  [Opcode.SUB_16]: makeCost(c.AVM_SUB_BASE_L2_GAS, 0),
+  [Opcode.MUL_8]: makeCost(c.AVM_MUL_BASE_L2_GAS, 0),
+  [Opcode.MUL_16]: makeCost(c.AVM_MUL_BASE_L2_GAS, 0),
+  [Opcode.DIV_8]: makeCost(c.AVM_DIV_BASE_L2_GAS, 0),
+  [Opcode.DIV_16]: makeCost(c.AVM_DIV_BASE_L2_GAS, 0),
+  [Opcode.FDIV_8]: makeCost(c.AVM_FDIV_BASE_L2_GAS, 0),
+  [Opcode.FDIV_16]: makeCost(c.AVM_FDIV_BASE_L2_GAS, 0),
+  [Opcode.EQ_8]: makeCost(c.AVM_EQ_BASE_L2_GAS, 0),
+  [Opcode.EQ_16]: makeCost(c.AVM_EQ_BASE_L2_GAS, 0),
+  [Opcode.LT_8]: makeCost(c.AVM_LT_BASE_L2_GAS, 0),
+  [Opcode.LT_16]: makeCost(c.AVM_LT_BASE_L2_GAS, 0),
+  [Opcode.LTE_8]: makeCost(c.AVM_LTE_BASE_L2_GAS, 0),
+  [Opcode.LTE_16]: makeCost(c.AVM_LTE_BASE_L2_GAS, 0),
+  [Opcode.AND_8]: makeCost(c.AVM_AND_BASE_L2_GAS, 0),
+  [Opcode.AND_16]: makeCost(c.AVM_AND_BASE_L2_GAS, 0),
+  [Opcode.OR_8]: makeCost(c.AVM_OR_BASE_L2_GAS, 0),
+  [Opcode.OR_16]: makeCost(c.AVM_OR_BASE_L2_GAS, 0),
+  [Opcode.XOR_8]: makeCost(c.AVM_XOR_BASE_L2_GAS, 0),
+  [Opcode.XOR_16]: makeCost(c.AVM_XOR_BASE_L2_GAS, 0),
   [Opcode.NOT]: makeCost(c.AVM_NOT_BASE_L2_GAS, 0),
-  [Opcode.SHL]: makeCost(c.AVM_SHL_BASE_L2_GAS, 0),
-  [Opcode.SHR]: makeCost(c.AVM_SHR_BASE_L2_GAS, 0),
+  [Opcode.SHL_8]: makeCost(c.AVM_SHL_BASE_L2_GAS, 0),
+  [Opcode.SHL_16]: makeCost(c.AVM_SHL_BASE_L2_GAS, 0),
+  [Opcode.SHR_8]: makeCost(c.AVM_SHR_BASE_L2_GAS, 0),
+  [Opcode.SHR_16]: makeCost(c.AVM_SHR_BASE_L2_GAS, 0),
   [Opcode.CAST]: makeCost(c.AVM_CAST_BASE_L2_GAS, 0),
   [Opcode.ADDRESS]: makeCost(c.AVM_ADDRESS_BASE_L2_GAS, 0),
   [Opcode.STORAGEADDRESS]: makeCost(c.AVM_STORAGEADDRESS_BASE_L2_GAS, 0),
@@ -86,12 +99,18 @@ const BaseGasCosts: Record<Opcode, Gas> = {
   [Opcode.CALLDATACOPY]: makeCost(c.AVM_CALLDATACOPY_BASE_L2_GAS, 0),
   [Opcode.L2GASLEFT]: makeCost(c.AVM_L2GASLEFT_BASE_L2_GAS, 0),
   [Opcode.DAGASLEFT]: makeCost(c.AVM_DAGASLEFT_BASE_L2_GAS, 0),
-  [Opcode.JUMP]: makeCost(c.AVM_JUMP_BASE_L2_GAS, 0),
-  [Opcode.JUMPI]: makeCost(c.AVM_JUMPI_BASE_L2_GAS, 0),
+  [Opcode.JUMP_16]: makeCost(c.AVM_JUMP_BASE_L2_GAS, 0),
+  [Opcode.JUMPI_16]: makeCost(c.AVM_JUMPI_BASE_L2_GAS, 0),
   [Opcode.INTERNALCALL]: makeCost(c.AVM_INTERNALCALL_BASE_L2_GAS, 0),
   [Opcode.INTERNALRETURN]: makeCost(c.AVM_INTERNALRETURN_BASE_L2_GAS, 0),
-  [Opcode.SET]: makeCost(c.AVM_SET_BASE_L2_GAS, 0),
-  [Opcode.MOV]: makeCost(c.AVM_MOV_BASE_L2_GAS, 0),
+  [Opcode.SET_8]: makeCost(c.AVM_SET_BASE_L2_GAS, 0),
+  [Opcode.SET_16]: makeCost(c.AVM_SET_BASE_L2_GAS, 0),
+  [Opcode.SET_32]: makeCost(c.AVM_SET_BASE_L2_GAS, 0),
+  [Opcode.SET_64]: makeCost(c.AVM_SET_BASE_L2_GAS, 0),
+  [Opcode.SET_128]: makeCost(c.AVM_SET_BASE_L2_GAS, 0),
+  [Opcode.SET_FF]: makeCost(c.AVM_SET_BASE_L2_GAS, 0),
+  [Opcode.MOV_8]: makeCost(c.AVM_MOV_BASE_L2_GAS, 0),
+  [Opcode.MOV_16]: makeCost(c.AVM_MOV_BASE_L2_GAS, 0),
   [Opcode.CMOV]: makeCost(c.AVM_CMOV_BASE_L2_GAS, 0),
   [Opcode.SLOAD]: makeCost(c.AVM_SLOAD_BASE_L2_GAS, 0),
   [Opcode.SSTORE]: makeCost(c.AVM_SSTORE_BASE_L2_GAS, 0),
@@ -122,20 +141,33 @@ const BaseGasCosts: Record<Opcode, Gas> = {
 };
 
 const DynamicGasCosts: Record<Opcode, Gas> = {
-  [Opcode.ADD]: makeCost(c.AVM_ADD_DYN_L2_GAS, 0),
-  [Opcode.SUB]: makeCost(c.AVM_SUB_DYN_L2_GAS, 0),
-  [Opcode.MUL]: makeCost(c.AVM_MUL_DYN_L2_GAS, 0),
-  [Opcode.DIV]: makeCost(c.AVM_DIV_DYN_L2_GAS, 0),
-  [Opcode.FDIV]: makeCost(c.AVM_FDIV_DYN_L2_GAS, 0),
-  [Opcode.EQ]: makeCost(c.AVM_EQ_DYN_L2_GAS, 0),
-  [Opcode.LT]: makeCost(c.AVM_LT_DYN_L2_GAS, 0),
-  [Opcode.LTE]: makeCost(c.AVM_LTE_DYN_L2_GAS, 0),
-  [Opcode.AND]: makeCost(c.AVM_AND_DYN_L2_GAS, 0),
-  [Opcode.OR]: makeCost(c.AVM_OR_DYN_L2_GAS, 0),
-  [Opcode.XOR]: makeCost(c.AVM_XOR_DYN_L2_GAS, 0),
+  [Opcode.ADD_8]: makeCost(c.AVM_ADD_DYN_L2_GAS, 0),
+  [Opcode.ADD_16]: makeCost(c.AVM_ADD_DYN_L2_GAS, 0),
+  [Opcode.SUB_8]: makeCost(c.AVM_SUB_DYN_L2_GAS, 0),
+  [Opcode.SUB_16]: makeCost(c.AVM_SUB_DYN_L2_GAS, 0),
+  [Opcode.MUL_8]: makeCost(c.AVM_MUL_DYN_L2_GAS, 0),
+  [Opcode.MUL_16]: makeCost(c.AVM_MUL_DYN_L2_GAS, 0),
+  [Opcode.DIV_8]: makeCost(c.AVM_DIV_DYN_L2_GAS, 0),
+  [Opcode.DIV_16]: makeCost(c.AVM_DIV_DYN_L2_GAS, 0),
+  [Opcode.FDIV_8]: makeCost(c.AVM_FDIV_DYN_L2_GAS, 0),
+  [Opcode.FDIV_16]: makeCost(c.AVM_FDIV_DYN_L2_GAS, 0),
+  [Opcode.EQ_8]: makeCost(c.AVM_EQ_DYN_L2_GAS, 0),
+  [Opcode.EQ_16]: makeCost(c.AVM_EQ_DYN_L2_GAS, 0),
+  [Opcode.LT_8]: makeCost(c.AVM_LT_DYN_L2_GAS, 0),
+  [Opcode.LT_16]: makeCost(c.AVM_LT_DYN_L2_GAS, 0),
+  [Opcode.LTE_8]: makeCost(c.AVM_LTE_DYN_L2_GAS, 0),
+  [Opcode.LTE_16]: makeCost(c.AVM_LTE_DYN_L2_GAS, 0),
+  [Opcode.AND_8]: makeCost(c.AVM_AND_DYN_L2_GAS, 0),
+  [Opcode.AND_16]: makeCost(c.AVM_AND_DYN_L2_GAS, 0),
+  [Opcode.OR_8]: makeCost(c.AVM_OR_DYN_L2_GAS, 0),
+  [Opcode.OR_16]: makeCost(c.AVM_OR_DYN_L2_GAS, 0),
+  [Opcode.XOR_8]: makeCost(c.AVM_XOR_DYN_L2_GAS, 0),
+  [Opcode.XOR_16]: makeCost(c.AVM_XOR_DYN_L2_GAS, 0),
   [Opcode.NOT]: makeCost(c.AVM_NOT_DYN_L2_GAS, 0),
-  [Opcode.SHL]: makeCost(c.AVM_SHL_DYN_L2_GAS, 0),
-  [Opcode.SHR]: makeCost(c.AVM_SHR_DYN_L2_GAS, 0),
+  [Opcode.SHL_8]: makeCost(c.AVM_SHL_DYN_L2_GAS, 0),
+  [Opcode.SHL_16]: makeCost(c.AVM_SHL_DYN_L2_GAS, 0),
+  [Opcode.SHR_8]: makeCost(c.AVM_SHR_DYN_L2_GAS, 0),
+  [Opcode.SHR_16]: makeCost(c.AVM_SHR_DYN_L2_GAS, 0),
   [Opcode.CAST]: makeCost(c.AVM_CAST_DYN_L2_GAS, 0),
   [Opcode.ADDRESS]: makeCost(c.AVM_ADDRESS_DYN_L2_GAS, 0),
   [Opcode.STORAGEADDRESS]: makeCost(c.AVM_STORAGEADDRESS_DYN_L2_GAS, 0),
@@ -151,12 +183,18 @@ const DynamicGasCosts: Record<Opcode, Gas> = {
   [Opcode.CALLDATACOPY]: makeCost(c.AVM_CALLDATACOPY_DYN_L2_GAS, 0),
   [Opcode.L2GASLEFT]: makeCost(c.AVM_L2GASLEFT_DYN_L2_GAS, 0),
   [Opcode.DAGASLEFT]: makeCost(c.AVM_DAGASLEFT_DYN_L2_GAS, 0),
-  [Opcode.JUMP]: makeCost(c.AVM_JUMP_DYN_L2_GAS, 0),
-  [Opcode.JUMPI]: makeCost(c.AVM_JUMPI_DYN_L2_GAS, 0),
+  [Opcode.JUMP_16]: makeCost(c.AVM_JUMP_DYN_L2_GAS, 0),
+  [Opcode.JUMPI_16]: makeCost(c.AVM_JUMPI_DYN_L2_GAS, 0),
   [Opcode.INTERNALCALL]: makeCost(c.AVM_INTERNALCALL_DYN_L2_GAS, 0),
   [Opcode.INTERNALRETURN]: makeCost(c.AVM_INTERNALRETURN_DYN_L2_GAS, 0),
-  [Opcode.SET]: makeCost(c.AVM_SET_DYN_L2_GAS, 0),
-  [Opcode.MOV]: makeCost(c.AVM_MOV_DYN_L2_GAS, 0),
+  [Opcode.SET_8]: makeCost(c.AVM_SET_DYN_L2_GAS, 0),
+  [Opcode.SET_16]: makeCost(c.AVM_SET_DYN_L2_GAS, 0),
+  [Opcode.SET_32]: makeCost(c.AVM_SET_DYN_L2_GAS, 0),
+  [Opcode.SET_64]: makeCost(c.AVM_SET_DYN_L2_GAS, 0),
+  [Opcode.SET_128]: makeCost(c.AVM_SET_DYN_L2_GAS, 0),
+  [Opcode.SET_FF]: makeCost(c.AVM_SET_DYN_L2_GAS, 0),
+  [Opcode.MOV_8]: makeCost(c.AVM_MOV_DYN_L2_GAS, 0),
+  [Opcode.MOV_16]: makeCost(c.AVM_MOV_DYN_L2_GAS, 0),
   [Opcode.CMOV]: makeCost(c.AVM_CMOV_DYN_L2_GAS, 0),
   [Opcode.SLOAD]: makeCost(c.AVM_SLOAD_DYN_L2_GAS, 0),
   [Opcode.SSTORE]: makeCost(c.AVM_SSTORE_DYN_L2_GAS, 0),

package/src/avm/avm_memory_types.ts

@@ -350,7 +350,7 @@ export class TaggedMemory implements TaggedMemoryInterface {
   }
 
   // Truncates the value to fit the type.
-  public static integralFromTag(v: bigint | number, tag: TypeTag): IntegralValue {
+  public static buildFromTagTruncating(v: bigint | number, tag: TypeTag): MemoryValue {
     v = BigInt(v);
     switch (tag) {
       case TypeTag.UINT8:
@@ -363,8 +363,10 @@ export class TaggedMemory implements TaggedMemoryInterface {
         return new Uint64(v & ((1n << 64n) - 1n));
       case TypeTag.UINT128:
         return new Uint128(v & ((1n << 128n) - 1n));
+      case TypeTag.FIELD:
+        return new Field(v);
       default:
-        throw new Error(`${TypeTag[tag]} is not a valid integral type.`);
+        throw new Error(`${TypeTag[tag]} is not a valid tag.`);
     }
   }
 

package/src/avm/bytecode_utils.ts

@@ -1,13 +1,13 @@
 import { promisify } from 'util';
 import { gunzip } from 'zlib';
 
-import { Mov } from '../avm/opcodes/memory.js';
+import { Opcode } from './serialization/instruction_serialization.js';
 
 const AVM_MAGIC_SUFFIX = Buffer.from([
-  Mov.opcode, // opcode
+  Opcode.MOV_16, // opcode
   0x00, // indirect
-  ...Buffer.from('000018ca', 'hex'), // srcOffset
-  ...Buffer.from('000018ca', 'hex'), // dstOffset
+  ...Buffer.from('18ca', 'hex'), // srcOffset
+  ...Buffer.from('18ca', 'hex'), // dstOffset
 ]);
 
 export function markBytecodeAsAvm(bytecode: Buffer): Buffer {

package/src/avm/opcodes/arithmetic.ts

@@ -1,8 +1,7 @@
 import type { AvmContext } from '../avm_context.js';
-import { type Field, type MemoryValue, TypeTag } from '../avm_memory_types.js';
-import { Opcode, OperandType } from '../serialization/instruction_serialization.js';
+import { type Field, type MemoryValue } from '../avm_memory_types.js';
+import { Opcode } from '../serialization/instruction_serialization.js';
 import { Addressing } from './addressing_mode.js';
-import { Instruction } from './instruction.js';
 import { ThreeOperandInstruction } from './instruction_impl.js';
 
 export abstract class ThreeOperandArithmeticInstruction extends ThreeOperandInstruction {
@@ -32,7 +31,7 @@ export abstract class ThreeOperandArithmeticInstruction extends ThreeOperandInst
 
 export class Add extends ThreeOperandArithmeticInstruction {
   static readonly type: string = 'ADD';
-  static readonly opcode = Opcode.ADD;
+  static readonly opcode = Opcode.ADD_8; // FIXME: needed for gas.
 
   protected compute(a: MemoryValue, b: MemoryValue): MemoryValue {
     return a.add(b);
@@ -41,7 +40,7 @@ export class Add extends ThreeOperandArithmeticInstruction {
 
 export class Sub extends ThreeOperandArithmeticInstruction {
   static readonly type: string = 'SUB';
-  static readonly opcode = Opcode.SUB;
+  static readonly opcode = Opcode.SUB_8; // FIXME: needed for gas.
 
   protected compute(a: MemoryValue, b: MemoryValue): MemoryValue {
     return a.sub(b);
@@ -50,7 +49,7 @@ export class Sub extends ThreeOperandArithmeticInstruction {
 
 export class Mul extends ThreeOperandArithmeticInstruction {
   static type: string = 'MUL';
-  static readonly opcode = Opcode.MUL;
+  static readonly opcode = Opcode.MUL_8; // FIXME: needed for gas.
 
   protected compute(a: MemoryValue, b: MemoryValue): MemoryValue {
     return a.mul(b);
@@ -59,48 +58,20 @@ export class Mul extends ThreeOperandArithmeticInstruction {
 
 export class Div extends ThreeOperandArithmeticInstruction {
   static type: string = 'DIV';
-  static readonly opcode = Opcode.DIV;
+  static readonly opcode = Opcode.DIV_8; // FIXME: needed for gas.
 
   protected compute(a: MemoryValue, b: MemoryValue): MemoryValue {
     return a.div(b);
   }
 }
 
-export class FieldDiv extends Instruction {
+// TODO: This class now temporarily has a tag, until all tags are removed.
+export class FieldDiv extends ThreeOperandArithmeticInstruction {
   static type: string = 'FDIV';
-  static readonly opcode = Opcode.FDIV;
-
-  // Informs (de)serialization. See Instruction.deserialize.
-  static readonly wireFormat: OperandType[] = [
-    OperandType.UINT8,
-    OperandType.UINT8,
-    OperandType.UINT32,
-    OperandType.UINT32,
-    OperandType.UINT32,
-  ];
-
-  constructor(private indirect: number, private aOffset: number, private bOffset: number, private dstOffset: number) {
-    super();
-  }
-
-  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 [aOffset, bOffset, dstOffset] = Addressing.fromWire(this.indirect).resolve(
-      [this.aOffset, this.bOffset, this.dstOffset],
-      memory,
-    );
-    memory.checkTags(TypeTag.FIELD, aOffset, bOffset);
-
-    const a = memory.getAs<Field>(aOffset);
-    const b = memory.getAs<Field>(bOffset);
+  static readonly opcode = Opcode.FDIV_8; // FIXME: needed for gas.
 
-    const dest = a.fdiv(b);
-    memory.set(dstOffset, dest);
-
-    memory.assert(memoryOperations);
-    context.machineState.incrementPc();
+  protected compute(a: Field, b: Field): Field {
+    // return (a as Field).fdiv(b as Field);
+    return a.fdiv(b);
   }
 }

package/src/avm/opcodes/bitwise.ts

@@ -34,7 +34,7 @@ abstract class ThreeOperandBitwiseInstruction extends ThreeOperandInstruction {
 
 export class And extends ThreeOperandBitwiseInstruction {
   static readonly type: string = 'AND';
-  static readonly opcode = Opcode.AND;
+  static readonly opcode = Opcode.AND_8; // FIXME: needed for gas.
 
   protected override compute(a: IntegralValue, b: IntegralValue): IntegralValue {
     return a.and(b);
@@ -43,7 +43,7 @@ export class And extends ThreeOperandBitwiseInstruction {
 
 export class Or extends ThreeOperandBitwiseInstruction {
   static readonly type: string = 'OR';
-  static readonly opcode = Opcode.OR;
+  static readonly opcode = Opcode.OR_8; // FIXME: needed for gas.
 
   protected override compute(a: IntegralValue, b: IntegralValue): IntegralValue {
     return a.or(b);
@@ -52,7 +52,7 @@ export class Or extends ThreeOperandBitwiseInstruction {
 
 export class Xor extends ThreeOperandBitwiseInstruction {
   static readonly type: string = 'XOR';
-  static readonly opcode = Opcode.XOR;
+  static readonly opcode = Opcode.XOR_8; // FIXME: needed for gas.
 
   protected override compute(a: IntegralValue, b: IntegralValue): IntegralValue {
     return a.xor(b);
@@ -61,7 +61,7 @@ export class Xor extends ThreeOperandBitwiseInstruction {
 
 export class Shl extends ThreeOperandBitwiseInstruction {
   static readonly type: string = 'SHL';
-  static readonly opcode = Opcode.SHL;
+  static readonly opcode = Opcode.SHL_8; // FIXME: needed for gas.
 
   protected override compute(a: IntegralValue, b: IntegralValue): IntegralValue {
     return a.shl(b);
@@ -74,7 +74,7 @@ export class Shl extends ThreeOperandBitwiseInstruction {
 
 export class Shr extends ThreeOperandBitwiseInstruction {
   static readonly type: string = 'SHR';
-  static readonly opcode = Opcode.SHR;
+  static readonly opcode = Opcode.SHR_8; // FIXME: needed for gas.
 
   protected override compute(a: IntegralValue, b: IntegralValue): IntegralValue {
     return a.shr(b);

package/src/avm/opcodes/comparators.ts

@@ -31,7 +31,7 @@ abstract class ComparatorInstruction extends ThreeOperandInstruction {
 
 export class Eq extends ComparatorInstruction {
   static readonly type: string = 'EQ';
-  static readonly opcode = Opcode.EQ;
+  static readonly opcode = Opcode.EQ_8; // FIXME: needed for gas.
 
   protected compare(a: MemoryValue, b: MemoryValue): boolean {
     return a.equals(b);
@@ -40,7 +40,7 @@ export class Eq extends ComparatorInstruction {
 
 export class Lt extends ComparatorInstruction {
   static readonly type: string = 'LT';
-  static readonly opcode = Opcode.LT;
+  static readonly opcode = Opcode.LT_8; // FIXME: needed for gas.
 
   protected compare(a: MemoryValue, b: MemoryValue): boolean {
     return a.lt(b);
@@ -49,7 +49,7 @@ export class Lt extends ComparatorInstruction {
 
 export class Lte extends ComparatorInstruction {
   static readonly type: string = 'LTE';
-  static readonly opcode = Opcode.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/avm/opcodes/control_flow.ts

@@ -7,9 +7,9 @@ import { Instruction } from './instruction.js';
 
 export class Jump extends Instruction {
   static type: string = 'JUMP';
-  static readonly opcode: Opcode = Opcode.JUMP;
+  static readonly opcode: Opcode = Opcode.JUMP_16;
   // Informs (de)serialization. See Instruction.deserialize.
-  static readonly wireFormat: OperandType[] = [OperandType.UINT8, OperandType.UINT32];
+  static readonly wireFormat: OperandType[] = [OperandType.UINT8, OperandType.UINT16];
 
   constructor(private jumpOffset: number) {
     super();
@@ -26,14 +26,14 @@ export class Jump extends Instruction {
 
 export class JumpI extends Instruction {
   static type: string = 'JUMPI';
-  static readonly opcode: Opcode = Opcode.JUMPI;
+  static readonly opcode: Opcode = Opcode.JUMPI_16;
 
   // Instruction wire format with opcode.
   static readonly wireFormat: OperandType[] = [
     OperandType.UINT8,
     OperandType.UINT8,
-    OperandType.UINT32,
-    OperandType.UINT32,
+    OperandType.UINT16,
+    OperandType.UINT16,
   ];
 
   constructor(private indirect: number, private loc: number, private condOffset: number) {

package/src/avm/opcodes/instruction.ts

@@ -4,11 +4,11 @@ import type { AvmContext } from '../avm_context.js';
 import { getBaseGasCost, getDynamicGasCost, mulGas, sumGas } from '../avm_gas.js';
 import { type MemoryOperations } from '../avm_memory_types.js';
 import { type BufferCursor } from '../serialization/buffer_cursor.js';
-import { Opcode, type OperandType, deserialize, serialize } from '../serialization/instruction_serialization.js';
+import { type Serializable } from '../serialization/bytecode_serialization.js';
+import { Opcode, type OperandType, deserialize, serializeAs } from '../serialization/instruction_serialization.js';
 
 type InstructionConstructor = {
   new (...args: any[]): Instruction;
-  wireFormat?: OperandType[];
 };
 
 /**
@@ -37,29 +37,51 @@ export abstract class Instruction {
     return instructionStr;
   }
 
+  // Default deserialization which uses Class.opcode and Class.wireFormat.
+  public static deserialize(
+    this: InstructionConstructor & { wireFormat: OperandType[]; as: any },
+    buf: BufferCursor | Buffer,
+  ): Instruction {
+    return this.as(this.wireFormat).deserialize(buf);
+  }
+
+  // Default serialization which uses Class.opcode and Class.wireFormat.
+  public serialize(): Buffer {
+    const klass = this.constructor as any;
+    assert(klass.opcode !== undefined && klass.opcode !== null);
+    assert(klass.wireFormat !== undefined && klass.wireFormat !== null);
+    return this.as(klass.opcode, klass.wireFormat).serialize();
+  }
+
   /**
-   * Serialize the instruction to a Buffer according to its wire format specified in its subclass.
-   * If you want to use this, your subclass should specify a {@code static wireFormat: OperandType[]}.
-   * @param this - The instruction to serialize.
-   * @returns The serialized instruction.
+   * Returns a new instruction instance that can be serialized with the given opcode and wire format.
+   * @param opcode The opcode of the instruction.
+   * @param wireFormat The wire format of the instruction.
+   * @returns The new instruction instance.
    */
-  public serialize(this: any): Buffer {
-    assert(!!this.constructor.wireFormat, 'wireFormat must be defined on the class');
-    return serialize(this.constructor.wireFormat, this);
+  public as(opcode: Opcode, wireFormat: OperandType[]): Instruction & Serializable {
+    return Object.defineProperty(this, 'serialize', {
+      value: (): Buffer => {
+        return serializeAs(wireFormat, opcode, this);
+      },
+      enumerable: false,
+    });
   }
 
   /**
-   * Deserializes a subclass of Instruction from a Buffer.
-   * If you want to use this, your subclass should specify a {@code static wireFormat: OperandType[]}.
-   * @param this Class object to deserialize to.
-   * @param buf Buffer to read from.
-   * @returns Constructed instance of Class.
+   * Returns a new instruction class that can be deserialized with the given opcode and wire format.
+   * @param opcode The opcode of the instruction.
+   * @param wireFormat The wire format of the instruction.
+   * @returns The new instruction class.
    */
-  public static deserialize(this: InstructionConstructor, buf: BufferCursor | Buffer): Instruction {
-    assert(!!this.wireFormat, 'wireFormat must be defined on the instruction class');
-    const res = deserialize(buf, this.wireFormat);
-    const args = res.slice(1); // Remove opcode.
-    return new this(...args);
+  public static as(this: InstructionConstructor, wireFormat: OperandType[]) {
+    return Object.assign(this, {
+      deserialize: (buf: BufferCursor | Buffer): Instruction => {
+        const res = deserialize(buf, wireFormat);
+        const args = res.slice(1); // Remove opcode.
+        return new this(...args);
+      },
+    });
   }
 
   /**

package/src/avm/opcodes/instruction_impl.ts

@@ -14,13 +14,21 @@ export const TwoOperandWireFormat = [
 ];
 
 /** Wire format that informs deserialization for instructions with three operands. */
-export const ThreeOperandWireFormat = [
+export const ThreeOperandWireFormat8 = [
+  OperandType.UINT8,
+  OperandType.UINT8,
+  OperandType.UINT8,
   OperandType.UINT8,
   OperandType.UINT8,
   OperandType.UINT8,
-  OperandType.UINT32,
-  OperandType.UINT32,
-  OperandType.UINT32,
+];
+export const ThreeOperandWireFormat16 = [
+  OperandType.UINT8,
+  OperandType.UINT8,
+  OperandType.UINT8,
+  OperandType.UINT16,
+  OperandType.UINT16,
+  OperandType.UINT16,
 ];
 
 /**
@@ -46,8 +54,8 @@ export abstract class TwoOperandInstruction extends Instruction {
  * indirect, inTag, and three UINT32s.
  */
 export abstract class ThreeOperandInstruction extends Instruction {
-  // Informs (de)serialization. See Instruction.deserialize.
-  static readonly wireFormat: OperandType[] = ThreeOperandWireFormat;
+  static readonly wireFormat8: OperandType[] = ThreeOperandWireFormat8;
+  static readonly wireFormat16: OperandType[] = ThreeOperandWireFormat16;
 
   constructor(
     protected indirect: number,

package/src/avm/opcodes/memory.ts

@@ -1,39 +1,57 @@
 import type { AvmContext } from '../avm_context.js';
-import { Field, TaggedMemory, TypeTag } from '../avm_memory_types.js';
-import { InstructionExecutionError } from '../errors.js';
-import { BufferCursor } from '../serialization/buffer_cursor.js';
-import { Opcode, OperandType, deserialize, serialize } from '../serialization/instruction_serialization.js';
+import { Field, TaggedMemory } 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 { TwoOperandInstruction } from './instruction_impl.js';
 
-const TAG_TO_OPERAND_TYPE = new Map<TypeTag, OperandType>([
-  [TypeTag.UINT8, OperandType.UINT8],
-  [TypeTag.UINT16, OperandType.UINT16],
-  [TypeTag.UINT32, OperandType.UINT32],
-  [TypeTag.UINT64, OperandType.UINT64],
-  [TypeTag.UINT128, OperandType.UINT128],
-]);
-
-function getOperandTypeFromInTag(inTag: number | bigint): OperandType {
-  inTag = inTag as number;
-  const tagOperandType = TAG_TO_OPERAND_TYPE.get(inTag);
-  if (tagOperandType === undefined) {
-    throw new Error(`Invalid tag ${inTag} for SET.`);
-  }
-  return tagOperandType;
-}
-
 export class Set extends Instruction {
   static readonly type: string = 'SET';
-  static readonly opcode: Opcode = Opcode.SET;
-
-  private static readonly wireFormatBeforeConst: OperandType[] = [
-    OperandType.UINT8,
-    OperandType.UINT8,
-    OperandType.UINT8,
+  // Required for gas.
+  static readonly opcode: Opcode = Opcode.SET_8;
+
+  public static readonly wireFormat8: OperandType[] = [
+    OperandType.UINT8, // opcode
+    OperandType.UINT8, // indirect
+    OperandType.UINT8, // tag
+    OperandType.UINT8, // const (value)
+    OperandType.UINT8, // dstOffset
+  ];
+  public static readonly wireFormat16: OperandType[] = [
+    OperandType.UINT8, // opcode
+    OperandType.UINT8, // indirect
+    OperandType.UINT8, // tag
+    OperandType.UINT16, // const (value)
+    OperandType.UINT16, // dstOffset
+  ];
+  public static readonly wireFormat32: OperandType[] = [
+    OperandType.UINT8, // opcode
+    OperandType.UINT8, // indirect
+    OperandType.UINT8, // tag
+    OperandType.UINT32, // const (value)
+    OperandType.UINT16, // dstOffset
+  ];
+  public static readonly wireFormat64: OperandType[] = [
+    OperandType.UINT8, // opcode
+    OperandType.UINT8, // indirect
+    OperandType.UINT8, // tag
+    OperandType.UINT64, // const (value)
+    OperandType.UINT16, // dstOffset
+  ];
+  public static readonly wireFormat128: OperandType[] = [
+    OperandType.UINT8, // opcode
+    OperandType.UINT8, // indirect
+    OperandType.UINT8, // tag
+    OperandType.UINT128, // const (value)
+    OperandType.UINT16, // dstOffset
+  ];
+  public static readonly wireFormatFF: OperandType[] = [
+    OperandType.UINT8, // opcode
+    OperandType.UINT8, // indirect
+    OperandType.UINT8, // tag
+    OperandType.FF, // const (value)
+    OperandType.UINT16, // dstOffset
   ];
-  private static readonly wireFormatAfterConst: OperandType[] = [OperandType.UINT32];
 
   constructor(
     private indirect: number,
@@ -44,42 +62,13 @@ export class Set extends Instruction {
     super();
   }
 
-  /** We need to use a custom serialize function because of the variable length of the value. */
-  public override serialize(): Buffer {
-    const format: OperandType[] = [
-      ...Set.wireFormatBeforeConst,
-      getOperandTypeFromInTag(this.inTag),
-      ...Set.wireFormatAfterConst,
-    ];
-    return serialize(format, this);
-  }
-
-  /** We need to use a custom deserialize function because of the variable length of the value. */
-  public static override deserialize(this: typeof Set, buf: BufferCursor | Buffer): Set {
-    if (buf instanceof Buffer) {
-      buf = new BufferCursor(buf);
-    }
-    const beforeConst = deserialize(buf, Set.wireFormatBeforeConst);
-    const tag = beforeConst[beforeConst.length - 1];
-    const val = deserialize(buf, [getOperandTypeFromInTag(tag)]);
-    const afterConst = deserialize(buf, Set.wireFormatAfterConst);
-    const res = [...beforeConst, ...val, ...afterConst];
-    const args = res.slice(1) as ConstructorParameters<typeof Set>; // Remove opcode.
-    return new this(...args);
-  }
-
   public async execute(context: AvmContext): Promise<void> {
     const memoryOperations = { writes: 1, indirect: this.indirect };
     const memory = context.machineState.memory.track(this.type);
     context.machineState.consumeGas(this.gasCost(memoryOperations));
 
-    // Per the YP, the tag cannot be a field.
-    if ([TypeTag.FIELD, TypeTag.UNINITIALIZED, TypeTag.INVALID].includes(this.inTag)) {
-      throw new InstructionExecutionError(`Invalid tag ${TypeTag[this.inTag]} for SET.`);
-    }
     const [dstOffset] = Addressing.fromWire(this.indirect).resolve([this.dstOffset], memory);
-
-    const res = TaggedMemory.integralFromTag(this.value, this.inTag);
+    const res = TaggedMemory.buildFromTagTruncating(this.value, this.inTag);
     memory.set(dstOffset, res);
 
     memory.assert(memoryOperations);
@@ -148,9 +137,7 @@ export class Cast extends TwoOperandInstruction {
     const [srcOffset, dstOffset] = Addressing.fromWire(this.indirect).resolve([this.aOffset, this.dstOffset], memory);
 
     const a = memory.get(srcOffset);
-
-    const casted =
-      this.inTag == TypeTag.FIELD ? new Field(a.toBigInt()) : TaggedMemory.integralFromTag(a.toBigInt(), this.inTag);
+    const casted = TaggedMemory.buildFromTagTruncating(a.toBigInt(), this.inTag);
 
     memory.set(dstOffset, casted);
 
@@ -161,13 +148,20 @@ export class Cast extends TwoOperandInstruction {
 
 export class Mov extends Instruction {
   static readonly type: string = 'MOV';
-  static readonly opcode: Opcode = Opcode.MOV;
-  // Informs (de)serialization. See Instruction.deserialize.
-  static readonly wireFormat: OperandType[] = [
+  // FIXME: This is needed for gas.
+  static readonly opcode: Opcode = Opcode.MOV_8;
+
+  static readonly wireFormat8: OperandType[] = [
     OperandType.UINT8,
     OperandType.UINT8,
-    OperandType.UINT32,
-    OperandType.UINT32,
+    OperandType.UINT8,
+    OperandType.UINT8,
+  ];
+  static readonly wireFormat16: OperandType[] = [
+    OperandType.UINT8,
+    OperandType.UINT8,
+    OperandType.UINT16,
+    OperandType.UINT16,
   ];
 
   constructor(private indirect: number, private srcOffset: number, private dstOffset: number) {