@aztec/simulator 0.42.0 → 0.43.0

package/src/acvm/oracle/typed_oracle.ts

@@ -184,15 +184,31 @@ export abstract class TypedOracle {
     throw new OracleMethodNotAvailableError('storageWrite');
   }
 
-  emitEncryptedLog(_contractAddress: AztecAddress, _randomness: Fr, _encryptedNote: Buffer, _counter: number): void {
-    throw new OracleMethodNotAvailableError('emitEncryptedLog');
+  emitEncryptedEventLog(
+    _contractAddress: AztecAddress,
+    _randomness: Fr,
+    _encryptedEvent: Buffer,
+    _counter: number,
+  ): void {
+    throw new OracleMethodNotAvailableError('emitEncryptedEventLog');
   }
 
   emitEncryptedNoteLog(_noteHashCounter: number, _encryptedNote: Buffer, _counter: number): void {
     throw new OracleMethodNotAvailableError('emitEncryptedNoteLog');
   }
 
-  computeEncryptedLog(
+  computeEncryptedEventLog(
+    _contractAddress: AztecAddress,
+    _randomness: Fr,
+    _eventTypeId: Fr,
+    _ovKeys: KeyValidationRequest,
+    _ivpkM: PublicKey,
+    _preimage: Fr[],
+  ): Buffer {
+    throw new OracleMethodNotAvailableError('computeEncryptedEventLog');
+  }
+
+  computeEncryptedNoteLog(
     _contractAddress: AztecAddress,
     _storageSlot: Fr,
     _noteTypeId: Fr,
@@ -200,7 +216,7 @@ export abstract class TypedOracle {
     _ivpkM: PublicKey,
     _preimage: Fr[],
   ): Buffer {
-    throw new OracleMethodNotAvailableError('computeEncryptedLog');
+    throw new OracleMethodNotAvailableError('computeEncryptedNoteLog');
   }
 
   emitUnencryptedLog(_log: UnencryptedL2Log, _counter: number): void {

package/src/avm/avm_gas.ts

@@ -122,6 +122,8 @@ const BaseGasCosts: Record<Opcode, Gas> = {
   [Opcode.POSEIDON2]: DefaultBaseGasCost,
   [Opcode.SHA256]: DefaultBaseGasCost,
   [Opcode.PEDERSEN]: DefaultBaseGasCost,
+  [Opcode.ECADD]: DefaultBaseGasCost,
+  [Opcode.MSM]: DefaultBaseGasCost,
   // Conversions
   [Opcode.TORADIXLE]: DefaultBaseGasCost,
 };

package/src/avm/avm_memory_types.ts

@@ -298,9 +298,7 @@ export class TaggedMemory implements TaggedMemoryInterface {
   }
 
   public checkIsValidMemoryOffsetTag(offset: number) {
-    if (this.getTag(offset) > TypeTag.UINT64) {
-      throw TagCheckError.forOffset(offset, TypeTag[this.getTag(offset)], 'UINT64');
-    }
+    this.checkTag(TypeTag.UINT32, offset);
   }
 
   public static checkIsIntegralTag(tag: TypeTag) {

package/src/avm/fixtures/index.ts

@@ -3,7 +3,8 @@ import { FunctionSelector } from '@aztec/foundation/abi';
 import { AztecAddress } from '@aztec/foundation/aztec-address';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { Fr } from '@aztec/foundation/fields';
-import { AvmNestedCallsTestContractArtifact, AvmTestContractArtifact } from '@aztec/noir-contracts.js';
+import { AvmTestContractArtifact } from '@aztec/noir-contracts.js';
+import { SerializableContractInstance } from '@aztec/types/contracts';
 
 import { strict as assert } from 'assert';
 import { mock } from 'jest-mock-extended';
@@ -16,6 +17,7 @@ import { AvmMachineState } from '../avm_machine_state.js';
 import { Field, Uint8 } from '../avm_memory_types.js';
 import { HostStorage } from '../journal/host_storage.js';
 import { AvmPersistableStateManager } from '../journal/journal.js';
+import { type TracedContractInstance } from '../journal/trace_types.js';
 
 /**
  * Create a new AVM context with default values.
@@ -137,11 +139,13 @@ export function getAvmTestContractBytecode(functionName: string): Buffer {
   return artifact.bytecode;
 }
 
-export function getAvmNestedCallsTestContractBytecode(functionName: string): Buffer {
-  const artifact = AvmNestedCallsTestContractArtifact.functions.find(f => f.name === functionName)!;
-  assert(
-    !!artifact?.bytecode,
-    `No bytecode found for function ${functionName}. Try re-running bootstrap.sh on the repository root.`,
-  );
-  return artifact.bytecode;
+export function randomTracedContractInstance(): TracedContractInstance {
+  const instance = SerializableContractInstance.random();
+  const address = AztecAddress.random();
+  return { exists: true, ...instance, address };
+}
+
+export function emptyTracedContractInstance(withAddress?: AztecAddress): TracedContractInstance {
+  const instance = SerializableContractInstance.empty().withAddress(withAddress ?? AztecAddress.zero());
+  return { exists: false, ...instance };
 }

package/src/avm/journal/journal.ts

@@ -14,6 +14,7 @@ import {
 import { EventSelector } from '@aztec/foundation/abi';
 import { Fr } from '@aztec/foundation/fields';
 import { type DebugLogger, createDebugLogger } from '@aztec/foundation/log';
+import { SerializableContractInstance } from '@aztec/types/contracts';
 
 import { type PublicExecutionResult } from '../../index.js';
 import { type HostStorage } from './host_storage.js';
@@ -21,6 +22,7 @@ import { Nullifiers } from './nullifiers.js';
 import { PublicStorage } from './public_storage.js';
 import { WorldStateAccessTrace } from './trace.js';
 import {
+  type TracedContractInstance,
   type TracedL1toL2MessageCheck,
   type TracedNoteHash,
   type TracedNoteHashCheck,
@@ -55,7 +57,7 @@ export type JournalData = {
 };
 
 // TRANSITIONAL: This should be removed once the kernel handles and entire enqueued call per circuit
-type PartialPublicExecutionResult = {
+export type PartialPublicExecutionResult = {
   noteHashReadRequests: ReadRequest[];
   nullifierReadRequests: ReadRequest[];
   nullifierNonExistentReadRequests: ReadRequest[];
@@ -147,15 +149,6 @@ export class AvmPersistableStateManager {
     this.publicStorage.write(storageAddress, slot, value);
 
     // TRANSITIONAL: This should be removed once the kernel handles and entire enqueued call per circuit
-    // The current info to the kernel clears any previous read or write request.
-    this.transitionalExecutionResult.contractStorageReads =
-      this.transitionalExecutionResult.contractStorageReads.filter(
-        read => !read.storageSlot.equals(slot) || !read.contractAddress!.equals(storageAddress),
-      );
-    this.transitionalExecutionResult.contractStorageUpdateRequests =
-      this.transitionalExecutionResult.contractStorageUpdateRequests.filter(
-        update => !update.storageSlot.equals(slot) || !update.contractAddress!.equals(storageAddress),
-      );
     this.transitionalExecutionResult.contractStorageUpdateRequests.push(
       new ContractStorageUpdateRequest(slot, value, this.trace.accessCounter, storageAddress),
     );
@@ -178,17 +171,9 @@ export class AvmPersistableStateManager {
     );
 
     // TRANSITIONAL: This should be removed once the kernel handles and entire enqueued call per circuit
-    // The current info to the kernel kernel does not consider cached reads.
-    if (!cached) {
-      // The current info to the kernel removes any previous reads to the same slot.
-      this.transitionalExecutionResult.contractStorageReads =
-        this.transitionalExecutionResult.contractStorageReads.filter(
-          read => !read.storageSlot.equals(slot) || !read.contractAddress!.equals(storageAddress),
-        );
-      this.transitionalExecutionResult.contractStorageReads.push(
-        new ContractStorageRead(slot, value, this.trace.accessCounter, storageAddress),
-      );
-    }
+    this.transitionalExecutionResult.contractStorageReads.push(
+      new ContractStorageRead(slot, value, this.trace.accessCounter, storageAddress),
+    );
 
     // We want to keep track of all performed reads (even reverted ones)
     this.trace.tracePublicStorageRead(storageAddress, slot, value, exists, cached);
@@ -208,6 +193,10 @@ export class AvmPersistableStateManager {
     const gotLeafIndex = await this.hostStorage.commitmentsDb.getCommitmentIndex(noteHash);
     const exists = gotLeafIndex === leafIndex.toBigInt();
     this.log.debug(`noteHashes(${storageAddress})@${noteHash} ?? leafIndex: ${leafIndex}, exists: ${exists}.`);
+
+    // TODO: include exists here also - This can for sure come from the trace???
+    this.transitionalExecutionResult.noteHashReadRequests.push(new ReadRequest(noteHash, this.trace.accessCounter));
+
     this.trace.traceNoteHashCheck(storageAddress, noteHash, exists, leafIndex);
     return Promise.resolve(exists);
   }
@@ -279,6 +268,9 @@ export class AvmPersistableStateManager {
     this.log.debug(
       `l1ToL2Messages(@${msgLeafIndex}) ?? exists: ${exists}, expected: ${msgHash}, found: ${valueAtIndex}.`,
     );
+
+    this.transitionalExecutionResult.l1ToL2MsgReadRequests.push(new ReadRequest(msgHash, this.trace.accessCounter));
+
     this.trace.traceL1ToL2MessageCheck(msgHash, msgLeafIndex, exists);
     return Promise.resolve(exists);
   }
@@ -322,6 +314,19 @@ export class AvmPersistableStateManager {
     this.trace.traceNewLog(logHash);
   }
 
+  public async getContractInstance(contractAddress: Fr): Promise<TracedContractInstance> {
+    let exists = true;
+    const aztecAddress = AztecAddress.fromField(contractAddress);
+    let instance = await this.hostStorage.contractsDb.getContractInstance(aztecAddress);
+    if (instance === undefined) {
+      instance = SerializableContractInstance.empty().withAddress(aztecAddress);
+      exists = false;
+    }
+    const tracedInstance = { ...instance, exists };
+    this.trace.traceGetContractInstance(tracedInstance);
+    return Promise.resolve(tracedInstance);
+  }
+
   /**
    * Accept nested world state modifications, merging in its trace and accrued substate
    */

package/src/avm/journal/trace.ts

@@ -1,7 +1,7 @@
-import { AvmExecutionHints, AvmHint, Vector } from '@aztec/circuits.js';
 import { Fr } from '@aztec/foundation/fields';
 
 import {
+  type TracedContractInstance,
   type TracedL1toL2MessageCheck,
   type TracedNoteHash,
   type TracedNoteHashCheck,
@@ -24,6 +24,7 @@ export class WorldStateAccessTrace {
   public newNullifiers: TracedNullifier[] = [];
   public l1ToL2MessageChecks: TracedL1toL2MessageCheck[] = [];
   public newLogsHashes: TracedUnencryptedL2Log[] = [];
+  public gotContractInstances: TracedContractInstance[] = [];
 
   //public contractCalls: TracedContractCall[] = [];
   //public archiveChecks: TracedArchiveLeafCheck[] = [];
@@ -148,6 +149,11 @@ export class WorldStateAccessTrace {
     this.incrementAccessCounter();
   }
 
+  public traceGetContractInstance(instance: TracedContractInstance) {
+    this.gotContractInstances.push(instance);
+    this.incrementAccessCounter();
+  }
+
   private incrementAccessCounter() {
     this.accessCounter++;
   }
@@ -168,17 +174,8 @@ export class WorldStateAccessTrace {
     this.newNullifiers.push(...incomingTrace.newNullifiers);
     this.l1ToL2MessageChecks.push(...incomingTrace.l1ToL2MessageChecks);
     this.newLogsHashes.push(...incomingTrace.newLogsHashes);
+    this.gotContractInstances.push(...incomingTrace.gotContractInstances);
     // it is assumed that the incoming trace was initialized with this as parent, so accept counter
     this.accessCounter = incomingTrace.accessCounter;
   }
-
-  // TODO(dbanks12): should only return hints for one call.... shouldn't include nested calls (merged in traces)
-  public toHints(): AvmExecutionHints {
-    return new AvmExecutionHints(
-      new Vector(this.publicStorageReads.map(read => new AvmHint(read.counter, read.value))),
-      new Vector(this.noteHashChecks.map(check => new AvmHint(check.counter, new Fr(check.exists ? 1 : 0)))),
-      new Vector(this.nullifierChecks.map(check => new AvmHint(check.counter, new Fr(check.exists ? 1 : 0)))),
-      new Vector(this.l1ToL2MessageChecks.map(check => new AvmHint(check.counter, new Fr(check.exists ? 1 : 0)))),
-    );
-  }
 }

package/src/avm/journal/trace_types.ts

@@ -1,4 +1,5 @@
 import { type Fr } from '@aztec/foundation/fields';
+import { type ContractInstanceWithAddress } from '@aztec/types/contracts';
 
 //export type TracedContractCall = {
 //  callPointer: Fr;
@@ -86,3 +87,5 @@ export type TracedUnencryptedL2Log = {
 //  leafIndex: Fr;
 //  leaf: Fr;
 //};
+
+export type TracedContractInstance = { exists: boolean } & ContractInstanceWithAddress;

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,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) {