@aztec/simulator 0.0.0-test.0 → 0.0.1-commit.001888fc

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

@@ -1,5 +1,5 @@
 import type { AvmContext } from '../avm_context.js';
-import type { IntegralValue } from '../avm_memory_types.js';
+import { TypeTag, type Uint1 } from '../avm_memory_types.js';
 import { InstructionExecutionError } from '../errors.js';
 import { Opcode, OperandType } from '../serialization/instruction_serialization.js';
 import { Addressing } from './addressing_mode.js';
@@ -16,7 +16,7 @@ export class Jump extends Instruction {
   }
 
   public async execute(context: AvmContext): Promise<void> {
-    context.machineState.consumeGas(this.gasCost());
+    context.machineState.consumeGas(this.baseGasCost(0, 0));
 
     context.machineState.pc = this.jumpOffset;
   }
@@ -38,20 +38,29 @@ export class JumpI extends Instruction {
     OperandType.UINT32,
   ];
 
-  constructor(private indirect: number, private condOffset: number, private loc: number) {
+  constructor(
+    private addressingMode: number,
+    private condOffset: number,
+    private loc: 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.condOffset];
-    const addressing = Addressing.fromWire(this.indirect, operands.length);
-    const [condOffset] = addressing.resolve(operands, memory);
-    const condition = memory.getAs<IntegralValue>(condOffset);
+    const [resolvedCondOffset] = addressing.resolve(operands, memory);
+
+    memory.checkTag(TypeTag.UINT1, resolvedCondOffset);
+    const condition = memory.getAs<Uint1>(resolvedCondOffset);
 
-    if (condition.toBigInt() == 0n) {
+    if (condition.toNumber() == 0) {
       context.machineState.pc = context.machineState.nextPc;
     } else {
       context.machineState.pc = this.loc;
@@ -74,7 +83,7 @@ export class InternalCall extends Instruction {
   }
 
   public async execute(context: AvmContext): Promise<void> {
-    context.machineState.consumeGas(this.gasCost());
+    context.machineState.consumeGas(this.baseGasCost(0, 0));
 
     context.machineState.internalCallStack.push({
       callPc: context.machineState.pc,
@@ -99,7 +108,7 @@ export class InternalReturn extends Instruction {
   }
 
   public async execute(context: AvmContext): Promise<void> {
-    context.machineState.consumeGas(this.gasCost());
+    context.machineState.consumeGas(this.baseGasCost(0, 0));
 
     const stackEntry = context.machineState.internalCallStack.pop();
     if (stackEntry === undefined) {

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

@@ -12,7 +12,7 @@ export class ToRadixBE extends Instruction {
   // Informs (de)serialization. See Instruction.deserialize.
   static readonly wireFormat: OperandType[] = [
     OperandType.UINT8, // Opcode
-    OperandType.UINT16, // Indirect
+    OperandType.UINT16, // addressing_mode
     OperandType.UINT16, // src memory address
     OperandType.UINT16, // radix memory address
     OperandType.UINT16, // number of limbs address
@@ -21,7 +21,7 @@ export class ToRadixBE extends Instruction {
   ];
 
   constructor(
-    private indirect: number,
+    private addressingMode: number,
     private srcOffset: number,
     private radixOffset: number,
     private numLimbsOffset: number,
@@ -33,8 +33,13 @@ export class ToRadixBE extends Instruction {
 
   public async execute(context: AvmContext): Promise<void> {
     const memory = context.machineState.memory;
+    const addressing = Addressing.fromWire(this.addressingMode);
+
+    context.machineState.consumeGas(
+      this.baseGasCost(addressing.indirectOperandsCount(), addressing.relativeOperandsCount()),
+    );
+
     const operands = [this.srcOffset, this.radixOffset, this.numLimbsOffset, this.outputBitsOffset, this.dstOffset];
-    const addressing = Addressing.fromWire(this.indirect, operands.length);
     const [srcOffset, radixOffset, numLimbsOffset, outputBitsOffset, dstOffset] = addressing.resolve(operands, memory);
 
     // The radix gadget only takes in a Field
@@ -44,11 +49,13 @@ export class ToRadixBE extends Instruction {
     memory.checkTag(TypeTag.UINT1, outputBitsOffset);
 
     const numLimbs = memory.get(numLimbsOffset).toNumber();
-    context.machineState.consumeGas(this.gasCost(numLimbs));
+    const radix: bigint = memory.get(radixOffset).toBigInt();
+    context.machineState.consumeGas(
+      this.dynamicGasCost(Math.max(numLimbs, radix > 256n ? 32 : MODULUS_LIMBS_PER_RADIX[Number(radix)])),
+    );
     const outputBits = memory.get(outputBitsOffset).toNumber();
 
     let value: bigint = memory.get(srcOffset).toBigInt();
-    const radix: bigint = memory.get(radixOffset).toBigInt();
 
     if (radix < 2 || radix > 256) {
       throw new InvalidToRadixInputsError(`ToRadixBE instruction's radix should be in range [2,256] (was ${radix}).`);
@@ -73,8 +80,25 @@ export class ToRadixBE extends Instruction {
       value /= radixBN;
     }
 
+    if (value !== 0n) {
+      throw new InvalidToRadixInputsError(`Field failed to decompose in ${numLimbs} limbs.`);
+    }
+
     const outputType = outputBits != 0 ? Uint1 : Uint8;
     const res = limbArray.map(byte => new outputType(byte));
     memory.setSlice(dstOffset, res);
   }
 }
+
+// First two are for radix = 0 and 1, which are invalid, so we have 0 limbs for those cases.
+export const MODULUS_LIMBS_PER_RADIX: number[] = [
+  0, 0, 254, 161, 127, 110, 99, 91, 85, 81, 77, 74, 71, 69, 67, 65, 64, 63, 61, 60, 59, 58, 57, 57, 56, 55, 54, 54, 53,
+  53, 52, 52, 51, 51, 50, 50, 50, 49, 49, 48, 48, 48, 48, 47, 47, 47, 46, 46, 46, 46, 45, 45, 45, 45, 45, 44, 44, 44,
+  44, 44, 43, 43, 43, 43, 43, 43, 42, 42, 42, 42, 42, 42, 42, 41, 41, 41, 41, 41, 41, 41, 41, 41, 40, 40, 40, 40, 40,
+  40, 40, 40, 40, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38,
+  37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
+  36, 36, 36, 36, 36, 36, 36, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
+  35, 35, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,
+  34, 34, 34, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
+  33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
+];

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

@@ -1,8 +1,9 @@
-import { Grumpkin } from '@aztec/foundation/crypto';
-import { Point } from '@aztec/foundation/fields';
+import { Grumpkin } from '@aztec/foundation/crypto/grumpkin';
+import { Point } from '@aztec/foundation/curves/grumpkin';
 
 import type { AvmContext } from '../avm_context.js';
 import { Field, TypeTag, Uint1 } from '../avm_memory_types.js';
+import { EcAddPointNotOnCurveError } from '../errors.js';
 import { Opcode, OperandType } from '../serialization/instruction_serialization.js';
 import { Addressing } from './addressing_mode.js';
 import { Instruction } from './instruction.js';
@@ -25,7 +26,7 @@ export class EcAdd extends Instruction {
   ];
 
   constructor(
-    private indirect: number,
+    private addressingMode: number,
     private p1XOffset: number,
     private p1YOffset: number,
     private p1IsInfiniteOffset: number,
@@ -39,7 +40,11 @@ export class EcAdd 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.p1XOffset,
@@ -50,7 +55,6 @@ export class EcAdd extends Instruction {
       this.p2IsInfiniteOffset,
       this.dstOffset,
     ];
-    const addressing = Addressing.fromWire(this.indirect, operands.length);
     const [p1XOffset, p1YOffset, p1IsInfiniteOffset, p2XOffset, p2YOffset, p2IsInfiniteOffset, dstOffset] =
       addressing.resolve(operands, memory);
 
@@ -62,7 +66,7 @@ export class EcAdd extends Instruction {
     const p1IsInfinite = memory.get(p1IsInfiniteOffset).toNumber() === 1;
     const p1 = new Point(p1X.toFr(), p1Y.toFr(), p1IsInfinite);
     if (!p1.isOnGrumpkin()) {
-      throw new Error(`Point1 is not on the curve`);
+      throw new EcAddPointNotOnCurveError(/*pointIndex=*/ 1, p1);
     }
 
     const p2X = memory.get(p2XOffset);
@@ -71,17 +75,25 @@ export class EcAdd extends Instruction {
     const p2IsInfinite = memory.get(p2IsInfiniteOffset).toNumber() === 1;
     const p2 = new Point(p2X.toFr(), p2Y.toFr(), p2IsInfinite);
     if (!p2.isOnGrumpkin()) {
-      throw new Error(`Point1 is not on the curve`);
+      throw new EcAddPointNotOnCurveError(/*pointIndex=*/ 2, p2);
     }
 
-    const grumpkin = new Grumpkin();
     let dest;
-    if (p1IsInfinite) {
+    if (p1IsInfinite && p2IsInfinite) {
+      dest = Point.ZERO;
+    } else if (p1IsInfinite) {
       dest = p2;
     } else if (p2IsInfinite) {
       dest = p1;
     } else {
-      dest = await grumpkin.add(p1, p2);
+      // TS<>BB ecc add communication is broken for points that add up to infinity.
+      // However, here we know that both points are on the curve, and that none is infinity
+      // so we can check for the case where you add p + (-p) = infinity.
+      if (p1.x.equals(p2.x) && !p1.y.equals(p2.y)) {
+        dest = Point.ZERO;
+      } else {
+        dest = await Grumpkin.add(p1, p2);
+      }
     }
 
     // Important to use setSlice() and not set() in the two following statements as

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

@@ -1,5 +1,5 @@
 import type { AvmContext } from '../avm_context.js';
-import { Field, Uint64 } from '../avm_memory_types.js';
+import { Field, Uint1, Uint32, Uint64, Uint128 } from '../avm_memory_types.js';
 import { InstructionExecutionError } from '../errors.js';
 import { Opcode, OperandType } from '../serialization/instruction_serialization.js';
 import { Addressing } from './addressing_mode.js';
@@ -13,15 +13,15 @@ export enum EnvironmentVariable {
   VERSION,
   BLOCKNUMBER,
   TIMESTAMP,
-  FEEPERL2GAS,
-  FEEPERDAGAS,
+  MINFEEPERL2GAS,
+  MINFEEPERDAGAS,
   ISSTATICCALL,
   L2GASLEFT,
   DAGASLEFT,
 }
 
-function getValue(e: EnvironmentVariable, ctx: AvmContext) {
-  switch (e) {
+function getValue(varEnum: EnvironmentVariable, ctx: AvmContext) {
+  switch (varEnum) {
     case EnvironmentVariable.ADDRESS:
       return new Field(ctx.environment.address.toField());
     case EnvironmentVariable.SENDER:
@@ -33,21 +33,21 @@ function getValue(e: EnvironmentVariable, ctx: AvmContext) {
     case EnvironmentVariable.VERSION:
       return new Field(ctx.environment.globals.version);
     case EnvironmentVariable.BLOCKNUMBER:
-      return new Field(ctx.environment.globals.blockNumber);
+      return new Uint32(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);
+      return new Uint64(ctx.environment.globals.timestamp);
+    case EnvironmentVariable.MINFEEPERL2GAS:
+      return new Uint128(ctx.environment.globals.gasFees.feePerL2Gas);
+    case EnvironmentVariable.MINFEEPERDAGAS:
+      return new Uint128(ctx.environment.globals.gasFees.feePerDaGas);
     case EnvironmentVariable.ISSTATICCALL:
-      return new Field(ctx.environment.isStaticCall ? 1 : 0);
+      return new Uint1(ctx.environment.isStaticCall ? 1 : 0);
     case EnvironmentVariable.L2GASLEFT:
-      return new Field(ctx.machineState.l2GasLeft);
+      return new Uint32(ctx.machineState.l2GasLeft);
     case EnvironmentVariable.DAGASLEFT:
-      return new Field(ctx.machineState.daGasLeft);
+      return new Uint32(ctx.machineState.daGasLeft);
     default:
-      throw new Error(`Unknown environment variable ${e}`);
+      throw new InstructionExecutionError(`Invalid GETENVVAR var enum ${varEnum}`);
   }
 }
 
@@ -56,27 +56,32 @@ export class GetEnvVar extends Instruction {
   public static readonly opcode: Opcode = Opcode.GETENVVAR_16;
   static readonly wireFormat16: OperandType[] = [
     OperandType.UINT8, // opcode
-    OperandType.UINT8, // indirect
+    OperandType.UINT8, // addressing_mode
     OperandType.UINT16, // dstOffset
     OperandType.UINT8, // variable enum (immediate)
   ];
 
-  constructor(private indirect: number, private dstOffset: number, private varEnum: number) {
+  constructor(
+    private addressingMode: number,
+    private dstOffset: number,
+    private varEnum: 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);
 
-    if (!(this.varEnum in EnvironmentVariable)) {
-      throw new InstructionExecutionError(`Invalid GETENVVAR var enum ${this.varEnum}`);
-    }
+    context.machineState.consumeGas(
+      this.baseGasCost(addressing.indirectOperandsCount(), addressing.relativeOperandsCount()),
+    );
 
     const operands = [this.dstOffset];
-    const addressing = Addressing.fromWire(this.indirect, operands.length);
     const [dstOffset] = addressing.resolve(operands, memory);
 
-    memory.set(dstOffset, getValue(this.varEnum as EnvironmentVariable, context));
+    const value = getValue(this.varEnum as EnvironmentVariable, context);
+
+    memory.set(dstOffset, value);
   }
 }

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

@@ -1,6 +1,7 @@
 import type { AvmContext } from '../avm_context.js';
 import type { AvmContractCallResult } from '../avm_contract_call_result.js';
 import { type Field, TypeTag, Uint1 } from '../avm_memory_types.js';
+import { CallDataMemory, ReturnDataMemory } from '../calldata.js';
 import { Opcode, OperandType } from '../serialization/instruction_serialization.js';
 import { Addressing } from './addressing_mode.js';
 import { Instruction } from './instruction.js';
@@ -9,49 +10,58 @@ abstract class ExternalCall extends Instruction {
   // Informs (de)serialization. See Instruction.deserialize.
   static readonly wireFormat: OperandType[] = [
     OperandType.UINT8,
-    OperandType.UINT8, // Indirect
-    OperandType.UINT16,
-    OperandType.UINT16,
-    OperandType.UINT16,
-    OperandType.UINT16,
+    OperandType.UINT16, // addressing_mode
+    OperandType.UINT16, // L2 gas offset
+    OperandType.UINT16, // DA gas offset
+    OperandType.UINT16, // Address offset
+    OperandType.UINT16, // Args offset
+    OperandType.UINT16, // Args size offset
   ];
 
   constructor(
-    private indirect: number,
-    private gasOffset: number,
+    private addressingMode: number,
+    private l2GasOffset: number,
+    private daGasOffset: number,
     private addrOffset: number,
-    private argsOffset: number,
     private argsSizeOffset: number,
+    private argsOffset: number,
   ) {
     super();
   }
 
   public async execute(context: AvmContext) {
     const memory = context.machineState.memory;
-    const operands = [this.gasOffset, this.addrOffset, this.argsOffset, this.argsSizeOffset];
-    const addressing = Addressing.fromWire(this.indirect, operands.length);
-    const [gasOffset, addrOffset, argsOffset, argsSizeOffset] = addressing.resolve(operands, memory);
-    memory.checkTags(TypeTag.FIELD, gasOffset, gasOffset + 1);
+    const addressing = Addressing.fromWire(this.addressingMode);
+
+    context.machineState.consumeGas(
+      this.baseGasCost(addressing.indirectOperandsCount(), addressing.relativeOperandsCount()),
+    );
+
+    const operands = [this.l2GasOffset, this.daGasOffset, this.addrOffset, this.argsSizeOffset, this.argsOffset];
+    const [l2GasOffset, daGasOffset, addrOffset, argsSizeOffset, argsOffset] = addressing.resolve(operands, memory);
+
+    memory.checkTags(TypeTag.UINT32, l2GasOffset);
+    memory.checkTags(TypeTag.UINT32, daGasOffset);
     memory.checkTag(TypeTag.FIELD, addrOffset);
     memory.checkTag(TypeTag.UINT32, argsSizeOffset);
 
     const calldataSize = memory.get(argsSizeOffset).toNumber();
-    const calldata = memory.getSlice(argsOffset, calldataSize).map(f => f.toFr());
-    memory.checkTagsRange(TypeTag.FIELD, argsOffset, calldataSize);
+
+    const calldata = new CallDataMemory(memory, argsOffset, calldataSize);
 
     const callAddress = memory.getAs<Field>(addrOffset);
     // 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.
-    context.machineState.consumeGas(this.gasCost(calldataSize));
-    // Then we consume the gas allocated for the nested call. The excess will be refunded later.
+    // 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,
     // but in the machine state we track gas as a number.
-    const allocatedL2Gas = Number(BigIntMin(memory.get(gasOffset).toBigInt(), BigInt(context.machineState.l2GasLeft)));
+    const allocatedL2Gas = Number(
+      BigIntMin(memory.get(l2GasOffset).toBigInt(), BigInt(context.machineState.l2GasLeft)),
+    );
     const allocatedDaGas = Number(
-      BigIntMin(memory.get(gasOffset + 1).toBigInt(), BigInt(context.machineState.daGasLeft)),
+      BigIntMin(memory.get(daGasOffset).toBigInt(), BigInt(context.machineState.daGasLeft)),
     );
     const allocatedGas = { l2Gas: allocatedL2Gas, daGas: allocatedDaGas };
     context.machineState.consumeGas(allocatedGas);
@@ -64,12 +74,15 @@ abstract class ExternalCall extends Instruction {
     const success = !nestedCallResults.reverted;
 
     // Save return/revert data for later.
-    const fullReturnData = nestedCallResults.output;
-    context.machineState.nestedReturndata = fullReturnData;
+    const returnData = nestedCallResults.output;
+    context.machineState.nestedReturndata = returnData;
 
     // Track the success status directly
     context.machineState.nestedCallSuccess = success;
 
+    // Account for all instructions executed in the nested call
+    context.machineState.instrCounter += nestedCallResults.totalInstructions;
+
     // If the nested call reverted, we try to save the reason and the revert data.
     // This will be used by the caller to try to reconstruct the call stack.
     // This is only a heuristic and may not always work. It is intended to work
@@ -77,7 +90,7 @@ abstract class ExternalCall extends Instruction {
     // (in Noir code).
     if (!success) {
       context.machineState.collectedRevertInfo = {
-        revertDataRepresentative: fullReturnData,
+        revertDataRepresentative: returnData.bestEffortReadAll(),
         recursiveRevertReason: nestedCallResults.revertReason!,
       };
     }
@@ -124,15 +137,22 @@ export class SuccessCopy extends Instruction {
     OperandType.UINT16, // dstOffset (16-bit)
   ];
 
-  constructor(private indirect: number, private dstOffset: number) {
+  constructor(
+    private addressingMode: number,
+    private dstOffset: number,
+  ) {
     super();
   }
 
   public async execute(context: AvmContext): Promise<void> {
     const memory = context.machineState.memory;
+    const addressing = Addressing.fromWire(this.addressingMode);
+
+    context.machineState.consumeGas(
+      this.baseGasCost(addressing.indirectOperandsCount(), addressing.relativeOperandsCount()),
+    );
 
     const operands = [this.dstOffset];
-    const addressing = Addressing.fromWire(this.indirect, operands.length);
     const [dstOffset] = addressing.resolve(operands, memory);
 
     // Use the direct success tracking property
@@ -154,22 +174,29 @@ export class Return extends Instruction {
     OperandType.UINT16,
   ];
 
-  constructor(private indirect: number, private returnOffset: number, private returnSizeOffset: number) {
+  constructor(
+    private addressingMode: number,
+    private returnSizeOffset: number,
+    private returnOffset: number,
+  ) {
     super();
   }
 
   public async execute(context: AvmContext): Promise<void> {
     const memory = context.machineState.memory;
+    const addressing = Addressing.fromWire(this.addressingMode);
 
-    const operands = [this.returnOffset, this.returnSizeOffset];
-    const addressing = Addressing.fromWire(this.indirect, operands.length);
-    const [returnOffset, returnSizeOffset] = addressing.resolve(operands, memory);
+    context.machineState.consumeGas(
+      this.baseGasCost(addressing.indirectOperandsCount(), addressing.relativeOperandsCount()),
+    );
+
+    const operands = [this.returnSizeOffset, this.returnOffset];
+    const [returnSizeOffset, returnOffset] = addressing.resolve(operands, memory);
 
     memory.checkTag(TypeTag.UINT32, returnSizeOffset);
     const returnSize = memory.get(returnSizeOffset).toNumber();
-    context.machineState.consumeGas(this.gasCost(returnSize));
 
-    const output = memory.getSlice(returnOffset, returnSize).map(word => word.toFr());
+    const output = new ReturnDataMemory(memory, returnOffset, returnSize);
 
     context.machineState.return(output);
   }
@@ -196,21 +223,28 @@ export class Revert extends Instruction {
     OperandType.UINT16,
   ];
 
-  constructor(private indirect: number, private returnOffset: number, private retSizeOffset: number) {
+  constructor(
+    private addressingMode: number,
+    private retSizeOffset: number,
+    private returnOffset: number,
+  ) {
     super();
   }
 
   public async execute(context: AvmContext): Promise<void> {
     const memory = context.machineState.memory;
+    const addressing = Addressing.fromWire(this.addressingMode);
+
+    context.machineState.consumeGas(
+      this.baseGasCost(addressing.indirectOperandsCount(), addressing.relativeOperandsCount()),
+    );
 
-    const operands = [this.returnOffset, this.retSizeOffset];
-    const addressing = Addressing.fromWire(this.indirect, operands.length);
-    const [returnOffset, retSizeOffset] = addressing.resolve(operands, memory);
+    const operands = [this.retSizeOffset, this.returnOffset];
+    const [retSizeOffset, returnOffset] = addressing.resolve(operands, memory);
 
     memory.checkTag(TypeTag.UINT32, retSizeOffset);
     const retSize = memory.get(retSizeOffset).toNumber();
-    context.machineState.consumeGas(this.gasCost(retSize));
-    const output = memory.getSlice(returnOffset, retSize).map(word => word.toFr());
+    const output = new ReturnDataMemory(memory, returnOffset, retSize);
 
     context.machineState.revert(output);
   }

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

@@ -1,4 +1,6 @@
-import { keccakf1600, poseidon2Permutation, sha256Compression } from '@aztec/foundation/crypto';
+import { keccakf1600 } from '@aztec/foundation/crypto/keccak';
+import { poseidon2Permutation } from '@aztec/foundation/crypto/poseidon';
+import { sha256Compression } from '@aztec/foundation/crypto/sha256';
 
 import type { AvmContext } from '../avm_context.js';
 import { Field, TypeTag, Uint32, Uint64 } from '../avm_memory_types.js';
@@ -19,16 +21,24 @@ export class Poseidon2 extends Instruction {
     OperandType.UINT16,
   ];
 
-  constructor(private indirect: number, private inputStateOffset: number, private outputStateOffset: number) {
+  constructor(
+    private addressingMode: number,
+    private inputStateOffset: number,
+    private outputStateOffset: 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.inputStateOffset, this.outputStateOffset];
-    const addressing = Addressing.fromWire(this.indirect, operands.length);
+
     const [inputOffset, outputOffset] = addressing.resolve(operands, memory);
 
     const inputState = memory.getSlice(inputOffset, Poseidon2.stateSize);
@@ -54,7 +64,11 @@ export class KeccakF1600 extends Instruction {
     OperandType.UINT16,
   ];
 
-  constructor(private indirect: number, private dstOffset: number, private inputOffset: number) {
+  constructor(
+    private addressingMode: number,
+    private dstOffset: number,
+    private inputOffset: number,
+  ) {
     super();
   }
 
@@ -62,10 +76,14 @@ export class KeccakF1600 extends Instruction {
   public async execute(context: AvmContext): Promise<void> {
     const inputSize = 25;
     const memory = context.machineState.memory;
+    const addressing = Addressing.fromWire(this.addressingMode);
+
+    context.machineState.consumeGas(
+      this.baseGasCost(addressing.indirectOperandsCount(), addressing.relativeOperandsCount()),
+    );
+
     const operands = [this.dstOffset, this.inputOffset];
-    const addressing = Addressing.fromWire(this.indirect, operands.length);
     const [dstOffset, inputOffset] = addressing.resolve(operands, memory);
-    context.machineState.consumeGas(this.gasCost());
 
     const stateData = memory.getSlice(inputOffset, inputSize).map(word => word.toBigInt());
     memory.checkTagsRange(TypeTag.UINT64, inputOffset, inputSize);
@@ -91,7 +109,7 @@ export class Sha256Compression extends Instruction {
   ];
 
   constructor(
-    private indirect: number,
+    private addressingMode: number,
     private outputOffset: number,
     private stateOffset: number,
     private inputsOffset: number,
@@ -104,19 +122,27 @@ export class Sha256Compression extends Instruction {
     const INPUTS_SIZE = 16;
 
     const memory = context.machineState.memory;
+    const addressing = Addressing.fromWire(this.addressingMode);
+
+    context.machineState.consumeGas(
+      this.baseGasCost(addressing.indirectOperandsCount(), addressing.relativeOperandsCount()),
+    );
+
     const operands = [this.outputOffset, this.stateOffset, this.inputsOffset];
-    const addressing = Addressing.fromWire(this.indirect, operands.length);
     const [outputOffset, stateOffset, inputsOffset] = addressing.resolve(operands, memory);
 
     // Note: size of output is same as size of state
-    context.machineState.consumeGas(this.gasCost());
-    const inputs = Uint32Array.from(memory.getSlice(inputsOffset, INPUTS_SIZE).map(word => word.toNumber()));
-    const state = Uint32Array.from(memory.getSlice(stateOffset, STATE_SIZE).map(word => word.toNumber()));
+    const inputs = memory.getSlice(inputsOffset, INPUTS_SIZE).map(word => word.toBigInt());
+    const state = memory.getSlice(stateOffset, STATE_SIZE).map(word => word.toBigInt());
 
     memory.checkTagsRange(TypeTag.UINT32, inputsOffset, INPUTS_SIZE);
     memory.checkTagsRange(TypeTag.UINT32, stateOffset, STATE_SIZE);
 
-    const output = sha256Compression(state, inputs);
+    // At this point both state and inputs are Uint32Array-compatible
+    const inputsArray = new Uint32Array(inputs.map(i => Number(i)));
+    const stateArray = new Uint32Array(state.map(i => Number(i)));
+
+    const output = sha256Compression(stateArray, inputsArray);
 
     // Conversion required from Uint32Array to Uint32[] (can't map directly, need `...`)
     const res = [...output].map(word => new Uint32(word));