@aztec/simulator 0.41.0 → 0.43.0

package/src/avm/opcodes/accrued_substate.ts

@@ -1,5 +1,5 @@
 import type { AvmContext } from '../avm_context.js';
-import { Uint8 } from '../avm_memory_types.js';
+import { TypeTag, Uint8 } from '../avm_memory_types.js';
 import { InstructionExecutionError, StaticCallAlterationError } from '../errors.js';
 import { NullifierCollisionError } from '../journal/nullifiers.js';
 import { Opcode, OperandType } from '../serialization/instruction_serialization.js';
@@ -31,17 +31,22 @@ export class NoteHashExists extends Instruction {
     const memoryOperations = { reads: 2, writes: 1, indirect: this.indirect };
     const memory = context.machineState.memory.track(this.type);
     context.machineState.consumeGas(this.gasCost(memoryOperations));
+    const [noteHashOffset, leafIndexOffset, existsOffset] = Addressing.fromWire(this.indirect).resolve(
+      [this.noteHashOffset, this.leafIndexOffset, this.existsOffset],
+      memory,
+    );
+    memory.checkTags(TypeTag.FIELD, noteHashOffset, leafIndexOffset);
 
     // Note that this instruction accepts any type in memory, and converts to Field.
-    const noteHash = memory.get(this.noteHashOffset).toFr();
-    const leafIndex = memory.get(this.leafIndexOffset).toFr();
+    const noteHash = memory.get(noteHashOffset).toFr();
+    const leafIndex = memory.get(leafIndexOffset).toFr();
 
     const exists = await context.persistableState.checkNoteHashExists(
       context.environment.storageAddress,
       noteHash,
       leafIndex,
     );
-    memory.set(this.existsOffset, exists ? new Uint8(1) : new Uint8(0));
+    memory.set(existsOffset, exists ? new Uint8(1) : new Uint8(0));
 
     memory.assert(memoryOperations);
     context.machineState.incrementPc();
@@ -63,11 +68,14 @@ export class EmitNoteHash extends Instruction {
     const memory = context.machineState.memory.track(this.type);
     context.machineState.consumeGas(this.gasCost(memoryOperations));
 
+    const [noteHashOffset] = Addressing.fromWire(this.indirect).resolve([this.noteHashOffset], memory);
+    memory.checkTag(TypeTag.FIELD, noteHashOffset);
+
     if (context.environment.isStaticCall) {
       throw new StaticCallAlterationError();
     }
 
-    const noteHash = memory.get(this.noteHashOffset).toFr();
+    const noteHash = memory.get(noteHashOffset).toFr();
     context.persistableState.writeNoteHash(context.environment.storageAddress, noteHash);
 
     memory.assert(memoryOperations);
@@ -101,11 +109,17 @@ export class NullifierExists extends Instruction {
     const memory = context.machineState.memory.track(this.type);
     context.machineState.consumeGas(this.gasCost(memoryOperations));
 
-    const nullifier = memory.get(this.nullifierOffset).toFr();
-    const address = memory.get(this.addressOffset).toFr();
+    const [nullifierOffset, addressOffset, existsOffset] = Addressing.fromWire(this.indirect).resolve(
+      [this.nullifierOffset, this.addressOffset, this.existsOffset],
+      memory,
+    );
+    memory.checkTags(TypeTag.FIELD, nullifierOffset, addressOffset);
+
+    const nullifier = memory.get(nullifierOffset).toFr();
+    const address = memory.get(addressOffset).toFr();
     const exists = await context.persistableState.checkNullifierExists(address, nullifier);
 
-    memory.set(this.existsOffset, exists ? new Uint8(1) : new Uint8(0));
+    memory.set(existsOffset, exists ? new Uint8(1) : new Uint8(0));
 
     memory.assert(memoryOperations);
     context.machineState.incrementPc();
@@ -131,7 +145,10 @@ export class EmitNullifier extends Instruction {
     const memory = context.machineState.memory.track(this.type);
     context.machineState.consumeGas(this.gasCost(memoryOperations));
 
-    const nullifier = memory.get(this.nullifierOffset).toFr();
+    const [nullifierOffset] = Addressing.fromWire(this.indirect).resolve([this.nullifierOffset], memory);
+    memory.checkTag(TypeTag.FIELD, nullifierOffset);
+
+    const nullifier = memory.get(nullifierOffset).toFr();
     try {
       await context.persistableState.writeNullifier(context.environment.storageAddress, nullifier);
     } catch (e) {
@@ -176,10 +193,16 @@ export class L1ToL2MessageExists extends Instruction {
     const memory = context.machineState.memory.track(this.type);
     context.machineState.consumeGas(this.gasCost(memoryOperations));
 
-    const msgHash = memory.get(this.msgHashOffset).toFr();
-    const msgLeafIndex = memory.get(this.msgLeafIndexOffset).toFr();
+    const [msgHashOffset, msgLeafIndexOffset, existsOffset] = Addressing.fromWire(this.indirect).resolve(
+      [this.msgHashOffset, this.msgLeafIndexOffset, this.existsOffset],
+      memory,
+    );
+    memory.checkTags(TypeTag.FIELD, msgHashOffset, msgLeafIndexOffset);
+
+    const msgHash = memory.get(msgHashOffset).toFr();
+    const msgLeafIndex = memory.get(msgLeafIndexOffset).toFr();
     const exists = await context.persistableState.checkL1ToL2MessageExists(msgHash, msgLeafIndex);
-    memory.set(this.existsOffset, exists ? new Uint8(1) : new Uint8(0));
+    memory.set(existsOffset, exists ? new Uint8(1) : new Uint8(0));
 
     memory.assert(memoryOperations);
     context.machineState.incrementPc();
@@ -202,7 +225,7 @@ export class EmitUnencryptedLog extends Instruction {
     private indirect: number,
     private eventSelectorOffset: number,
     private logOffset: number,
-    private logSize: number,
+    private logSizeOffset: number,
   ) {
     super();
   }
@@ -212,18 +235,23 @@ export class EmitUnencryptedLog extends Instruction {
       throw new StaticCallAlterationError();
     }
 
-    const memoryOperations = { reads: 1 + this.logSize, indirect: this.indirect };
     const memory = context.machineState.memory.track(this.type);
-    context.machineState.consumeGas(this.gasCost(memoryOperations));
 
-    const [eventSelectorOffset, logOffset] = Addressing.fromWire(this.indirect).resolve(
-      [this.eventSelectorOffset, this.logOffset],
+    const [eventSelectorOffset, logOffset, logSizeOffset] = Addressing.fromWire(this.indirect).resolve(
+      [this.eventSelectorOffset, this.logOffset, this.logSizeOffset],
       memory,
     );
+    memory.checkTag(TypeTag.FIELD, eventSelectorOffset);
+    memory.checkTag(TypeTag.UINT32, logSizeOffset);
+    const logSize = memory.get(logSizeOffset).toNumber();
+    memory.checkTagsRange(TypeTag.FIELD, logOffset, logSize);
 
     const contractAddress = context.environment.address;
     const event = memory.get(eventSelectorOffset).toFr();
-    const log = memory.getSlice(logOffset, this.logSize).map(f => f.toFr());
+
+    const memoryOperations = { reads: 2 + logSize, indirect: this.indirect };
+    context.machineState.consumeGas(this.gasCost(memoryOperations));
+    const log = memory.getSlice(logOffset, logSize).map(f => f.toFr());
     context.persistableState.writeLog(contractAddress, event, log);
 
     memory.assert(memoryOperations);
@@ -250,8 +278,13 @@ export class SendL2ToL1Message extends Instruction {
     const memory = context.machineState.memory.track(this.type);
     context.machineState.consumeGas(this.gasCost(memoryOperations));
 
-    const recipient = memory.get(this.recipientOffset).toFr();
-    const content = memory.get(this.contentOffset).toFr();
+    const [recipientOffset, contentOffset] = Addressing.fromWire(this.indirect).resolve(
+      [this.recipientOffset, this.contentOffset],
+      memory,
+    );
+
+    const recipient = memory.get(recipientOffset).toFr();
+    const content = memory.get(contentOffset).toFr();
     context.persistableState.writeL1Message(recipient, content);
 
     memory.assert(memoryOperations);

package/src/avm/opcodes/arithmetic.ts

@@ -1,7 +1,7 @@
 import type { AvmContext } from '../avm_context.js';
-import { getBaseGasCost, getGasCostForTypeTag, getMemoryGasCost, sumGas } from '../avm_gas.js';
-import { type Field, type MemoryOperations, type MemoryValue, TypeTag } from '../avm_memory_types.js';
+import { type Field, type MemoryValue, TypeTag } 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 { ThreeOperandInstruction } from './instruction_impl.js';
 
@@ -11,24 +11,22 @@ export abstract class ThreeOperandArithmeticInstruction extends ThreeOperandInst
     const memory = context.machineState.memory.track(this.type);
     context.machineState.consumeGas(this.gasCost(memoryOperations));
 
-    memory.checkTags(this.inTag, this.aOffset, this.bOffset);
+    const [aOffset, bOffset, dstOffset] = Addressing.fromWire(this.indirect).resolve(
+      [this.aOffset, this.bOffset, this.dstOffset],
+      memory,
+    );
+    memory.checkTags(this.inTag, aOffset, bOffset);
 
-    const a = memory.get(this.aOffset);
-    const b = memory.get(this.bOffset);
+    const a = memory.get(aOffset);
+    const b = memory.get(bOffset);
 
     const dest = this.compute(a, b);
-    memory.set(this.dstOffset, dest);
+    memory.set(dstOffset, dest);
 
     memory.assert(memoryOperations);
     context.machineState.incrementPc();
   }
 
-  protected override gasCost(memoryOps: Partial<MemoryOperations & { indirect: number }>) {
-    const baseGasCost = getGasCostForTypeTag(this.inTag, getBaseGasCost(this.opcode));
-    const memoryGasCost = getMemoryGasCost(memoryOps);
-    return sumGas(baseGasCost, memoryGasCost);
-  }
-
   protected abstract compute(a: MemoryValue, b: MemoryValue): MemoryValue;
 }
 
@@ -90,21 +88,19 @@ export class FieldDiv extends Instruction {
     const memory = context.machineState.memory.track(this.type);
     context.machineState.consumeGas(this.gasCost(memoryOperations));
 
-    memory.checkTags(TypeTag.FIELD, this.aOffset, this.bOffset);
+    const [aOffset, bOffset, dstOffset] = Addressing.fromWire(this.indirect).resolve(
+      [this.aOffset, this.bOffset, this.dstOffset],
+      memory,
+    );
+    memory.checkTags(TypeTag.FIELD, aOffset, bOffset);
 
-    const a = memory.getAs<Field>(this.aOffset);
-    const b = memory.getAs<Field>(this.bOffset);
+    const a = memory.getAs<Field>(aOffset);
+    const b = memory.getAs<Field>(bOffset);
 
     const dest = a.fdiv(b);
-    memory.set(this.dstOffset, dest);
+    memory.set(dstOffset, dest);
 
     memory.assert(memoryOperations);
     context.machineState.incrementPc();
   }
-
-  protected override gasCost(memoryOps: Partial<MemoryOperations & { indirect: number }>) {
-    const baseGasCost = getGasCostForTypeTag(TypeTag.FIELD, getBaseGasCost(this.opcode));
-    const memoryGasCost = getMemoryGasCost(memoryOps);
-    return sumGas(baseGasCost, memoryGasCost);
-  }
 }

package/src/avm/opcodes/bitwise.ts

@@ -1,6 +1,7 @@
 import type { AvmContext } from '../avm_context.js';
 import { type IntegralValue, type TaggedMemoryInterface, TypeTag } from '../avm_memory_types.js';
 import { Opcode } from '../serialization/instruction_serialization.js';
+import { Addressing } from './addressing_mode.js';
 import { ThreeOperandInstruction, TwoOperandInstruction } from './instruction_impl.js';
 
 abstract class ThreeOperandBitwiseInstruction extends ThreeOperandInstruction {
@@ -9,13 +10,17 @@ abstract class ThreeOperandBitwiseInstruction extends ThreeOperandInstruction {
     const memory = context.machineState.memory.track(this.type);
     context.machineState.consumeGas(this.gasCost(memoryOperations));
 
-    this.checkTags(memory, this.inTag, this.aOffset, this.bOffset);
+    const [aOffset, bOffset, dstOffset] = Addressing.fromWire(this.indirect).resolve(
+      [this.aOffset, this.bOffset, this.dstOffset],
+      memory,
+    );
+    this.checkTags(memory, this.inTag, aOffset, bOffset);
 
-    const a = memory.getAs<IntegralValue>(this.aOffset);
-    const b = memory.getAs<IntegralValue>(this.bOffset);
+    const a = memory.getAs<IntegralValue>(aOffset);
+    const b = memory.getAs<IntegralValue>(bOffset);
 
     const res = this.compute(a, b);
-    memory.set(this.dstOffset, res);
+    memory.set(dstOffset, res);
 
     memory.assert(memoryOperations);
     context.machineState.incrementPc();
@@ -93,12 +98,12 @@ export class Not extends TwoOperandInstruction {
     const memory = context.machineState.memory.track(this.type);
     context.machineState.consumeGas(this.gasCost(memoryOperations));
 
-    memory.checkTags(this.inTag, this.aOffset);
-
-    const a = memory.getAs<IntegralValue>(this.aOffset);
+    const [aOffset, dstOffset] = Addressing.fromWire(this.indirect).resolve([this.aOffset, this.dstOffset], memory);
+    memory.checkTags(this.inTag, aOffset);
+    const a = memory.getAs<IntegralValue>(aOffset);
 
     const res = a.not();
-    memory.set(this.dstOffset, res);
+    memory.set(dstOffset, res);
 
     memory.assert(memoryOperations);
     context.machineState.incrementPc();

package/src/avm/opcodes/comparators.ts

@@ -1,6 +1,7 @@
 import type { AvmContext } from '../avm_context.js';
 import { type MemoryValue, Uint8 } from '../avm_memory_types.js';
 import { Opcode } from '../serialization/instruction_serialization.js';
+import { Addressing } from './addressing_mode.js';
 import { ThreeOperandInstruction } from './instruction_impl.js';
 
 abstract class ComparatorInstruction extends ThreeOperandInstruction {
@@ -9,13 +10,17 @@ abstract class ComparatorInstruction extends ThreeOperandInstruction {
     const memory = context.machineState.memory.track(this.type);
     context.machineState.consumeGas(this.gasCost(memoryOperations));
 
-    memory.checkTags(this.inTag, this.aOffset, this.bOffset);
+    const [aOffset, bOffset, dstOffset] = Addressing.fromWire(this.indirect).resolve(
+      [this.aOffset, this.bOffset, this.dstOffset],
+      memory,
+    );
+    memory.checkTags(this.inTag, aOffset, bOffset);
 
-    const a = memory.get(this.aOffset);
-    const b = memory.get(this.bOffset);
+    const a = memory.get(aOffset);
+    const b = memory.get(bOffset);
 
     const dest = new Uint8(this.compare(a, b) ? 1 : 0);
-    memory.set(this.dstOffset, dest);
+    memory.set(dstOffset, dest);
 
     memory.assert(memoryOperations);
     context.machineState.incrementPc();

package/src/avm/opcodes/contract.ts

@@ -1,7 +1,7 @@
-import { AztecAddress, Fr } from '@aztec/circuits.js';
+import { Fr } from '@aztec/circuits.js';
 
 import type { AvmContext } from '../avm_context.js';
-import { Field } from '../avm_memory_types.js';
+import { Field, TypeTag } from '../avm_memory_types.js';
 import { Opcode, OperandType } from '../serialization/instruction_serialization.js';
 import { Addressing } from './addressing_mode.js';
 import { Instruction } from './instruction.js';
@@ -22,35 +22,31 @@ export class GetContractInstance extends Instruction {
   }
 
   async execute(context: AvmContext): Promise<void> {
+    const memoryOperations = { reads: 1, writes: 6, indirect: this.indirect };
+    const memory = context.machineState.memory.track(this.type);
+    context.machineState.consumeGas(this.gasCost(memoryOperations));
+
     const [addressOffset, dstOffset] = Addressing.fromWire(this.indirect).resolve(
       [this.addressOffset, this.dstOffset],
-      context.machineState.memory,
+      memory,
     );
+    memory.checkTag(TypeTag.FIELD, addressOffset);
+
+    const address = memory.get(addressOffset).toFr();
+    const instance = await context.persistableState.getContractInstance(address);
+
+    const data = [
+      new Fr(instance.exists),
+      instance.salt,
+      instance.deployer.toField(),
+      instance.contractClassId,
+      instance.initializationHash,
+      instance.publicKeysHash,
+    ].map(f => new Field(f));
 
-    const address = AztecAddress.fromField(context.machineState.memory.get(addressOffset).toFr());
-    const instance = await context.persistableState.hostStorage.contractsDb.getContractInstance(address);
-
-    const data =
-      instance === undefined
-        ? [
-            new Field(0), // not found
-            new Field(0),
-            new Field(0),
-            new Field(0),
-            new Field(0),
-            new Field(0),
-          ]
-        : [
-            new Fr(1), // found
-            instance.salt,
-            instance.deployer.toField(),
-            instance.contractClassId,
-            instance.initializationHash,
-            instance.publicKeysHash,
-          ].map(f => new Field(f));
-
-    context.machineState.memory.setSlice(dstOffset, data);
+    memory.setSlice(dstOffset, data);
 
+    memory.assert(memoryOperations);
     context.machineState.incrementPc();
   }
 }

package/src/avm/opcodes/control_flow.ts

@@ -2,6 +2,7 @@ import type { AvmContext } from '../avm_context.js';
 import { type IntegralValue } 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';
 
 export class Jump extends Instruction {
@@ -44,7 +45,8 @@ export class JumpI extends Instruction {
     const memory = context.machineState.memory.track(this.type);
     context.machineState.consumeGas(this.gasCost(memoryOperations));
 
-    const condition = memory.getAs<IntegralValue>(this.condOffset);
+    const [condOffset] = Addressing.fromWire(this.indirect).resolve([this.condOffset], memory);
+    const condition = memory.getAs<IntegralValue>(condOffset);
 
     // TODO: reconsider this casting
     if (condition.toBigInt() == 0n) {

package/src/avm/opcodes/conversion.ts

@@ -50,7 +50,7 @@ export class ToRadixLE extends Instruction {
       value /= radixBN;
     }
 
-    const res = [...limbArray].map(byte => new Uint8(byte));
+    const res = limbArray.map(byte => new Uint8(byte));
     memory.setSlice(dstOffset, res);
 
     memory.assert(memoryOperations);

package/src/avm/opcodes/ec_add.ts

@@ -0,0 +1,92 @@
+import { Grumpkin } from '@aztec/circuits.js/barretenberg';
+import { Point } from '@aztec/foundation/fields';
+
+import { type AvmContext } from '../avm_context.js';
+import { Field } 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 class EcAdd extends Instruction {
+  static type: string = 'ECADD';
+  static readonly opcode = Opcode.ECADD;
+
+  // Informs (de)serialization. See Instruction.deserialize.
+  static readonly wireFormat: OperandType[] = [
+    OperandType.UINT8, // reserved
+    OperandType.UINT8, // indirect
+    OperandType.UINT32, // p1X
+    OperandType.UINT32, // p1Y
+    OperandType.UINT32, // p1IsInfinite
+    OperandType.UINT32, // p2X
+    OperandType.UINT32, // p2Y
+    OperandType.UINT32, // p2IsInfinite
+    OperandType.UINT32, // dst
+  ];
+
+  constructor(
+    private indirect: number,
+    private p1XOffset: number,
+    private p1YOffset: number,
+    private p1IsInfiniteOffset: number,
+    private p2XOffset: number,
+    private p2YOffset: number,
+    private p2IsInfiniteOffset: number,
+    private dstOffset: number,
+  ) {
+    super();
+  }
+
+  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));
+
+    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,
+      );
+
+    const p1X = memory.get(p1XOffset);
+    const p1Y = memory.get(p1YOffset);
+    const p1IsInfinite = memory.get(p1IsInfiniteOffset).toNumber() === 1;
+    const p1 = new Point(p1X.toFr(), p1Y.toFr());
+    if (!p1.isOnGrumpkin()) {
+      throw new Error(`Point1 is not on the curve`);
+    }
+
+    const p2X = memory.get(p2XOffset);
+    const p2Y = memory.get(p2YOffset);
+    // unused. Point doesn't store this information
+    const p2IsInfinite = memory.get(p2IsInfiniteOffset).toNumber() === 1;
+    const p2 = new Point(p2X.toFr(), p2Y.toFr());
+    if (!p2.isOnGrumpkin()) {
+      throw new Error(`Point1 is not on the curve`);
+    }
+
+    const grumpkin = new Grumpkin();
+    let dest = grumpkin.add(p1, p2);
+    // Temporary,
+    if (p1IsInfinite) {
+      dest = p2;
+    } else if (p2IsInfinite) {
+      dest = p1;
+    }
+    memory.set(dstOffset, new Field(dest.x));
+    memory.set(dstOffset + 1, new Field(dest.y));
+    // Check representation of infinity for grumpkin
+    memory.set(dstOffset + 2, new Field(dest.equals(Point.ZERO) ? 1 : 0));
+
+    memory.assert(memoryOperations);
+    context.machineState.incrementPc();
+  }
+}

package/src/avm/opcodes/external_calls.ts

@@ -4,7 +4,7 @@ import { padArrayEnd } from '@aztec/foundation/collection';
 import { convertAvmResultsToPxResult, createPublicExecution } from '../../public/transitional_adaptors.js';
 import type { AvmContext } from '../avm_context.js';
 import { gasLeftToGas } from '../avm_gas.js';
-import { Field, Uint8 } from '../avm_memory_types.js';
+import { Field, TypeTag, Uint8 } from '../avm_memory_types.js';
 import { type AvmContractCallResults } from '../avm_message_call_result.js';
 import { AvmSimulator } from '../avm_simulator.js';
 import { RethrownError } from '../errors.js';
@@ -53,9 +53,15 @@ abstract class ExternalCall extends Instruction {
       [this.gasOffset, this.addrOffset, this.argsOffset, this.argsSizeOffset, this.retOffset, this.successOffset],
       memory,
     );
+    memory.checkTags(TypeTag.FIELD, gasOffset, gasOffset + 1);
+    memory.checkTag(TypeTag.FIELD, addrOffset);
+    memory.checkTag(TypeTag.UINT32, argsSizeOffset);
+    memory.checkTag(TypeTag.FIELD, this.functionSelectorOffset);
 
-    const callAddress = memory.getAs<Field>(addrOffset);
     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();
     // If we are already in a static call, we propagate the environment.
@@ -86,13 +92,15 @@ abstract class ExternalCall extends Instruction {
     const startSideEffectCounter = nestedContext.persistableState.trace.accessCounter;
 
     const oldStyleExecution = createPublicExecution(startSideEffectCounter, nestedContext.environment, calldata);
-    const nestedCallResults: AvmContractCallResults = await new AvmSimulator(nestedContext).execute();
+    const simulator = new AvmSimulator(nestedContext);
+    const nestedCallResults: AvmContractCallResults = await simulator.execute();
     const pxResults = convertAvmResultsToPxResult(
       nestedCallResults,
       startSideEffectCounter,
       oldStyleExecution,
       Gas.from(allocatedGas),
       nestedContext,
+      simulator.getBytecode(),
     );
     // store the old PublicExecutionResult object to maintain a recursive data structure for the old kernel
     context.persistableState.transitionalExecutionResult.nestedExecutions.push(pxResults);

package/src/avm/opcodes/hashing.ts

@@ -1,7 +1,7 @@
 import { keccak256, pedersenHash, poseidon2Permutation, sha256 } from '@aztec/foundation/crypto';
 
 import { type AvmContext } from '../avm_context.js';
-import { Field, Uint8 } from '../avm_memory_types.js';
+import { Field, TypeTag, Uint8 } from '../avm_memory_types.js';
 import { Opcode, OperandType } from '../serialization/instruction_serialization.js';
 import { Addressing } from './addressing_mode.js';
 import { Instruction } from './instruction.js';
@@ -32,6 +32,7 @@ export class Poseidon2 extends Instruction {
       [this.inputStateOffset, this.outputStateOffset],
       memory,
     );
+    memory.checkTagsRange(TypeTag.FIELD, inputOffset, Poseidon2.stateSize);
 
     const inputState = memory.getSlice(inputOffset, Poseidon2.stateSize);
     const outputState = poseidon2Permutation(inputState);
@@ -74,10 +75,13 @@ export class Keccak extends Instruction {
       [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 messageData = Buffer.concat(memory.getSlice(messageOffset, messageSize).map(word => word.toBuffer()));
     const hashBuffer = keccak256(messageData);
 
@@ -119,9 +123,11 @@ export class Sha256 extends Instruction {
       [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 messageData = Buffer.concat(memory.getSlice(messageOffset, messageSize).map(word => word.toBuffer()));
     const hashBuffer = sha256(messageData);
@@ -168,12 +174,16 @@ export class Pedersen extends Instruction {
 
     // We hash a set of field elements
     const genIndex = Number(memory.get(genIndexOffset).toBigInt());
+    memory.checkTag(TypeTag.UINT32, genIndexOffset);
     const messageSize = Number(memory.get(messageSizeOffset).toBigInt());
+    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));
 
+    memory.checkTagsRange(TypeTag.FIELD, messageOffset, messageSize);
+
     // No domain sep for now
     const hash = pedersenHash(hashData, genIndex);
     memory.set(dstOffset, new Field(hash));

package/src/avm/opcodes/instruction.ts

@@ -1,7 +1,7 @@
 import { strict as assert } from 'assert';
 
 import type { AvmContext } from '../avm_context.js';
-import { getBaseGasCost, getMemoryGasCost, sumGas } from '../avm_gas.js';
+import { getBaseGasCost, sumGas } from '../avm_gas.js';
 import { type MemoryOperations } from '../avm_memory_types.js';
 import { type BufferCursor } from '../serialization/buffer_cursor.js';
 import { Opcode, type OperandType, deserialize, serialize } from '../serialization/instruction_serialization.js';
@@ -67,9 +67,11 @@ export abstract class Instruction {
    * @param memoryOps Memory operations performed by the instruction.
    * @returns Gas cost.
    */
-  protected gasCost(memoryOps: Partial<MemoryOperations & { indirect: number }> = {}) {
+  protected gasCost(_memoryOps: Partial<MemoryOperations & { indirect: number }> = {}) {
     const baseGasCost = getBaseGasCost(this.opcode);
-    const memoryGasCost = getMemoryGasCost(memoryOps);
+    // TODO(https://github.com/AztecProtocol/aztec-packages/issues/6861): reconsider.
+    // const memoryGasCost = getMemoryGasCost(memoryOps);
+    const memoryGasCost = { l2Gas: 0, daGas: 0 };
     return sumGas(baseGasCost, memoryGasCost);
   }
 

package/src/avm/opcodes/instruction_impl.ts

@@ -1,6 +1,7 @@
 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. */
@@ -72,7 +73,9 @@ export abstract class GetterInstruction extends Instruction {
     const memory = context.machineState.memory.track(this.type);
     context.machineState.consumeGas(this.gasCost(memoryOperations));
 
-    memory.set(this.dstOffset, this.getValue(context));
+    const [dstOffset] = Addressing.fromWire(this.indirect).resolve([this.dstOffset], memory);
+
+    memory.set(dstOffset, this.getValue(context));
 
     memory.assert(memoryOperations);
     context.machineState.incrementPc();