@aztec/simulator 0.87.2 → 0.87.3-nightly.20250528

package/src/private/providers/circuit_recording/memory_circuit_recorder.ts

@@ -0,0 +1,11 @@
+import { CircuitRecorder } from './circuit_recorder.js';
+
+/*
+ * In memory circuit recorder uses the default implementation. This is kept
+ * while we decide the fate of the FileCircuitRecorder
+ */
+export class MemoryCircuitRecorder extends CircuitRecorder {
+  constructor() {
+    super();
+  }
+}

package/src/private/providers/circuit_recording/simulation_provider_recorder_wrapper.ts

@@ -2,18 +2,21 @@ import type { ForeignCallHandler } from '@aztec/noir-protocol-circuits-types/typ
 import type { FunctionArtifactWithContractName } from '@aztec/stdlib/abi';
 import type { NoirCompiledCircuitWithName } from '@aztec/stdlib/noir';
 
-import type { ACIRCallback, ACIRExecutionResult } from '../../acvm/acvm.js';
+import type { ACIRCallback, ACIRCallbackStats, ACIRExecutionResult } from '../../acvm/acvm.js';
 import type { ACVMWitness } from '../../acvm/acvm_types.js';
 import type { ACVMSuccess } from '../acvm_native.js';
 import type { SimulationProvider } from '../simulation_provider.js';
-import { CircuitRecorder } from './circuit_recorder.js';
+import type { CircuitRecorder } from './circuit_recorder.js';
 
 /**
  * Takes a simulation provider and wraps it in a circuit recorder. See CircuitRecorder for more details on how circuit
  * recording works.
  */
 export class SimulationProviderRecorderWrapper implements SimulationProvider {
-  constructor(private simulator: SimulationProvider) {}
+  constructor(
+    private simulator: SimulationProvider,
+    private recorder: CircuitRecorder,
+  ) {}
 
   executeProtocolCircuit(
     input: ACVMWitness,
@@ -47,7 +50,7 @@ export class SimulationProviderRecorderWrapper implements SimulationProvider {
     );
   }
 
-  async #simulate<C extends ACIRCallback | ForeignCallHandler | undefined, T>(
+  async #simulate<C extends ACIRCallback | ForeignCallHandler | undefined, T extends ACIRExecutionResult | ACVMSuccess>(
     simulateFn: (wrappedCallback: C) => Promise<T>,
     input: ACVMWitness,
     bytecode: Buffer,
@@ -55,28 +58,33 @@ export class SimulationProviderRecorderWrapper implements SimulationProvider {
     functionName: string,
     callback: C,
   ): Promise<T> {
-    const recordDir = process.env.CIRCUIT_RECORD_DIR;
-    if (!recordDir) {
-      // Recording is not enabled so we just execute the circuit
-      return simulateFn(callback);
-    }
-
     // Start recording circuit execution
-    const recorder = await CircuitRecorder.start(recordDir, input, bytecode, contractName, functionName);
+    await this.recorder.start(input, bytecode, contractName, functionName);
 
     // If callback was provided, we wrap it in a circuit recorder callback wrapper
-    const wrappedCallback = recorder.wrapCallback(callback);
+    const wrappedCallback = this.recorder.wrapCallback(callback);
     let result: T;
     try {
       result = await simulateFn(wrappedCallback as C);
     } catch (error) {
       // If an error occurs, we finalize the recording file with the error
-      await recorder.finishWithError(error);
+      await this.recorder.finishWithError(error);
       throw error;
     }
 
     // Witness generation is complete so we finish the circuit recorder
-    await recorder.finish();
+    const recording = await this.recorder.finish();
+
+    (result as ACIRExecutionResult).oracles = recording.oracleCalls?.reduce(
+      (acc, { time, name }) => {
+        if (!acc[name]) {
+          acc[name] = { times: [] };
+        }
+        acc[name].times.push(time);
+        return acc;
+      },
+      {} as Record<string, ACIRCallbackStats>,
+    );
 
     return result;
   }

package/src/private/utility_execution_oracle.ts

@@ -274,7 +274,7 @@ export class UtilityExecutionOracle extends TypedOracle {
     return await this.executionDataProvider.getIndexedTaggingSecretAsSender(this.contractAddress, sender, recipient);
   }
 
-  public override async syncPrivateState(pendingTaggedLogArrayBaseSlot: Fr) {
+  public override async fetchTaggedLogs(pendingTaggedLogArrayBaseSlot: Fr) {
     await this.executionDataProvider.syncTaggedLogs(this.contractAddress, pendingTaggedLogArrayBaseSlot, this.scopes);
 
     await this.executionDataProvider.removeNullifiedNotes(this.contractAddress);

package/src/public/avm/avm_gas.ts

@@ -104,7 +104,7 @@ const BASE_GAS_COSTS: Record<Opcode, Gas> = {
   [Opcode.MOV_8]: makeCost(c.AVM_MOV_BASE_L2_GAS, 0),
   [Opcode.MOV_16]: makeCost(c.AVM_MOV_BASE_L2_GAS, 0),
   [Opcode.SLOAD]: makeCost(c.AVM_SLOAD_BASE_L2_GAS, 0),
-  [Opcode.SSTORE]: makeCost(c.AVM_SSTORE_BASE_L2_GAS, c.AVM_SSTORE_BASE_DA_GAS),
+  [Opcode.SSTORE]: makeCost(c.AVM_SSTORE_BASE_L2_GAS, 0), // DA gas is dynamic
   [Opcode.NOTEHASHEXISTS]: makeCost(c.AVM_NOTEHASHEXISTS_BASE_L2_GAS, 0),
   [Opcode.EMITNOTEHASH]: makeCost(c.AVM_EMITNOTEHASH_BASE_L2_GAS, c.AVM_EMITNOTEHASH_BASE_DA_GAS),
   [Opcode.NULLIFIEREXISTS]: makeCost(c.AVM_NULLIFIEREXISTS_BASE_L2_GAS, 0),
@@ -129,13 +129,16 @@ const BASE_GAS_COSTS: Record<Opcode, Gas> = {
 const DYNAMIC_GAS_COSTS = new Map<Opcode, Gas>([
   [Opcode.CALLDATACOPY, makeCost(c.AVM_CALLDATACOPY_DYN_L2_GAS, 0)],
   [Opcode.RETURNDATACOPY, makeCost(c.AVM_RETURNDATACOPY_DYN_L2_GAS, 0)],
+  // TODO: Call and static call based on bytecode length
   [Opcode.EMITUNENCRYPTEDLOG, makeCost(c.AVM_EMITUNENCRYPTEDLOG_DYN_L2_GAS, c.AVM_EMITUNENCRYPTEDLOG_DYN_DA_GAS)],
-  [Opcode.CALL, makeCost(c.AVM_CALL_DYN_L2_GAS, 0)],
-  [Opcode.STATICCALL, makeCost(c.AVM_STATICCALL_DYN_L2_GAS, 0)],
-  [Opcode.RETURN, makeCost(c.AVM_RETURN_DYN_L2_GAS, 0)],
-  [Opcode.REVERT_8, makeCost(c.AVM_REVERT_DYN_L2_GAS, 0)],
-  [Opcode.REVERT_16, makeCost(c.AVM_REVERT_DYN_L2_GAS, 0)],
   [Opcode.TORADIXBE, makeCost(c.AVM_TORADIXBE_DYN_L2_GAS, 0)],
+  [Opcode.AND_8, makeCost(c.AVM_BITWISE_DYN_L2_GAS, 0)],
+  [Opcode.AND_16, makeCost(c.AVM_BITWISE_DYN_L2_GAS, 0)],
+  [Opcode.OR_8, makeCost(c.AVM_BITWISE_DYN_L2_GAS, 0)],
+  [Opcode.OR_16, makeCost(c.AVM_BITWISE_DYN_L2_GAS, 0)],
+  [Opcode.XOR_8, makeCost(c.AVM_BITWISE_DYN_L2_GAS, 0)],
+  [Opcode.XOR_16, makeCost(c.AVM_BITWISE_DYN_L2_GAS, 0)],
+  [Opcode.SSTORE, makeCost(0, c.AVM_SSTORE_DYN_DA_GAS)],
 ]);
 
 /** Returns the fixed base gas cost for a given opcode. */
@@ -143,17 +146,20 @@ export function getBaseGasCost(opcode: Opcode): Gas {
   return BASE_GAS_COSTS[opcode];
 }
 
-export function getDynamicGasCost(opcode: Opcode): Gas {
-  return DYNAMIC_GAS_COSTS.has(opcode) ? DYNAMIC_GAS_COSTS.get(opcode)! : makeCost(0, 0);
+export function computeAddressingCost(indirectOperandsCount: number, relativeOperandsCount: number): Gas {
+  return makeCost(
+    indirectOperandsCount * c.AVM_ADDRESSING_INDIRECT_L2_GAS + relativeOperandsCount * c.AVM_ADDRESSING_RELATIVE_L2_GAS,
+    0,
+  );
 }
 
-/** Returns gas cost for an operation on a given type tag based on the base cost per byte. */
-export function getGasCostForTypeTag(tag: TypeTag, baseCost: Gas) {
-  return mulGas(baseCost, getGasCostMultiplierFromTypeTag(tag));
+export function getDynamicGasCost(opcode: Opcode): Gas {
+  return DYNAMIC_GAS_COSTS.has(opcode) ? DYNAMIC_GAS_COSTS.get(opcode)! : makeCost(0, 0);
 }
 
-/** Returns a multiplier based on the size of the type represented by the tag. Throws on uninitialized or invalid. */
-function getGasCostMultiplierFromTypeTag(tag: TypeTag) {
+/** Returns a multiplier based on the byte size of the type represented by the integer tag.
+ * Used to account for necessary rows in the bitwise trace. Throws on invalid. */
+export function getBitwiseDynamicGasMultiplier(tag: TypeTag) {
   switch (tag) {
     case TypeTag.UINT1: // same as u8
       return 1;
@@ -168,7 +174,7 @@ function getGasCostMultiplierFromTypeTag(tag: TypeTag) {
     case TypeTag.UINT128:
       return 16;
     case TypeTag.FIELD:
-      return 32;
+      return 0; // Field is not allowed for bitwise operations. However we don't fail in gas, since we'll fail in bitwise.
     case TypeTag.INVALID:
       throw new InstructionExecutionError(`Invalid tag type for gas cost multiplier: ${TypeTag[tag]}`);
   }

package/src/public/avm/fixtures/base_avm_simulation_tester.ts

@@ -100,4 +100,9 @@ export abstract class BaseAvmSimulationTester {
     );
     await this.merkleTrees.sequentialInsert(MerkleTreeId.NULLIFIER_TREE, [contractAddressNullifier.toBuffer()]);
   }
+
+  async insertNullifier(contractThatEmitted: AztecAddress, nullifier: Fr) {
+    const siloedNullifier = await siloNullifier(contractThatEmitted, nullifier);
+    await this.merkleTrees.sequentialInsert(MerkleTreeId.NULLIFIER_TREE, [siloedNullifier.toBuffer()]);
+  }
 }

package/src/public/avm/fixtures/utils.ts

@@ -122,7 +122,7 @@ export async function createContractClassAndInstance(
   const contractClass = await makeContractClassPublic(seed, bytecode);
 
   const constructorAbi = getContractFunctionAbi('constructor', contractArtifact);
-  const { publicKeys } = await deriveKeys(Fr.random());
+  const { publicKeys } = await deriveKeys(new Fr(seed));
   const initializationHash = await computeInitializationHash(constructorAbi, constructorArgs);
   const contractInstance =
     originalContractClassId === undefined

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

@@ -31,7 +31,9 @@ export class NoteHashExists extends Instruction {
     const memory = context.machineState.memory;
     const addressing = Addressing.fromWire(this.indirect);
 
-    context.machineState.consumeGas(this.gasCost());
+    context.machineState.consumeGas(
+      this.baseGasCost(addressing.indirectOperandsCount(), addressing.relativeOperandsCount()),
+    );
     const operands = [this.noteHashOffset, this.leafIndexOffset, this.existsOffset];
     const [noteHashOffset, leafIndexOffset, existsOffset] = addressing.resolve(operands, memory);
     memory.checkTags(TypeTag.FIELD, noteHashOffset, leafIndexOffset);
@@ -62,7 +64,9 @@ export class EmitNoteHash extends Instruction {
     const memory = context.machineState.memory;
     const addressing = Addressing.fromWire(this.indirect);
 
-    context.machineState.consumeGas(this.gasCost());
+    context.machineState.consumeGas(
+      this.baseGasCost(addressing.indirectOperandsCount(), addressing.relativeOperandsCount()),
+    );
 
     const operands = [this.noteHashOffset];
     const [noteHashOffset] = addressing.resolve(operands, memory);
@@ -102,7 +106,9 @@ export class NullifierExists extends Instruction {
     const memory = context.machineState.memory;
     const addressing = Addressing.fromWire(this.indirect);
 
-    context.machineState.consumeGas(this.gasCost());
+    context.machineState.consumeGas(
+      this.baseGasCost(addressing.indirectOperandsCount(), addressing.relativeOperandsCount()),
+    );
 
     const operands = [this.nullifierOffset, this.addressOffset, this.existsOffset];
     const [nullifierOffset, addressOffset, existsOffset] = addressing.resolve(operands, memory);
@@ -137,7 +143,9 @@ export class EmitNullifier extends Instruction {
     const memory = context.machineState.memory;
     const addressing = Addressing.fromWire(this.indirect);
 
-    context.machineState.consumeGas(this.gasCost());
+    context.machineState.consumeGas(
+      this.baseGasCost(addressing.indirectOperandsCount(), addressing.relativeOperandsCount()),
+    );
 
     const operands = [this.nullifierOffset];
     const [nullifierOffset] = addressing.resolve(operands, memory);
@@ -184,7 +192,9 @@ export class L1ToL2MessageExists extends Instruction {
     const memory = context.machineState.memory;
     const addressing = Addressing.fromWire(this.indirect);
 
-    context.machineState.consumeGas(this.gasCost());
+    context.machineState.consumeGas(
+      this.baseGasCost(addressing.indirectOperandsCount(), addressing.relativeOperandsCount()),
+    );
 
     const operands = [this.msgHashOffset, this.msgLeafIndexOffset, this.existsOffset];
     const [msgHashOffset, msgLeafIndexOffset, existsOffset] = addressing.resolve(operands, memory);
@@ -220,6 +230,10 @@ export class EmitUnencryptedLog extends Instruction {
     const memory = context.machineState.memory;
     const addressing = Addressing.fromWire(this.indirect);
 
+    context.machineState.consumeGas(
+      this.baseGasCost(addressing.indirectOperandsCount(), addressing.relativeOperandsCount()),
+    );
+
     const operands = [this.logOffset, this.logSizeOffset];
     const [logOffset, logSizeOffset] = addressing.resolve(operands, memory);
     memory.checkTag(TypeTag.UINT32, logSizeOffset);
@@ -228,7 +242,7 @@ export class EmitUnencryptedLog extends Instruction {
 
     const contractAddress = context.environment.address;
 
-    context.machineState.consumeGas(this.gasCost(logSize));
+    context.machineState.consumeGas(this.dynamicGasCost(logSize));
     const log = memory.getSlice(logOffset, logSize).map(f => f.toFr());
     context.persistableState.writePublicLog(contractAddress, log);
   }
@@ -256,7 +270,9 @@ export class SendL2ToL1Message extends Instruction {
     const memory = context.machineState.memory;
     const addressing = Addressing.fromWire(this.indirect);
 
-    context.machineState.consumeGas(this.gasCost());
+    context.machineState.consumeGas(
+      this.baseGasCost(addressing.indirectOperandsCount(), addressing.relativeOperandsCount()),
+    );
 
     const operands = [this.recipientOffset, this.contentOffset];
     const [recipientOffset, contentOffset] = addressing.resolve(operands, memory);

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

@@ -54,6 +54,14 @@ export class Addressing {
     return wire;
   }
 
+  public indirectOperandsCount(): number {
+    return this.modePerOperand.filter(mode => mode & AddressingMode.INDIRECT).length;
+  }
+
+  public relativeOperandsCount(): number {
+    return this.modePerOperand.filter(mode => mode & AddressingMode.RELATIVE).length;
+  }
+
   /**
    * Resolves the offsets using the addressing mode.
    * @param offsets The offsets to resolve.

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

@@ -16,7 +16,9 @@ export abstract class ThreeOperandArithmeticInstruction extends ThreeOperandInst
     const memory = context.machineState.memory;
     const addressing = Addressing.fromWire(this.indirect);
 
-    context.machineState.consumeGas(this.gasCost());
+    context.machineState.consumeGas(
+      this.baseGasCost(addressing.indirectOperandsCount(), addressing.relativeOperandsCount()),
+    );
 
     const operands = [this.aOffset, this.bOffset, this.dstOffset];
     const [aOffset, bOffset, dstOffset] = addressing.resolve(operands, memory);

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

@@ -1,4 +1,5 @@
 import type { AvmContext } from '../avm_context.js';
+import { getBitwiseDynamicGasMultiplier } from '../avm_gas.js';
 import { type IntegralValue, TaggedMemory, type TaggedMemoryInterface, TypeTag } from '../avm_memory_types.js';
 import { Opcode, OperandType } from '../serialization/instruction_serialization.js';
 import { Addressing } from './addressing_mode.js';
@@ -10,12 +11,17 @@ abstract class ThreeOperandBitwiseInstruction extends ThreeOperandInstruction {
     const memory = context.machineState.memory;
     const addressing = Addressing.fromWire(this.indirect);
 
-    context.machineState.consumeGas(this.gasCost());
+    context.machineState.consumeGas(
+      this.baseGasCost(addressing.indirectOperandsCount(), addressing.relativeOperandsCount()),
+    );
 
     const operands = [this.aOffset, this.bOffset, this.dstOffset];
     const [aOffset, bOffset, dstOffset] = addressing.resolve(operands, memory);
     this.checkTags(memory, aOffset, bOffset);
 
+    const multiplier = this.getDynamicMultiplier(memory.getTag(aOffset));
+    context.machineState.consumeGas(this.dynamicGasCost(multiplier));
+
     const a = memory.getAs<IntegralValue>(aOffset);
     const b = memory.getAs<IntegralValue>(bOffset);
 
@@ -28,6 +34,10 @@ abstract class ThreeOperandBitwiseInstruction extends ThreeOperandInstruction {
     TaggedMemory.checkIsIntegralTag(memory.getTag(aOffset));
     memory.checkTagsAreSame(aOffset, bOffset);
   }
+
+  protected getDynamicMultiplier(_lhsTag: TypeTag): number {
+    return 0;
+  }
 }
 
 export class And extends ThreeOperandBitwiseInstruction {
@@ -37,6 +47,10 @@ export class And extends ThreeOperandBitwiseInstruction {
   protected override compute(a: IntegralValue, b: IntegralValue): IntegralValue {
     return a.and(b);
   }
+
+  protected override getDynamicMultiplier(lhsTag: TypeTag): number {
+    return getBitwiseDynamicGasMultiplier(lhsTag);
+  }
 }
 
 export class Or extends ThreeOperandBitwiseInstruction {
@@ -46,6 +60,10 @@ export class Or extends ThreeOperandBitwiseInstruction {
   protected override compute(a: IntegralValue, b: IntegralValue): IntegralValue {
     return a.or(b);
   }
+
+  protected override getDynamicMultiplier(lhsTag: TypeTag): number {
+    return getBitwiseDynamicGasMultiplier(lhsTag);
+  }
 }
 
 export class Xor extends ThreeOperandBitwiseInstruction {
@@ -55,6 +73,10 @@ export class Xor extends ThreeOperandBitwiseInstruction {
   protected override compute(a: IntegralValue, b: IntegralValue): IntegralValue {
     return a.xor(b);
   }
+
+  protected override getDynamicMultiplier(lhsTag: TypeTag): number {
+    return getBitwiseDynamicGasMultiplier(lhsTag);
+  }
 }
 
 export class Shl extends ThreeOperandBitwiseInstruction {
@@ -102,7 +124,9 @@ export class Not extends Instruction {
     const memory = context.machineState.memory;
     const addressing = Addressing.fromWire(this.indirect);
 
-    context.machineState.consumeGas(this.gasCost());
+    context.machineState.consumeGas(
+      this.baseGasCost(addressing.indirectOperandsCount(), addressing.relativeOperandsCount()),
+    );
 
     const operands = [this.srcOffset, this.dstOffset];
     const [srcOffset, dstOffset] = addressing.resolve(operands, memory);

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

@@ -9,7 +9,9 @@ abstract class ComparatorInstruction extends ThreeOperandInstruction {
     const memory = context.machineState.memory;
     const addressing = Addressing.fromWire(this.indirect);
 
-    context.machineState.consumeGas(this.gasCost());
+    context.machineState.consumeGas(
+      this.baseGasCost(addressing.indirectOperandsCount(), addressing.relativeOperandsCount()),
+    );
 
     const operands = [this.aOffset, this.bOffset, this.dstOffset];
     const [aOffset, bOffset, dstOffset] = addressing.resolve(operands, memory);

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

@@ -36,7 +36,9 @@ export class GetContractInstance extends Instruction {
     const memory = context.machineState.memory;
     const addressing = Addressing.fromWire(this.indirect);
 
-    context.machineState.consumeGas(this.gasCost());
+    context.machineState.consumeGas(
+      this.baseGasCost(addressing.indirectOperandsCount(), addressing.relativeOperandsCount()),
+    );
 
     if (!(this.memberEnum in ContractInstanceMember)) {
       throw new InstructionExecutionError(`Invalid GETCONSTRACTINSTANCE member enum ${this.memberEnum}`);

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

@@ -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;
   }
@@ -50,7 +50,9 @@ export class JumpI extends Instruction {
     const memory = context.machineState.memory;
     const addressing = Addressing.fromWire(this.indirect);
 
-    context.machineState.consumeGas(this.gasCost());
+    context.machineState.consumeGas(
+      this.baseGasCost(addressing.indirectOperandsCount(), addressing.relativeOperandsCount()),
+    );
 
     const operands = [this.condOffset];
     const [condOffset] = addressing.resolve(operands, memory);
@@ -79,7 +81,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,
@@ -104,7 +106,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

@@ -35,6 +35,10 @@ export class ToRadixBE extends Instruction {
     const memory = context.machineState.memory;
     const addressing = Addressing.fromWire(this.indirect);
 
+    context.machineState.consumeGas(
+      this.baseGasCost(addressing.indirectOperandsCount(), addressing.relativeOperandsCount()),
+    );
+
     const operands = [this.srcOffset, this.radixOffset, this.numLimbsOffset, this.outputBitsOffset, this.dstOffset];
     const [srcOffset, radixOffset, numLimbsOffset, outputBitsOffset, dstOffset] = addressing.resolve(operands, memory);
 
@@ -45,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}).`);
@@ -79,3 +85,16 @@ export class ToRadixBE extends Instruction {
     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

@@ -41,7 +41,9 @@ export class EcAdd extends Instruction {
     const memory = context.machineState.memory;
     const addressing = Addressing.fromWire(this.indirect);
 
-    context.machineState.consumeGas(this.gasCost());
+    context.machineState.consumeGas(
+      this.baseGasCost(addressing.indirectOperandsCount(), addressing.relativeOperandsCount()),
+    );
 
     const operands = [
       this.p1XOffset,

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

@@ -73,7 +73,9 @@ export class GetEnvVar extends Instruction {
     const memory = context.machineState.memory;
     const addressing = Addressing.fromWire(this.indirect);
 
-    context.machineState.consumeGas(this.gasCost());
+    context.machineState.consumeGas(
+      this.baseGasCost(addressing.indirectOperandsCount(), addressing.relativeOperandsCount()),
+    );
 
     if (!(this.varEnum in EnvironmentVariable)) {
       throw new InstructionExecutionError(`Invalid GETENVVAR var enum ${this.varEnum}`);

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

@@ -32,11 +32,15 @@ abstract class ExternalCall extends Instruction {
     const memory = context.machineState.memory;
     const addressing = Addressing.fromWire(this.indirect);
 
+    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);
-    // TODO: Should be U32
-    memory.checkTags(TypeTag.FIELD, l2GasOffset);
-    memory.checkTags(TypeTag.FIELD, daGasOffset);
+
+    memory.checkTags(TypeTag.UINT32, l2GasOffset);
+    memory.checkTags(TypeTag.UINT32, daGasOffset);
     memory.checkTag(TypeTag.FIELD, addrOffset);
     memory.checkTag(TypeTag.UINT32, argsSizeOffset);
 
@@ -48,9 +52,7 @@ abstract class ExternalCall extends Instruction {
     // 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.
@@ -179,12 +181,15 @@ export class Return extends Instruction {
     const memory = context.machineState.memory;
     const addressing = Addressing.fromWire(this.indirect);
 
+    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());
 
@@ -225,12 +230,15 @@ export class Revert extends Instruction {
     const memory = context.machineState.memory;
     const addressing = Addressing.fromWire(this.indirect);
 
+    context.machineState.consumeGas(
+      this.baseGasCost(addressing.indirectOperandsCount(), addressing.relativeOperandsCount()),
+    );
+
     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());
 
     context.machineState.revert(output);

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

@@ -31,7 +31,9 @@ export class Poseidon2 extends Instruction {
     const memory = context.machineState.memory;
     const addressing = Addressing.fromWire(this.indirect);
 
-    context.machineState.consumeGas(this.gasCost());
+    context.machineState.consumeGas(
+      this.baseGasCost(addressing.indirectOperandsCount(), addressing.relativeOperandsCount()),
+    );
 
     const operands = [this.inputStateOffset, this.outputStateOffset];
 
@@ -74,9 +76,12 @@ export class KeccakF1600 extends Instruction {
     const memory = context.machineState.memory;
     const addressing = Addressing.fromWire(this.indirect);
 
+    context.machineState.consumeGas(
+      this.baseGasCost(addressing.indirectOperandsCount(), addressing.relativeOperandsCount()),
+    );
+
     const operands = [this.dstOffset, this.inputOffset];
     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);
@@ -117,11 +122,14 @@ export class Sha256Compression extends Instruction {
     const memory = context.machineState.memory;
     const addressing = Addressing.fromWire(this.indirect);
 
+    context.machineState.consumeGas(
+      this.baseGasCost(addressing.indirectOperandsCount(), addressing.relativeOperandsCount()),
+    );
+
     const operands = [this.outputOffset, this.stateOffset, this.inputsOffset];
     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()));
 

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

@@ -3,7 +3,7 @@ import type { Bufferable } from '@aztec/foundation/serialize';
 import { strict as assert } from 'assert';
 
 import type { AvmContext } from '../avm_context.js';
-import { type Gas, getBaseGasCost, getDynamicGasCost, mulGas, sumGas } from '../avm_gas.js';
+import { type Gas, computeAddressingCost, getBaseGasCost, getDynamicGasCost, mulGas, sumGas } from '../avm_gas.js';
 import type { BufferCursor } from '../serialization/buffer_cursor.js';
 import { Opcode, type OperandType, deserialize, serializeAs } from '../serialization/instruction_serialization.js';
 
@@ -92,13 +92,20 @@ export abstract class Instruction {
   }
 
   /**
-   * Computes gas cost for the instruction based on its base cost and memory operations.
-   * @returns Gas cost.
+   * Returns the base gas cost for the instruction.
+   * @returns The base gas cost.
    */
-  protected gasCost(dynMultiplier: number = 0): Gas {
-    const baseGasCost = getBaseGasCost(this.opcode);
-    const dynGasCost = mulGas(getDynamicGasCost(this.opcode), dynMultiplier);
-    return sumGas(baseGasCost, dynGasCost);
+  protected baseGasCost(indirectOperandsCount: number, relativeOperandsCount: number): Gas {
+    return sumGas(getBaseGasCost(this.opcode), computeAddressingCost(indirectOperandsCount, relativeOperandsCount));
+  }
+
+  /**
+   * Computes the dynamic gas cost for the instruction
+   * @param dynMultiplier - The multiplier for the dynamic gas cost.
+   * @returns The dynamic gas cost.
+   */
+  protected dynamicGasCost(dynMultiplier: number = 0): Gas {
+    return mulGas(getDynamicGasCost(this.opcode), dynMultiplier);
   }
 
   /**