@aztec/simulator 0.42.0 → 0.44.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,20 @@ 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 exists = await context.persistableState.checkL1ToL2MessageExists(msgHash, msgLeafIndex);
-    memory.set(this.existsOffset, exists ? new Uint8(1) : new Uint8(0));
+    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(
+      context.environment.address,
+      msgHash,
+      msgLeafIndex,
+    );
+    memory.set(existsOffset, exists ? new Uint8(1) : new Uint8(0));
 
     memory.assert(memoryOperations);
     context.machineState.incrementPc();
@@ -202,7 +229,7 @@ export class EmitUnencryptedLog extends Instruction {
     private indirect: number,
     private eventSelectorOffset: number,
     private logOffset: number,
-    private logSize: number,
+    private logSizeOffset: number,
   ) {
     super();
   }
@@ -212,19 +239,24 @@ 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());
-    context.persistableState.writeLog(contractAddress, event, log);
+
+    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.writeUnencryptedLog(contractAddress, event, log);
 
     memory.assert(memoryOperations);
     context.machineState.incrementPc();
@@ -250,9 +282,14 @@ 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();
-    context.persistableState.writeL1Message(recipient, content);
+    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.writeL2ToL1Message(recipient, content);
 
     memory.assert(memoryOperations);
     context.machineState.incrementPc();

package/src/avm/opcodes/arithmetic.ts

@@ -1,6 +1,7 @@
 import type { AvmContext } from '../avm_context.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';
 
@@ -10,13 +11,17 @@ 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();
@@ -83,13 +88,17 @@ 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();

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/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

@@ -1,10 +1,9 @@
 import { FunctionSelector, Gas } from '@aztec/circuits.js';
 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';
@@ -24,7 +23,6 @@ abstract class ExternalCall extends Instruction {
     OperandType.UINT32,
     OperandType.UINT32,
     OperandType.UINT32,
-    /* temporary function selector */
     OperandType.UINT32,
   ];
 
@@ -37,8 +35,8 @@ abstract class ExternalCall extends Instruction {
     private retOffset: number,
     private retSize: number,
     private successOffset: number,
-    // Function selector is temporary since eventually public contract bytecode will be one blob
-    // containing all functions, and function selector will become an application-level mechanism
+    // NOTE: Function selector is likely temporary since eventually public contract bytecode will be one
+    // blob containing all functions, and function selector will become an application-level mechanism
     // (e.g. first few bytes of calldata + compiler-generated jump table)
     private functionSelectorOffset: number,
   ) {
@@ -53,9 +51,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.
@@ -75,7 +79,6 @@ abstract class ExternalCall extends Instruction {
     const allocatedGas = { l2Gas: allocatedL2Gas, daGas: allocatedDaGas };
     context.machineState.consumeGas(allocatedGas);
 
-    // TRANSITIONAL: This should be removed once the kernel handles and entire enqueued call per circuit
     const nestedContext = context.createNestedContractCallContext(
       callAddress.toFr(),
       calldata,
@@ -83,32 +86,9 @@ abstract class ExternalCall extends Instruction {
       callType,
       FunctionSelector.fromField(functionSelector),
     );
-    const startSideEffectCounter = nestedContext.persistableState.trace.accessCounter;
 
-    const oldStyleExecution = createPublicExecution(startSideEffectCounter, nestedContext.environment, calldata);
     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);
-    // END TRANSITIONAL
-
-    // const nestedContext = context.createNestedContractCallContext(
-    //   callAddress.toFr(),
-    //   calldata,
-    //   allocatedGas,
-    //   this.type,
-    //   FunctionSelector.fromField(functionSelector),
-    // );
-    // const nestedCallResults: AvmContractCallResults = await new AvmSimulator(nestedContext).execute();
-
     const success = !nestedCallResults.reverted;
 
     // TRANSITIONAL: We rethrow here so that the MESSAGE gets propagated.
@@ -137,12 +117,16 @@ abstract class ExternalCall extends Instruction {
     // Refund unused gas
     context.machineState.refundGas(gasLeftToGas(nestedContext.machineState));
 
-    // TODO: Should we merge the changes from a nested call in the case of a STATIC call?
-    if (success) {
-      context.persistableState.acceptNestedCallState(nestedContext.persistableState);
-    } else {
-      context.persistableState.rejectNestedCallState(nestedContext.persistableState);
-    }
+    // Accept the nested call's state and trace the nested call
+    await context.persistableState.processNestedCall(
+      /*nestedState=*/ nestedContext.persistableState,
+      /*success=*/ success,
+      /*nestedEnvironment=*/ nestedContext.environment,
+      /*startGasLeft=*/ Gas.from(allocatedGas),
+      /*endGasLeft=*/ Gas.from(nestedContext.machineState.gasLeft),
+      /*bytecode=*/ simulator.getBytecode()!,
+      /*avmCallResults=*/ nestedCallResults,
+    );
 
     memory.assert(memoryOperations);
     context.machineState.incrementPc();

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_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();