@aztec/simulator 0.55.0 → 0.56.0

package/src/avm/opcodes/environment_getters.ts

@@ -1,112 +1,85 @@
 import type { AvmContext } from '../avm_context.js';
-import type { AvmExecutionEnvironment } from '../avm_execution_environment.js';
-import { Field, type MemoryValue, Uint32, Uint64 } from '../avm_memory_types.js';
-import { Opcode } from '../serialization/instruction_serialization.js';
-import { GetterInstruction } from './instruction_impl.js';
-
-abstract class EnvironmentGetterInstruction extends GetterInstruction {
-  protected getValue(context: AvmContext): MemoryValue {
-    return this.getEnvironmentValue(context.environment);
-  }
-
-  protected abstract getEnvironmentValue(env: AvmExecutionEnvironment): MemoryValue;
-}
-
-export class Address extends EnvironmentGetterInstruction {
-  static type: string = 'ADDRESS';
-  static readonly opcode: Opcode = Opcode.ADDRESS;
-
-  protected getEnvironmentValue(env: AvmExecutionEnvironment) {
-    return new Field(env.address.toField());
-  }
-}
-
-export class StorageAddress extends EnvironmentGetterInstruction {
-  static type: string = 'STORAGEADDRESS';
-  static readonly opcode: Opcode = Opcode.STORAGEADDRESS;
-
-  protected getEnvironmentValue(env: AvmExecutionEnvironment) {
-    return new Field(env.storageAddress.toField());
-  }
-}
-
-export class Sender extends EnvironmentGetterInstruction {
-  static type: string = 'SENDER';
-  static readonly opcode: Opcode = Opcode.SENDER;
-
-  protected getEnvironmentValue(env: AvmExecutionEnvironment) {
-    return new Field(env.sender.toField());
-  }
-}
-
-export class FunctionSelector extends EnvironmentGetterInstruction {
-  static type: string = 'FUNCTIONSELECTOR';
-  static readonly opcode: Opcode = Opcode.FUNCTIONSELECTOR;
-
-  protected getEnvironmentValue(env: AvmExecutionEnvironment) {
-    return new Uint32(env.functionSelector.value);
-  }
-}
-
-export class TransactionFee extends EnvironmentGetterInstruction {
-  static type: string = 'TRANSACTIONFEE';
-  static readonly opcode: Opcode = Opcode.TRANSACTIONFEE;
-
-  protected getEnvironmentValue(env: AvmExecutionEnvironment) {
-    return new Field(env.transactionFee);
-  }
-}
-
-export class ChainId extends EnvironmentGetterInstruction {
-  static type: string = 'CHAINID';
-  static readonly opcode: Opcode = Opcode.CHAINID;
-
-  protected getEnvironmentValue(env: AvmExecutionEnvironment) {
-    return new Field(env.globals.chainId);
-  }
+import { Field, Uint32, Uint64 } from '../avm_memory_types.js';
+import { Opcode, OperandType } from '../serialization/instruction_serialization.js';
+import { Addressing } from './addressing_mode.js';
+import { Instruction } from './instruction.js';
+
+export enum EnvironmentVariable {
+  ADDRESS,
+  STORAGEADDRESS,
+  SENDER,
+  FUNCTIONSELECTOR,
+  TRANSACTIONFEE,
+  CHAINID,
+  VERSION,
+  BLOCKNUMBER,
+  TIMESTAMP,
+  FEEPERL2GAS,
+  FEEPERDAGAS,
+  ISSTATICCALL,
+  L2GASLEFT,
+  DAGASLEFT,
 }
 
-export class Version extends EnvironmentGetterInstruction {
-  static type: string = 'VERSION';
-  static readonly opcode: Opcode = Opcode.VERSION;
-
-  protected getEnvironmentValue(env: AvmExecutionEnvironment) {
-    return new Field(env.globals.version);
+function getValue(e: EnvironmentVariable, ctx: AvmContext) {
+  switch (e) {
+    case EnvironmentVariable.ADDRESS:
+      return new Field(ctx.environment.address.toField());
+    case EnvironmentVariable.STORAGEADDRESS:
+      return new Field(ctx.environment.storageAddress.toField());
+    case EnvironmentVariable.SENDER:
+      return new Field(ctx.environment.sender.toField());
+    case EnvironmentVariable.FUNCTIONSELECTOR:
+      return new Uint32(ctx.environment.functionSelector.value);
+    case EnvironmentVariable.TRANSACTIONFEE:
+      return new Field(ctx.environment.transactionFee);
+    case EnvironmentVariable.CHAINID:
+      return new Field(ctx.environment.globals.chainId);
+    case EnvironmentVariable.VERSION:
+      return new Field(ctx.environment.globals.version);
+    case EnvironmentVariable.BLOCKNUMBER:
+      return new Field(ctx.environment.globals.blockNumber);
+    case EnvironmentVariable.TIMESTAMP:
+      return new Uint64(ctx.environment.globals.timestamp.toBigInt());
+    case EnvironmentVariable.FEEPERL2GAS:
+      return new Field(ctx.environment.globals.gasFees.feePerL2Gas);
+    case EnvironmentVariable.FEEPERDAGAS:
+      return new Field(ctx.environment.globals.gasFees.feePerDaGas);
+    case EnvironmentVariable.ISSTATICCALL:
+      return new Field(ctx.environment.isStaticCall ? 1 : 0);
+    case EnvironmentVariable.L2GASLEFT:
+      return new Field(ctx.machineState.l2GasLeft);
+    case EnvironmentVariable.DAGASLEFT:
+      return new Field(ctx.machineState.daGasLeft);
+    default:
+      throw new Error(`Unknown environment variable ${e}`);
   }
 }
 
-export class BlockNumber extends EnvironmentGetterInstruction {
-  static type: string = 'BLOCKNUMBER';
-  static readonly opcode: Opcode = Opcode.BLOCKNUMBER;
-
-  protected getEnvironmentValue(env: AvmExecutionEnvironment) {
-    return new Field(env.globals.blockNumber);
+export class GetEnvVar extends Instruction {
+  public static readonly type: string = 'GETENVVAR';
+  public static readonly opcode: Opcode = Opcode.GETENVVAR_16;
+  static readonly wireFormat16: OperandType[] = [
+    OperandType.UINT8, // opcode
+    OperandType.UINT8, // indirect
+    OperandType.UINT8, // variable enum (immediate)
+    OperandType.UINT16, // dstOffset
+  ];
+
+  constructor(private indirect: number, private varEnum: EnvironmentVariable, private dstOffset: number) {
+    super();
   }
-}
 
-export class Timestamp extends EnvironmentGetterInstruction {
-  static type: string = 'TIMESTAMP';
-  static readonly opcode: Opcode = Opcode.TIMESTAMP;
+  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));
 
-  protected getEnvironmentValue(env: AvmExecutionEnvironment) {
-    return new Uint64(env.globals.timestamp.toBigInt());
-  }
-}
-
-export class FeePerL2Gas extends EnvironmentGetterInstruction {
-  static type: string = 'FEEPERL2GAS';
-  static readonly opcode: Opcode = Opcode.FEEPERL2GAS;
-
-  protected getEnvironmentValue(env: AvmExecutionEnvironment) {
-    return new Field(env.globals.gasFees.feePerL2Gas);
-  }
-}
+    const [dstOffset] = Addressing.fromWire(this.indirect).resolve([this.dstOffset], memory);
 
-export class FeePerDAGas extends EnvironmentGetterInstruction {
-  static type: string = 'FEEPERDAGAS';
-  static readonly opcode: Opcode = Opcode.FEEPERDAGAS;
+    memory.set(dstOffset, getValue(this.varEnum, context));
 
-  protected getEnvironmentValue(env: AvmExecutionEnvironment) {
-    return new Field(env.globals.gasFees.feePerDaGas);
+    memory.assert(memoryOperations);
+    context.machineState.incrementPc();
   }
 }

package/src/avm/opcodes/hashing.ts

@@ -1,9 +1,16 @@
-import { keccak256, keccakf1600, pedersenHash, poseidon2Permutation, sha256 } from '@aztec/foundation/crypto';
+import {
+  keccak256,
+  keccakf1600,
+  pedersenHash,
+  poseidon2Permutation,
+  sha256Compression,
+} from '@aztec/foundation/crypto';
 
 import { strict as assert } from 'assert';
 
 import { type AvmContext } from '../avm_context.js';
-import { Field, TypeTag, Uint8, Uint64 } from '../avm_memory_types.js';
+import { Field, TypeTag, Uint8, Uint32, Uint64 } from '../avm_memory_types.js';
+import { InstructionExecutionError } from '../errors.js';
 import { Opcode, OperandType } from '../serialization/instruction_serialization.js';
 import { Addressing } from './addressing_mode.js';
 import { Instruction } from './instruction.js';
@@ -80,7 +87,7 @@ export class Keccak extends Instruction {
     memory.checkTag(TypeTag.UINT32, messageSizeOffset);
     const messageSize = memory.get(messageSizeOffset).toNumber();
     const memoryOperations = { reads: messageSize + 1, writes: 32, indirect: this.indirect };
-    context.machineState.consumeGas(this.gasCost(memoryOperations));
+    context.machineState.consumeGas(this.gasCost({ ...memoryOperations, dynMultiplier: messageSize }));
 
     memory.checkTagsRange(TypeTag.UINT8, messageOffset, messageSize);
 
@@ -145,9 +152,9 @@ export class KeccakF1600 extends Instruction {
   }
 }
 
-export class Sha256 extends Instruction {
-  static type: string = 'SHA256';
-  static readonly opcode: Opcode = Opcode.SHA256;
+export class Sha256Compression extends Instruction {
+  static type: string = 'SHA256COMPRESSION';
+  static readonly opcode: Opcode = Opcode.SHA256COMPRESSION;
 
   // Informs (de)serialization. See Instruction.deserialize.
   static readonly wireFormat: OperandType[] = [
@@ -156,36 +163,54 @@ export class Sha256 extends Instruction {
     OperandType.UINT32,
     OperandType.UINT32,
     OperandType.UINT32,
+    OperandType.UINT32,
+    OperandType.UINT32,
   ];
 
   constructor(
     private indirect: number,
-    private dstOffset: number,
-    private messageOffset: number,
-    private messageSizeOffset: number,
+    private outputOffset: number,
+    private stateOffset: number,
+    private stateSizeOffset: number,
+    private inputsOffset: number,
+    private inputsSizeOffset: number,
   ) {
     super();
   }
 
-  // pub fn sha256_slice(input: [u8]) -> [u8; 32]
   public async execute(context: AvmContext): Promise<void> {
+    const STATE_SIZE = 8;
+    const INPUTS_SIZE = 16;
+
     const memory = context.machineState.memory.track(this.type);
-    const [dstOffset, messageOffset, messageSizeOffset] = Addressing.fromWire(this.indirect).resolve(
-      [this.dstOffset, this.messageOffset, this.messageSizeOffset],
+    const [outputOffset, stateOffset, stateSizeOffset, inputsOffset, inputsSizeOffset] = Addressing.fromWire(
+      this.indirect,
+    ).resolve(
+      [this.outputOffset, this.stateOffset, this.stateSizeOffset, this.inputsOffset, this.inputsSizeOffset],
       memory,
     );
-    memory.checkTag(TypeTag.UINT32, messageSizeOffset);
-    const messageSize = memory.get(messageSizeOffset).toNumber();
-    const memoryOperations = { reads: messageSize + 1, writes: 32, indirect: this.indirect };
+    const stateSize = memory.get(stateSizeOffset).toNumber();
+    const inputsSize = memory.get(inputsSizeOffset).toNumber();
+    if (stateSize !== STATE_SIZE) {
+      throw new InstructionExecutionError('`state` argument to SHA256 compression must be of length 8');
+    }
+    if (inputsSize !== INPUTS_SIZE) {
+      throw new InstructionExecutionError('`inputs` argument to SHA256 compression must be of length 16');
+    }
+    // +2 to account for both size offsets (stateSizeOffset and inputsSizeOffset)
+    // Note: size of output is same as size of state
+    const memoryOperations = { reads: stateSize + inputsSize + 2, writes: stateSize, indirect: this.indirect };
     context.machineState.consumeGas(this.gasCost(memoryOperations));
-    memory.checkTagsRange(TypeTag.UINT8, messageOffset, messageSize);
+    memory.checkTagsRange(TypeTag.UINT32, inputsOffset, inputsSize);
+    memory.checkTagsRange(TypeTag.UINT32, stateOffset, stateSize);
 
-    const messageData = Buffer.concat(memory.getSlice(messageOffset, messageSize).map(word => word.toBuffer()));
-    const hashBuffer = sha256(messageData);
+    const state = Uint32Array.from(memory.getSlice(stateOffset, stateSize).map(word => word.toNumber()));
+    const inputs = Uint32Array.from(memory.getSlice(inputsOffset, inputsSize).map(word => word.toNumber()));
+    const output = sha256Compression(state, inputs);
 
-    // We need to convert the hashBuffer because map doesn't work as expected on an Uint8Array (Buffer).
-    const res = [...hashBuffer].map(byte => new Uint8(byte));
-    memory.setSlice(dstOffset, res);
+    // Conversion required from Uint32Array to Uint32[] (can't map directly, need `...`)
+    const res = [...output].map(word => new Uint32(word));
+    memory.setSlice(outputOffset, res);
 
     memory.assert(memoryOperations);
     context.machineState.incrementPc();
@@ -231,7 +256,7 @@ export class Pedersen extends Instruction {
     const hashData = memory.getSlice(messageOffset, messageSize);
 
     const memoryOperations = { reads: messageSize + 2, writes: 1, indirect: this.indirect };
-    context.machineState.consumeGas(this.gasCost(memoryOperations));
+    context.machineState.consumeGas(this.gasCost({ ...memoryOperations, dynMultiplier: messageSize }));
 
     memory.checkTagsRange(TypeTag.FIELD, messageOffset, messageSize);
 

package/src/avm/opcodes/index.ts

@@ -11,3 +11,6 @@ export * from './storage.js';
 export * from './external_calls.js';
 export * from './environment_getters.js';
 export * from './accrued_substate.js';
+export * from './hashing.js';
+export * from './ec_add.js';
+export * from './commitment.js';

package/src/avm/opcodes/instruction_impl.ts

@@ -1,25 +1,6 @@
-import { type AvmContext } from '../avm_context.js';
-import { type MemoryValue } from '../avm_memory_types.js';
 import { OperandType } from '../serialization/instruction_serialization.js';
-import { Addressing } from './addressing_mode.js';
 import { Instruction } from './instruction.js';
 
-/** Wire format that informs deserialization for instructions with two operands. */
-export const TwoOperandWireFormat8 = [
-  OperandType.UINT8,
-  OperandType.UINT8,
-  OperandType.UINT8,
-  OperandType.UINT8,
-  OperandType.UINT8,
-];
-export const TwoOperandWireFormat16 = [
-  OperandType.UINT8,
-  OperandType.UINT8,
-  OperandType.UINT8,
-  OperandType.UINT16,
-  OperandType.UINT16,
-];
-
 /** Wire format that informs deserialization for instructions with three operands. */
 export const ThreeOperandWireFormat8 = [
   OperandType.UINT8,
@@ -38,25 +19,6 @@ export const ThreeOperandWireFormat16 = [
   OperandType.UINT16,
 ];
 
-/**
- * Covers (de)serialization for an instruction with:
- * indirect, inTag, and two operands.
- */
-export abstract class TwoOperandInstruction extends Instruction {
-  // Informs (de)serialization. See Instruction.deserialize.
-  static readonly wireFormat8: OperandType[] = TwoOperandWireFormat8;
-  static readonly wireFormat16: OperandType[] = TwoOperandWireFormat16;
-
-  constructor(
-    protected indirect: number,
-    protected inTag: number,
-    protected aOffset: number,
-    protected dstOffset: number,
-  ) {
-    super();
-  }
-}
-
 /**
  * Covers (de)serialization for an instruction with:
  * indirect, inTag, and three operands.
@@ -75,27 +37,3 @@ export abstract class ThreeOperandInstruction extends Instruction {
     super();
   }
 }
-
-export abstract class GetterInstruction extends Instruction {
-  // Informs (de)serialization. See Instruction.deserialize.
-  static readonly wireFormat: OperandType[] = [OperandType.UINT8, OperandType.UINT8, OperandType.UINT32];
-
-  constructor(protected indirect: number, protected dstOffset: number) {
-    super();
-  }
-
-  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));
-
-    const [dstOffset] = Addressing.fromWire(this.indirect).resolve([this.dstOffset], memory);
-
-    memory.set(dstOffset, this.getValue(context));
-
-    memory.assert(memoryOperations);
-    context.machineState.incrementPc();
-  }
-
-  protected abstract getValue(env: AvmContext): MemoryValue;
-}

package/src/avm/opcodes/memory.ts

@@ -3,7 +3,6 @@ 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';
 
 export class Set extends Instruction {
   static readonly type: string = 'SET';
@@ -121,12 +120,27 @@ export class CMov extends Instruction {
   }
 }
 
-export class Cast extends TwoOperandInstruction {
+export class Cast extends Instruction {
   static readonly type: string = 'CAST';
   static readonly opcode = Opcode.CAST_8;
 
-  constructor(indirect: number, dstTag: number, srcOffset: number, dstOffset: number) {
-    super(indirect, dstTag, srcOffset, dstOffset);
+  static readonly wireFormat8 = [
+    OperandType.UINT8,
+    OperandType.UINT8,
+    OperandType.UINT8,
+    OperandType.UINT8,
+    OperandType.UINT8,
+  ];
+  static readonly wireFormat16 = [
+    OperandType.UINT8,
+    OperandType.UINT8,
+    OperandType.UINT8,
+    OperandType.UINT16,
+    OperandType.UINT16,
+  ];
+
+  constructor(private indirect: number, private dstTag: number, private srcOffset: number, private dstOffset: number) {
+    super();
   }
 
   public async execute(context: AvmContext): Promise<void> {
@@ -134,10 +148,10 @@ export class Cast extends TwoOperandInstruction {
     const memory = context.machineState.memory.track(this.type);
     context.machineState.consumeGas(this.gasCost(memoryOperations));
 
-    const [srcOffset, dstOffset] = Addressing.fromWire(this.indirect).resolve([this.aOffset, this.dstOffset], memory);
+    const [srcOffset, dstOffset] = Addressing.fromWire(this.indirect).resolve([this.srcOffset, this.dstOffset], memory);
 
     const a = memory.get(srcOffset);
-    const casted = TaggedMemory.buildFromTagTruncating(a.toBigInt(), this.inTag);
+    const casted = TaggedMemory.buildFromTagTruncating(a.toBigInt(), this.dstTag);
 
     memory.set(dstOffset, casted);
 

package/src/avm/opcodes/multi_scalar_mul.ts

@@ -1,8 +1,6 @@
 import { Fq, Point } from '@aztec/circuits.js';
 import { Grumpkin } from '@aztec/circuits.js/barretenberg';
 
-import { strict as assert } from 'assert';
-
 import { type AvmContext } from '../avm_context.js';
 import { Field, TypeTag } from '../avm_memory_types.js';
 import { InstructionExecutionError } from '../errors.js';
@@ -46,7 +44,9 @@ export class MultiScalarMul extends Instruction {
     memory.checkTag(TypeTag.UINT32, this.pointsLengthOffset);
     // Get the size of the unrolled (x, y , inf) points vector
     const pointsReadLength = memory.get(this.pointsLengthOffset).toNumber();
-    assert(pointsReadLength % 3 === 0, 'Points vector offset should be a multiple of 3');
+    if (pointsReadLength % 3 !== 0) {
+      throw new InstructionExecutionError(`Points vector offset should be a multiple of 3, was ${pointsReadLength}`);
+    }
     // Divide by 3 since each point is represented as a triplet to get the number of points
     const numPoints = pointsReadLength / 3;
     // The tag for each triplet will be (Field, Field, Uint8)
@@ -54,8 +54,8 @@ export class MultiScalarMul extends Instruction {
       const offset = pointsOffset + i * 3;
       // Check (Field, Field)
       memory.checkTagsRange(TypeTag.FIELD, offset, 2);
-      // Check Uint8 (inf flag)
-      memory.checkTag(TypeTag.UINT8, offset + 2);
+      // Check Uint1 (inf flag)
+      memory.checkTag(TypeTag.UINT1, offset + 2);
     }
     // Get the unrolled (x, y, inf) representing the points
     const pointsVector = memory.getSlice(pointsOffset, pointsReadLength);
@@ -68,7 +68,7 @@ export class MultiScalarMul extends Instruction {
       writes: 3 /* output triplet */,
       indirect: this.indirect,
     };
-    context.machineState.consumeGas(this.gasCost(memoryOperations));
+    context.machineState.consumeGas(this.gasCost({ ...memoryOperations, dynMultiplier: pointsReadLength }));
     // Get the unrolled scalar (lo & hi) representing the scalars
     const scalarsVector = memory.getSlice(scalarsOffset, scalarReadLength);
     memory.checkTagsRange(TypeTag.FIELD, scalarsOffset, scalarReadLength);

package/src/avm/serialization/bytecode_serialization.ts

@@ -1,33 +1,27 @@
-import { PedersenCommitment } from '../opcodes/commitment.js';
-import { DAGasLeft, L2GasLeft } from '../opcodes/context_getters.js';
-import { EcAdd } from '../opcodes/ec_add.js';
-import { Keccak, KeccakF1600, Pedersen, Poseidon2, Sha256 } from '../opcodes/hashing.js';
 import {
   Add,
-  Address,
   And,
-  BlockNumber,
   CMov,
   Call,
   CalldataCopy,
   Cast,
-  ChainId,
   DebugLog,
   Div,
+  EcAdd,
   EmitNoteHash,
   EmitNullifier,
   EmitUnencryptedLog,
   Eq,
-  FeePerDAGas,
-  FeePerL2Gas,
   FieldDiv,
-  FunctionSelector,
   GetContractInstance,
+  GetEnvVar,
   Instruction,
   InternalCall,
   InternalReturn,
   Jump,
   JumpI,
+  Keccak,
+  KeccakF1600,
   L1ToL2MessageExists,
   Lt,
   Lte,
@@ -37,22 +31,21 @@ import {
   NoteHashExists,
   NullifierExists,
   Or,
+  Pedersen,
+  PedersenCommitment,
+  Poseidon2,
   Return,
   Revert,
   SLoad,
   SStore,
   SendL2ToL1Message,
-  Sender,
   Set,
+  Sha256Compression,
   Shl,
   Shr,
   StaticCall,
-  StorageAddress,
   Sub,
-  Timestamp,
   ToRadixLE,
-  TransactionFee,
-  Version,
   Xor,
 } from '../opcodes/index.js';
 import { MultiScalarMul } from '../opcodes/multi_scalar_mul.js';
@@ -104,25 +97,10 @@ const INSTRUCTION_SET = () =>
     [Opcode.SHR_16, Shr.as(Shr.wireFormat16).deserialize],
     [Opcode.CAST_8, Cast.as(Cast.wireFormat8).deserialize],
     [Opcode.CAST_16, Cast.as(Cast.wireFormat16).deserialize],
-    [Address.opcode, Instruction.deserialize.bind(Address)],
-    [StorageAddress.opcode, Instruction.deserialize.bind(StorageAddress)],
-    [Sender.opcode, Instruction.deserialize.bind(Sender)],
-    [FunctionSelector.opcode, Instruction.deserialize.bind(FunctionSelector)],
-    [TransactionFee.opcode, Instruction.deserialize.bind(TransactionFee)],
-    // Execution Environment - Globals
-    [ChainId.opcode, Instruction.deserialize.bind(ChainId)],
-    [Version.opcode, Instruction.deserialize.bind(Version)],
-    [BlockNumber.opcode, Instruction.deserialize.bind(BlockNumber)],
-    [Timestamp.opcode, Instruction.deserialize.bind(Timestamp)],
-    [FeePerL2Gas.opcode, Instruction.deserialize.bind(FeePerL2Gas)],
-    [FeePerDAGas.opcode, Instruction.deserialize.bind(FeePerDAGas)],
-    // Execution Environment - Calldata
+    // Execution Environment
+    [Opcode.GETENVVAR_16, GetEnvVar.as(GetEnvVar.wireFormat16).deserialize],
     [CalldataCopy.opcode, Instruction.deserialize.bind(CalldataCopy)],
 
-    // Machine State
-    // Machine State - Gas
-    [L2GasLeft.opcode, Instruction.deserialize.bind(L2GasLeft)],
-    [DAGasLeft.opcode, Instruction.deserialize.bind(DAGasLeft)],
     // Machine State - Internal Control Flow
     [Jump.opcode, Instruction.deserialize.bind(Jump)],
     [JumpI.opcode, Instruction.deserialize.bind(JumpI)],
@@ -167,7 +145,7 @@ const INSTRUCTION_SET = () =>
     [EcAdd.opcode, Instruction.deserialize.bind(EcAdd)],
     [Keccak.opcode, Instruction.deserialize.bind(Keccak)],
     [Poseidon2.opcode, Instruction.deserialize.bind(Poseidon2)],
-    [Sha256.opcode, Instruction.deserialize.bind(Sha256)],
+    [Sha256Compression.opcode, Instruction.deserialize.bind(Sha256Compression)],
     [Pedersen.opcode, Instruction.deserialize.bind(Pedersen)],
     [MultiScalarMul.opcode, Instruction.deserialize.bind(MultiScalarMul)],
     [PedersenCommitment.opcode, Instruction.deserialize.bind(PedersenCommitment)],

package/src/avm/serialization/instruction_serialization.ts

@@ -39,21 +39,8 @@ export enum Opcode {
   CAST_8,
   CAST_16,
   // Execution environment
-  ADDRESS,
-  STORAGEADDRESS,
-  SENDER,
-  FUNCTIONSELECTOR,
-  TRANSACTIONFEE,
-  CHAINID,
-  VERSION,
-  BLOCKNUMBER,
-  TIMESTAMP,
-  FEEPERL2GAS,
-  FEEPERDAGAS,
+  GETENVVAR_16,
   CALLDATACOPY,
-  // Gas
-  L2GASLEFT,
-  DAGASLEFT,
   // Control flow
   JUMP_16,
   JUMPI_16,
@@ -92,16 +79,14 @@ export enum Opcode {
   // Gadgets
   KECCAK,
   POSEIDON2,
-  SHA256, // temp - may be removed, but alot of contracts rely on it
+  SHA256COMPRESSION,
+  KECCAKF1600,
   PEDERSEN, // temp - may be removed, but alot of contracts rely on it
   ECADD,
   MSM,
   PEDERSENCOMMITMENT,
   // Conversion
   TORADIXLE,
-  // Future Gadgets -- pending changes in noir
-  SHA256COMPRESSION,
-  KECCAKF1600, // Here for when we eventually support this
 }
 
 // Possible types for an instruction's operand in its wire format. (Keep in sync with CPP code.
@@ -109,6 +94,7 @@ export enum Opcode {
 // Note that cpp code introduced an additional enum value TAG to express the instruction tag. In TS,
 // this one is parsed as UINT8.
 export enum OperandType {
+  UINT1,
   UINT8,
   UINT16,
   UINT32,
@@ -122,6 +108,7 @@ type OperandWriter = (value: any) => void;
 
 // Specifies how to read and write each operand type.
 const OPERAND_SPEC = new Map<OperandType, [number, () => OperandNativeType, OperandWriter]>([
+  [OperandType.UINT1, [1, Buffer.prototype.readUint8, Buffer.prototype.writeUint8]],
   [OperandType.UINT8, [1, Buffer.prototype.readUint8, Buffer.prototype.writeUint8]],
   [OperandType.UINT16, [2, Buffer.prototype.readUint16BE, Buffer.prototype.writeUint16BE]],
   [OperandType.UINT32, [4, Buffer.prototype.readUint32BE, Buffer.prototype.writeUint32BE]],