@aztec/simulator 0.55.1 → 0.57.0

package/src/avm/opcodes/conversion.ts

@@ -1,7 +1,6 @@
-import { strict as assert } from 'assert';
-
 import { type AvmContext } from '../avm_context.js';
-import { TypeTag, Uint8 } from '../avm_memory_types.js';
+import { TypeTag, Uint1, Uint8 } 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';
@@ -16,32 +15,39 @@ export class ToRadixLE extends Instruction {
     OperandType.UINT8, // Indirect
     OperandType.UINT32, // src memory address
     OperandType.UINT32, // dst memory address
-    OperandType.UINT32, // radix (immediate)
+    OperandType.UINT32, // radix memory address
     OperandType.UINT32, // number of limbs (Immediate)
+    OperandType.UINT8, // output is in "bits" mode (Immediate - Uint1 still takes up a whole byte)
   ];
 
   constructor(
     private indirect: number,
     private srcOffset: number,
     private dstOffset: number,
-    private radix: number,
+    private radixOffset: number,
     private numLimbs: number,
+    private outputBits: number, // effectively a bool
   ) {
-    assert(radix <= 256, 'Radix cannot be greater than 256');
     super();
   }
 
   public async execute(context: AvmContext): Promise<void> {
     const memory = context.machineState.memory.track(this.type);
-    const [srcOffset, dstOffset] = Addressing.fromWire(this.indirect).resolve([this.srcOffset, this.dstOffset], memory);
-    const memoryOperations = { reads: 1, 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);
+    memory.checkTag(TypeTag.UINT32, radixOffset);
 
     let value: bigint = memory.get(srcOffset).toBigInt();
-    const radixBN: bigint = BigInt(this.radix);
+    const radix: bigint = memory.get(radixOffset).toBigInt();
+    if (radix > 256) {
+      throw new InstructionExecutionError(`ToRadixLE instruction's radix should be <= 256 (was ${radix})`);
+    }
+    const radixBN: bigint = BigInt(radix);
     const limbArray = [];
 
     for (let i = 0; i < this.numLimbs; i++) {
@@ -50,10 +56,11 @@ export class ToRadixLE extends Instruction {
       value /= radixBN;
     }
 
-    const res = limbArray.map(byte => new Uint8(byte));
+    const outputType = this.outputBits != 0 ? Uint1 : Uint8;
+    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();
   }
 }

package/src/avm/opcodes/ec_add.ts

@@ -14,7 +14,7 @@ export class EcAdd extends Instruction {
   // Informs (de)serialization. See Instruction.deserialize.
   static readonly wireFormat: OperandType[] = [
     OperandType.UINT8, // reserved
-    OperandType.UINT8, // indirect
+    OperandType.UINT16, // indirect
     OperandType.UINT32, // p1X
     OperandType.UINT32, // p1Y
     OperandType.UINT32, // p1IsInfinite
@@ -38,23 +38,21 @@ export class EcAdd extends Instruction {
   }
 
   public async execute(context: AvmContext): Promise<void> {
-    const memoryOperations = { reads: 6, writes: 3, indirect: this.indirect };
     const memory = context.machineState.memory.track(this.type);
-    context.machineState.consumeGas(this.gasCost(memoryOperations));
+    context.machineState.consumeGas(this.gasCost());
 
+    const operands = [
+      this.p1XOffset,
+      this.p1YOffset,
+      this.p1IsInfiniteOffset,
+      this.p2XOffset,
+      this.p2YOffset,
+      this.p2IsInfiniteOffset,
+      this.dstOffset,
+    ];
+    const addressing = Addressing.fromWire(this.indirect, operands.length);
     const [p1XOffset, p1YOffset, p1IsInfiniteOffset, p2XOffset, p2YOffset, p2IsInfiniteOffset, dstOffset] =
-      Addressing.fromWire(this.indirect).resolve(
-        [
-          this.p1XOffset,
-          this.p1YOffset,
-          this.p1IsInfiniteOffset,
-          this.p2XOffset,
-          this.p2YOffset,
-          this.p2IsInfiniteOffset,
-          this.dstOffset,
-        ],
-        memory,
-      );
+      addressing.resolve(operands, memory);
 
     const p1X = memory.get(p1XOffset);
     const p1Y = memory.get(p1YOffset);
@@ -86,7 +84,7 @@ export class EcAdd extends Instruction {
     // Check representation of infinity for grumpkin
     memory.set(dstOffset + 2, new Field(dest.equals(Point.ZERO) ? 1 : 0));
 
-    memory.assert(memoryOperations);
+    memory.assert({ reads: 6, writes: 3, addressing });
     context.machineState.incrementPc();
   }
 }

package/src/avm/opcodes/environment_getters.ts

@@ -1,112 +1,86 @@
 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 memory = context.machineState.memory.track(this.type);
+    context.machineState.consumeGas(this.gasCost());
 
-  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 operands = [this.dstOffset];
+    const addressing = Addressing.fromWire(this.indirect, operands.length);
+    const [dstOffset] = addressing.resolve(operands, 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({ writes: 1, addressing });
+    context.machineState.incrementPc();
   }
 }

package/src/avm/opcodes/external_calls.ts

@@ -15,7 +15,7 @@ abstract class ExternalCall extends Instruction {
   // Informs (de)serialization. See Instruction.deserialize.
   static readonly wireFormat: OperandType[] = [
     OperandType.UINT8,
-    OperandType.UINT8,
+    OperandType.UINT16, // Indirect
     OperandType.UINT32,
     OperandType.UINT32,
     OperandType.UINT32,
@@ -45,29 +45,34 @@ abstract class ExternalCall extends Instruction {
 
   public async execute(context: AvmContext) {
     const memory = context.machineState.memory.track(this.type);
-    const [gasOffset, addrOffset, argsOffset, argsSizeOffset, retOffset, successOffset] = Addressing.fromWire(
-      this.indirect,
-    ).resolve(
-      [this.gasOffset, this.addrOffset, this.argsOffset, this.argsSizeOffset, this.retOffset, this.successOffset],
-      memory,
-    );
+    const operands = [
+      this.gasOffset,
+      this.addrOffset,
+      this.argsOffset,
+      this.argsSizeOffset,
+      this.retOffset,
+      this.successOffset,
+      this.functionSelectorOffset,
+    ];
+    const addressing = Addressing.fromWire(this.indirect, operands.length);
+    const [gasOffset, addrOffset, argsOffset, argsSizeOffset, retOffset, successOffset, functionSelectorOffset] =
+      addressing.resolve(operands, memory);
     memory.checkTags(TypeTag.FIELD, gasOffset, gasOffset + 1);
     memory.checkTag(TypeTag.FIELD, addrOffset);
     memory.checkTag(TypeTag.UINT32, argsSizeOffset);
-    memory.checkTag(TypeTag.FIELD, this.functionSelectorOffset);
+    memory.checkTag(TypeTag.FIELD, functionSelectorOffset);
 
     const calldataSize = memory.get(argsSizeOffset).toNumber();
     memory.checkTagsRange(TypeTag.FIELD, argsOffset, calldataSize);
 
     const callAddress = memory.getAs<Field>(addrOffset);
     const calldata = memory.getSlice(argsOffset, calldataSize).map(f => f.toFr());
-    const functionSelector = memory.getAs<Field>(this.functionSelectorOffset).toFr();
+    const functionSelector = memory.getAs<Field>(functionSelectorOffset).toFr();
     // If we are already in a static call, we propagate the environment.
     const callType = context.environment.isStaticCall ? 'STATICCALL' : this.type;
 
     // First we consume the gas for this operation.
-    const memoryOperations = { reads: calldataSize + 5, writes: 1 + this.retSize, indirect: this.indirect };
-    context.machineState.consumeGas(this.gasCost({ ...memoryOperations, dynMultiplier: calldataSize + this.retSize }));
+    context.machineState.consumeGas(this.gasCost(calldataSize + this.retSize));
     // Then we consume the gas allocated for the nested call. The excess will be refunded later.
     // Gas allocation is capped by the amount of gas left in the current context.
     // We have to do some dancing here because the gas allocation is a field,
@@ -127,7 +132,7 @@ abstract class ExternalCall extends Instruction {
       /*avmCallResults=*/ nestedCallResults,
     );
 
-    memory.assert(memoryOperations);
+    memory.assert({ reads: calldataSize + 5, writes: 1 + this.retSize, addressing });
     context.machineState.incrementPc();
   }
 
@@ -168,16 +173,17 @@ export class Return extends Instruction {
   }
 
   public async execute(context: AvmContext): Promise<void> {
-    const memoryOperations = { reads: this.copySize, indirect: this.indirect };
     const memory = context.machineState.memory.track(this.type);
-    context.machineState.consumeGas(this.gasCost({ ...memoryOperations, dynMultiplier: this.copySize }));
+    context.machineState.consumeGas(this.gasCost(this.copySize));
 
-    const [returnOffset] = Addressing.fromWire(this.indirect).resolve([this.returnOffset], memory);
+    const operands = [this.returnOffset];
+    const addressing = Addressing.fromWire(this.indirect, operands.length);
+    const [returnOffset] = addressing.resolve(operands, memory);
 
     const output = memory.getSlice(returnOffset, this.copySize).map(word => word.toFr());
 
     context.machineState.return(output);
-    memory.assert(memoryOperations);
+    memory.assert({ reads: this.copySize, addressing });
   }
 }
 
@@ -203,16 +209,17 @@ export class Revert extends Instruction {
   }
 
   public async execute(context: AvmContext): Promise<void> {
-    const memoryOperations = { reads: this.retSize, indirect: this.indirect };
     const memory = context.machineState.memory.track(this.type);
-    context.machineState.consumeGas(this.gasCost({ ...memoryOperations, dynMultiplier: this.retSize }));
+    context.machineState.consumeGas(this.gasCost(this.retSize));
 
-    const [returnOffset] = Addressing.fromWire(this.indirect).resolve([this.returnOffset], memory);
+    const operands = [this.returnOffset];
+    const addressing = Addressing.fromWire(this.indirect, operands.length);
+    const [returnOffset] = addressing.resolve(operands, memory);
 
     const output = memory.getSlice(returnOffset, this.retSize).map(word => word.toFr());
 
     context.machineState.revert(output);
-    memory.assert(memoryOperations);
+    memory.assert({ reads: this.retSize, addressing });
   }
 }
 

package/src/avm/opcodes/hashing.ts

@@ -1,9 +1,15 @@
-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 { Opcode, OperandType } from '../serialization/instruction_serialization.js';
 import { Addressing } from './addressing_mode.js';
 import { Instruction } from './instruction.js';
@@ -26,14 +32,12 @@ export class Poseidon2 extends Instruction {
   }
 
   public async execute(context: AvmContext): Promise<void> {
-    const memoryOperations = { reads: Poseidon2.stateSize, writes: Poseidon2.stateSize, indirect: this.indirect };
     const memory = context.machineState.memory.track(this.type);
-    context.machineState.consumeGas(this.gasCost(memoryOperations));
+    context.machineState.consumeGas(this.gasCost());
 
-    const [inputOffset, outputOffset] = Addressing.fromWire(this.indirect).resolve(
-      [this.inputStateOffset, this.outputStateOffset],
-      memory,
-    );
+    const operands = [this.inputStateOffset, this.outputStateOffset];
+    const addressing = Addressing.fromWire(this.indirect, operands.length);
+    const [inputOffset, outputOffset] = addressing.resolve(operands, memory);
     memory.checkTagsRange(TypeTag.FIELD, inputOffset, Poseidon2.stateSize);
 
     const inputState = memory.getSlice(inputOffset, Poseidon2.stateSize);
@@ -43,7 +47,7 @@ export class Poseidon2 extends Instruction {
       outputState.map(word => new Field(word)),
     );
 
-    memory.assert(memoryOperations);
+    memory.assert({ reads: Poseidon2.stateSize, writes: Poseidon2.stateSize, addressing });
     context.machineState.incrementPc();
   }
 }
@@ -73,14 +77,12 @@ export class Keccak extends Instruction {
   // pub fn keccak256(input: [u8], message_size: u32) -> [u8; 32]
   public async execute(context: AvmContext): Promise<void> {
     const memory = context.machineState.memory.track(this.type);
-    const [dstOffset, messageOffset, messageSizeOffset] = Addressing.fromWire(this.indirect).resolve(
-      [this.dstOffset, this.messageOffset, this.messageSizeOffset],
-      memory,
-    );
+    const operands = [this.dstOffset, this.messageOffset, this.messageSizeOffset];
+    const addressing = Addressing.fromWire(this.indirect, operands.length);
+    const [dstOffset, messageOffset, messageSizeOffset] = addressing.resolve(operands, memory);
     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(messageSize));
 
     memory.checkTagsRange(TypeTag.UINT8, messageOffset, messageSize);
 
@@ -91,7 +93,7 @@ export class Keccak extends Instruction {
     const res = [...hashBuffer].map(byte => new Uint8(byte));
     memory.setSlice(dstOffset, res);
 
-    memory.assert(memoryOperations);
+    memory.assert({ reads: messageSize + 1, writes: 32, addressing });
     context.machineState.incrementPc();
   }
 }
@@ -122,15 +124,13 @@ export class KeccakF1600 extends Instruction {
   // pub fn keccakf1600(input: [u64; 25]) -> [u64; 25]
   public async execute(context: AvmContext): Promise<void> {
     const memory = context.machineState.memory.track(this.type);
-    const [dstOffset, stateOffset, stateSizeOffset] = Addressing.fromWire(this.indirect).resolve(
-      [this.dstOffset, this.stateOffset, this.stateSizeOffset],
-      memory,
-    );
+    const operands = [this.dstOffset, this.stateOffset, this.stateSizeOffset];
+    const addressing = Addressing.fromWire(this.indirect, operands.length);
+    const [dstOffset, stateOffset, stateSizeOffset] = addressing.resolve(operands, memory);
     memory.checkTag(TypeTag.UINT32, stateSizeOffset);
     const stateSize = memory.get(stateSizeOffset).toNumber();
     assert(stateSize === 25, 'Invalid state size for keccakf1600');
-    const memoryOperations = { reads: stateSize + 1, writes: 25, indirect: this.indirect };
-    context.machineState.consumeGas(this.gasCost(memoryOperations));
+    context.machineState.consumeGas(this.gasCost());
 
     memory.checkTagsRange(TypeTag.UINT64, stateOffset, stateSize);
 
@@ -140,14 +140,14 @@ export class KeccakF1600 extends Instruction {
     const res = updatedState.map(word => new Uint64(word));
     memory.setSlice(dstOffset, res);
 
-    memory.assert(memoryOperations);
+    memory.assert({ reads: stateSize + 1, writes: 25, addressing });
     context.machineState.incrementPc();
   }
 }
 
-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[] = [
@@ -160,34 +160,36 @@ export class Sha256 extends Instruction {
 
   constructor(
     private indirect: number,
-    private dstOffset: number,
-    private messageOffset: number,
-    private messageSizeOffset: number,
+    private outputOffset: number,
+    private stateOffset: number,
+    private inputsOffset: 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],
-      memory,
-    );
-    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));
-    memory.checkTagsRange(TypeTag.UINT8, messageOffset, messageSize);
+    const operands = [this.outputOffset, this.stateOffset, this.inputsOffset];
+    const addressing = Addressing.fromWire(this.indirect, operands.length);
+    const [outputOffset, stateOffset, inputsOffset] = addressing.resolve(operands, memory);
 
-    const messageData = Buffer.concat(memory.getSlice(messageOffset, messageSize).map(word => word.toBuffer()));
-    const hashBuffer = sha256(messageData);
+    // Note: size of output is same as size of state
+    context.machineState.consumeGas(this.gasCost());
+    memory.checkTagsRange(TypeTag.UINT32, inputsOffset, INPUTS_SIZE);
+    memory.checkTagsRange(TypeTag.UINT32, stateOffset, STATE_SIZE);
 
-    // 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);
+    const state = Uint32Array.from(memory.getSlice(stateOffset, STATE_SIZE).map(word => word.toNumber()));
+    const inputs = Uint32Array.from(memory.getSlice(inputsOffset, INPUTS_SIZE).map(word => word.toNumber()));
+    const output = sha256Compression(state, inputs);
 
-    memory.assert(memoryOperations);
+    // 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({ reads: STATE_SIZE + INPUTS_SIZE, writes: STATE_SIZE, addressing });
     context.machineState.incrementPc();
   }
 }
@@ -218,10 +220,9 @@ export class Pedersen extends Instruction {
 
   public async execute(context: AvmContext): Promise<void> {
     const memory = context.machineState.memory.track(this.type);
-    const [genIndexOffset, dstOffset, messageOffset, messageSizeOffset] = Addressing.fromWire(this.indirect).resolve(
-      [this.genIndexOffset, this.dstOffset, this.messageOffset, this.messageSizeOffset],
-      memory,
-    );
+    const operands = [this.genIndexOffset, this.dstOffset, this.messageOffset, this.messageSizeOffset];
+    const addressing = Addressing.fromWire(this.indirect, operands.length);
+    const [genIndexOffset, dstOffset, messageOffset, messageSizeOffset] = addressing.resolve(operands, memory);
 
     // We hash a set of field elements
     const genIndex = Number(memory.get(genIndexOffset).toBigInt());
@@ -230,8 +231,7 @@ export class Pedersen extends Instruction {
     memory.checkTag(TypeTag.UINT32, messageSizeOffset);
     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(messageSize));
 
     memory.checkTagsRange(TypeTag.FIELD, messageOffset, messageSize);
 
@@ -239,7 +239,7 @@ export class Pedersen extends Instruction {
     const hash = pedersenHash(hashData, genIndex);
     memory.set(dstOffset, new Field(hash));
 
-    memory.assert(memoryOperations);
+    memory.assert({ reads: messageSize + 2, writes: 1, addressing });
     context.machineState.incrementPc();
   }
 }

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.ts

@@ -1,8 +1,7 @@
 import { strict as assert } from 'assert';
 
 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 Gas, getBaseGasCost, getDynamicGasCost, mulGas, sumGas } from '../avm_gas.js';
 import { type BufferCursor } from '../serialization/buffer_cursor.js';
 import { type Serializable } from '../serialization/bytecode_serialization.js';
 import { Opcode, type OperandType, deserialize, serializeAs } from '../serialization/instruction_serialization.js';
@@ -86,17 +85,11 @@ export abstract class Instruction {
 
   /**
    * Computes gas cost for the instruction based on its base cost and memory operations.
-   * @param memoryOps Memory operations performed by the instruction.
    * @returns Gas cost.
    */
-  protected gasCost(ops: Partial<MemoryOperations & { indirect: number; dynMultiplier: number }> = {}) {
+  protected gasCost(dynMultiplier: number = 0): Gas {
     const baseGasCost = getBaseGasCost(this.opcode);
-    // TODO: We are using a simplified gas model to reduce complexity in the circuit.
-    // Memory accounting will probably be removed.
-    // TODO(https://github.com/AztecProtocol/aztec-packages/issues/6861): reconsider.
-    // const memoryGasCost = getMemoryGasCost(memoryOps);
-    // const memoryGasCost = { l2Gas: 0, daGas: 0 };
-    const dynGasCost = mulGas(getDynamicGasCost(this.opcode), ops.dynMultiplier ?? 0);
+    const dynGasCost = mulGas(getDynamicGasCost(this.opcode), dynMultiplier);
     return sumGas(baseGasCost, dynGasCost);
   }