@aztec/simulator 0.63.1 → 0.65.0

package/src/avm/journal/journal.ts

@@ -1,18 +1,16 @@
-import { type IndexedTreeId, MerkleTreeId, type MerkleTreeWriteOperations } from '@aztec/circuit-types';
+import { MerkleTreeId } from '@aztec/circuit-types';
 import {
   type AztecAddress,
   type Gas,
   type NullifierLeafPreimage,
   type PublicCallRequest,
-  PublicDataTreeLeaf,
-  PublicDataTreeLeafPreimage,
+  type PublicDataTreeLeafPreimage,
   SerializableContractInstance,
   computePublicBytecodeCommitment,
 } from '@aztec/circuits.js';
 import { computePublicDataTreeLeafSlot, siloNoteHash, siloNullifier } from '@aztec/circuits.js/hash';
 import { Fr } from '@aztec/foundation/fields';
 import { createDebugLogger } from '@aztec/foundation/log';
-import { type IndexedTreeLeafPreimage } from '@aztec/foundation/trees';
 
 import assert from 'assert';
 
@@ -21,7 +19,8 @@ import { type WorldStateDB } from '../../public/public_db_sources.js';
 import { type PublicSideEffectTraceInterface } from '../../public/side_effect_trace_interface.js';
 import { type AvmContractCallResult } from '../avm_contract_call_result.js';
 import { type AvmExecutionEnvironment } from '../avm_execution_environment.js';
-import { NullifierManager } from './nullifiers.js';
+import { AvmEphemeralForest } from '../avm_tree.js';
+import { NullifierCollisionError, NullifierManager } from './nullifiers.js';
 import { PublicStorage } from './public_storage.js';
 
 /**
@@ -36,9 +35,6 @@ import { PublicStorage } from './public_storage.js';
 export class AvmPersistableStateManager {
   private readonly log = createDebugLogger('aztec:avm_simulator:state_manager');
 
-  /** Interface to perform merkle tree operations */
-  public merkleTrees: MerkleTreeWriteOperations;
-
   /** Make sure a forked state is never merged twice. */
   private alreadyMergedIntoParent = false;
 
@@ -53,29 +49,43 @@ export class AvmPersistableStateManager {
     /** Nullifier set, including cached/recently-emitted nullifiers */
     private readonly nullifiers: NullifierManager = new NullifierManager(worldStateDB),
     private readonly doMerkleOperations: boolean = false,
-    merkleTrees?: MerkleTreeWriteOperations,
-  ) {
-    if (merkleTrees) {
-      this.merkleTrees = merkleTrees;
-    } else {
-      this.merkleTrees = worldStateDB.getMerkleInterface();
-    }
-  }
+    /** Ephmeral forest for merkle tree operations */
+    public readonly merkleTrees: AvmEphemeralForest,
+  ) {}
 
   /**
    * Create a new state manager with some preloaded pending siloed nullifiers
    */
-  public static newWithPendingSiloedNullifiers(
+  public static async newWithPendingSiloedNullifiers(
     worldStateDB: WorldStateDB,
     trace: PublicSideEffectTraceInterface,
     pendingSiloedNullifiers: Fr[],
+    doMerkleOperations: boolean = false,
   ) {
     const parentNullifiers = NullifierManager.newWithPendingSiloedNullifiers(worldStateDB, pendingSiloedNullifiers);
+    const ephemeralForest = await AvmEphemeralForest.create(worldStateDB.getMerkleInterface());
     return new AvmPersistableStateManager(
       worldStateDB,
       trace,
       /*publicStorage=*/ new PublicStorage(worldStateDB),
       /*nullifiers=*/ parentNullifiers.fork(),
+      doMerkleOperations,
+      ephemeralForest,
+    );
+  }
+
+  /**
+   * Create a new state manager
+   */
+  public static async create(worldStateDB: WorldStateDB, trace: PublicSideEffectTraceInterface) {
+    const ephemeralForest = await AvmEphemeralForest.create(worldStateDB.getMerkleInterface());
+    return new AvmPersistableStateManager(
+      worldStateDB,
+      trace,
+      /*publicStorage=*/ new PublicStorage(worldStateDB),
+      /*nullifiers=*/ new NullifierManager(worldStateDB),
+      /*doMerkleOperations=*/ true,
+      ephemeralForest,
     );
   }
 
@@ -89,6 +99,7 @@ export class AvmPersistableStateManager {
       this.publicStorage.fork(),
       this.nullifiers.fork(),
       this.doMerkleOperations,
+      this.merkleTrees.fork(),
     );
   }
 
@@ -116,7 +127,11 @@ export class AvmPersistableStateManager {
 
   private _merge(forkedState: AvmPersistableStateManager, reverted: boolean) {
     // sanity check to avoid merging the same forked trace twice
-    assert(!this.alreadyMergedIntoParent, 'Cannot merge forked state that has already been merged into its parent!');
+    assert(
+      !forkedState.alreadyMergedIntoParent,
+      'Cannot merge forked state that has already been merged into its parent!',
+    );
+    forkedState.alreadyMergedIntoParent = true;
     this.publicStorage.acceptAndMerge(forkedState.publicStorage);
     this.nullifiers.acceptAndMerge(forkedState.nullifiers);
     this.trace.merge(forkedState.trace, reverted);
@@ -135,27 +150,18 @@ export class AvmPersistableStateManager {
     this.publicStorage.write(contractAddress, slot, value);
     const leafSlot = computePublicDataTreeLeafSlot(contractAddress, slot);
     if (this.doMerkleOperations) {
-      const result = await this.merkleTrees.batchInsert(
-        MerkleTreeId.PUBLIC_DATA_TREE,
-        [new PublicDataTreeLeaf(leafSlot, value).toBuffer()],
-        0,
-      );
+      const result = await this.merkleTrees.writePublicStorage(leafSlot, value);
       assert(result !== undefined, 'Public data tree insertion error. You might want to disable skipMerkleOperations.');
       this.log.debug(`Inserted public data tree leaf at leafSlot ${leafSlot}, value: ${value}`);
 
-      const lowLeafInfo = result.lowLeavesWitnessData![0];
-      const lowLeafPreimage = lowLeafInfo.leafPreimage as PublicDataTreeLeafPreimage;
+      const lowLeafInfo = result.lowWitness;
+      const lowLeafPreimage = result.lowWitness.preimage as PublicDataTreeLeafPreimage;
       const lowLeafIndex = lowLeafInfo.index;
-      const lowLeafPath = lowLeafInfo.siblingPath.toFields();
+      const lowLeafPath = lowLeafInfo.siblingPath;
+
+      const insertionPath = result.insertionPath;
+      const newLeafPreimage = result.newOrElementToUpdate.element as PublicDataTreeLeafPreimage;
 
-      const insertionPath = result.newSubtreeSiblingPath.toFields();
-      const newLeafPreimage = new PublicDataTreeLeafPreimage(
-        leafSlot,
-        value,
-        lowLeafPreimage.nextSlot,
-        lowLeafPreimage.nextIndex,
-      );
-      // FIXME: Why do we need to hint both preimages for public data writes, but not for nullifier insertions?
       this.trace.tracePublicStorageWrite(
         contractAddress,
         slot,
@@ -179,23 +185,24 @@ export class AvmPersistableStateManager {
    * @returns the latest value written to slot, or 0 if never written to before
    */
   public async readStorage(contractAddress: AztecAddress, slot: Fr): Promise<Fr> {
-    const { value, exists, cached } = await this.publicStorage.read(contractAddress, slot);
-    this.log.debug(
-      `Storage read  (address=${contractAddress}, slot=${slot}): value=${value}, exists=${exists}, cached=${cached}`,
-    );
+    const { value, cached } = await this.publicStorage.read(contractAddress, slot);
+    this.log.debug(`Storage read  (address=${contractAddress}, slot=${slot}): value=${value}, cached=${cached}`);
 
     const leafSlot = computePublicDataTreeLeafSlot(contractAddress, slot);
 
     if (this.doMerkleOperations) {
       // Get leaf if present, low leaf if absent
       // If leaf is present, hint/trace it. Otherwise, hint/trace the low leaf.
-      const [leafIndex, leafPreimage, leafPath, _alreadyPresent] = await getLeafOrLowLeaf<PublicDataTreeLeafPreimage>(
-        MerkleTreeId.PUBLIC_DATA_TREE,
-        leafSlot.toBigInt(),
-        this.merkleTrees,
-      );
-      // FIXME: cannot have this assertion until "caching" is done via ephemeral merkle writes
-      //assert(alreadyPresent == exists, 'WorldStateDB contains public data leaf, but merkle tree does not.... This is a bug!');
+      const {
+        preimage,
+        index: leafIndex,
+        update: exists,
+      } = await this.merkleTrees.getLeafOrLowLeafInfo(MerkleTreeId.PUBLIC_DATA_TREE, leafSlot);
+      // The index and preimage here is either the low leaf or the leaf itself (depending on the value of update flag)
+      // In either case, we just want the sibling path to this leaf - it's up to the avm to distinguish if it's a low leaf or not
+      const leafPath = await this.merkleTrees.getSiblingPath(MerkleTreeId.PUBLIC_DATA_TREE, leafIndex);
+      const leafPreimage = preimage as PublicDataTreeLeafPreimage;
+
       this.log.debug(
         `leafPreimage.nextSlot: ${leafPreimage.nextSlot}, leafPreimage.nextIndex: ${Number(leafPreimage.nextIndex)}`,
       );
@@ -204,15 +211,16 @@ export class AvmPersistableStateManager {
       if (!exists) {
         // Sanity check that the leaf slot is skipped by low leaf when it doesn't exist
         assert(
-          leafSlot.toBigInt() > leafPreimage.slot.toBigInt() && leafSlot.toBigInt() < leafPreimage.nextSlot.toBigInt(),
-          'Public data tree low leaf should skip the target leaf slot when the target leaf does not exist.',
+          leafPreimage.slot.toBigInt() < leafSlot.toBigInt() &&
+            (leafPreimage.nextIndex === 0n || leafPreimage.nextSlot.toBigInt() > leafSlot.toBigInt()),
+          'Public data tree low leaf should skip the target leaf slot when the target leaf does not exist or is the max value.',
         );
       }
       this.log.debug(
         `Tracing storage leaf preimage slot=${slot}, leafSlot=${leafSlot}, value=${value}, nextKey=${leafPreimage.nextSlot}, nextIndex=${leafPreimage.nextIndex}`,
       );
       // On non-existence, AVM circuit will need to recognize that leafPreimage.slot != leafSlot,
-      // prove that this is a low leaf that skips leafSlot, and then prove memebership of the leaf.
+      // prove that this is a low leaf that skips leafSlot, and then prove membership of the leaf.
       this.trace.tracePublicStorageRead(contractAddress, slot, value, leafPreimage, new Fr(leafIndex), leafPath);
     } else {
       this.trace.tracePublicStorageRead(contractAddress, slot, value);
@@ -229,10 +237,8 @@ export class AvmPersistableStateManager {
    * @returns the latest value written to slot, or 0 if never written to before
    */
   public async peekStorage(contractAddress: AztecAddress, slot: Fr): Promise<Fr> {
-    const { value, exists, cached } = await this.publicStorage.read(contractAddress, slot);
-    this.log.debug(
-      `Storage peek  (address=${contractAddress}, slot=${slot}): value=${value}, exists=${exists}, cached=${cached}`,
-    );
+    const { value, cached } = await this.publicStorage.read(contractAddress, slot);
+    this.log.debug(`Storage peek  (address=${contractAddress}, slot=${slot}): value=${value},  cached=${cached}`);
     return Promise.resolve(value);
   }
 
@@ -255,7 +261,7 @@ export class AvmPersistableStateManager {
       // TODO(8287): We still return exists here, but we need to transmit both the requested noteHash and the gotLeafValue
       // such that the VM can constrain the equality and decide on exists based on that.
       const path = await this.merkleTrees.getSiblingPath(MerkleTreeId.NOTE_HASH_TREE, leafIndex.toBigInt());
-      this.trace.traceNoteHashCheck(contractAddress, gotLeafValue, leafIndex, exists, path.toFields());
+      this.trace.traceNoteHashCheck(contractAddress, gotLeafValue, leafIndex, exists, path);
     } else {
       this.trace.traceNoteHashCheck(contractAddress, gotLeafValue, leafIndex, exists);
     }
@@ -266,19 +272,15 @@ export class AvmPersistableStateManager {
    * Write a note hash, trace the write.
    * @param noteHash - the unsiloed note hash to write
    */
-  public async writeNoteHash(contractAddress: AztecAddress, noteHash: Fr): Promise<void> {
+  public writeNoteHash(contractAddress: AztecAddress, noteHash: Fr): void {
     this.log.debug(`noteHashes(${contractAddress}) += @${noteHash}.`);
 
     if (this.doMerkleOperations) {
-      // TODO: We should track this globally here in the state manager
-      const info = await this.merkleTrees.getTreeInfo(MerkleTreeId.NOTE_HASH_TREE);
-      const leafIndex = new Fr(info.size + 1n);
-
-      const path = await this.merkleTrees.getSiblingPath(MerkleTreeId.NOTE_HASH_TREE, leafIndex.toBigInt());
+      // Should write a helper for this
+      const leafIndex = new Fr(this.merkleTrees.treeMap.get(MerkleTreeId.NOTE_HASH_TREE)!.leafCount);
       const siloedNoteHash = siloNoteHash(contractAddress, noteHash);
-
-      await this.merkleTrees.appendLeaves(MerkleTreeId.NOTE_HASH_TREE, [siloedNoteHash]);
-      this.trace.traceNewNoteHash(contractAddress, noteHash, leafIndex, path.toFields());
+      const insertionPath = this.merkleTrees.appendNoteHash(siloedNoteHash);
+      this.trace.traceNewNoteHash(contractAddress, noteHash, leafIndex, insertionPath);
     } else {
       this.trace.traceNewNoteHash(contractAddress, noteHash);
     }
@@ -298,15 +300,15 @@ export class AvmPersistableStateManager {
     if (this.doMerkleOperations) {
       // Get leaf if present, low leaf if absent
       // If leaf is present, hint/trace it. Otherwise, hint/trace the low leaf.
-      const [leafIndex, leafPreimage, leafPath, alreadyPresent] = await getLeafOrLowLeaf<NullifierLeafPreimage>(
-        MerkleTreeId.NULLIFIER_TREE,
-        siloedNullifier.toBigInt(),
-        this.merkleTrees,
-      );
-      assert(
-        alreadyPresent == exists,
-        'WorldStateDB contains nullifier leaf, but merkle tree does not.... This is a bug!',
-      );
+      const {
+        preimage,
+        index: leafIndex,
+        update,
+      } = await this.merkleTrees.getLeafOrLowLeafInfo(MerkleTreeId.NULLIFIER_TREE, siloedNullifier);
+      const leafPreimage = preimage as NullifierLeafPreimage;
+      const leafPath = await this.merkleTrees.getSiblingPath(MerkleTreeId.NULLIFIER_TREE, leafIndex);
+
+      assert(update == exists, 'WorldStateDB contains nullifier leaf, but merkle tree does not.... This is a bug!');
 
       this.log.debug(
         `nullifiers(${contractAddress})@${nullifier} ?? leafIndex: ${leafIndex}, exists: ${exists}, pending: ${isPending}.`,
@@ -346,40 +348,55 @@ export class AvmPersistableStateManager {
    */
   public async writeNullifier(contractAddress: AztecAddress, nullifier: Fr) {
     this.log.debug(`nullifiers(${contractAddress}) += ${nullifier}.`);
-    // Cache pending nullifiers for later access
-    await this.nullifiers.append(contractAddress, nullifier);
 
     const siloedNullifier = siloNullifier(contractAddress, nullifier);
 
     if (this.doMerkleOperations) {
+      // Maybe overkill, but we should check if the nullifier is already present in the tree before attempting to insert
+      // It might be better to catch the error from the insert operation
       // Trace all nullifier creations, even duplicate insertions that fail
-      const alreadyPresent = await this.merkleTrees.getPreviousValueIndex(
+      const { preimage, index, update } = await this.merkleTrees.getLeafOrLowLeafInfo(
         MerkleTreeId.NULLIFIER_TREE,
-        siloedNullifier.toBigInt(),
+        siloedNullifier,
       );
-      if (alreadyPresent) {
-        this.log.verbose(`Nullifier already present in tree: ${nullifier} at index ${alreadyPresent.index}.`);
+      if (update) {
+        this.log.verbose(`Nullifier already present in tree: ${nullifier} at index ${index}.`);
+        // If the nullifier is already present, we should not insert it again
+        // instead we provide the direct membership path
+        const path = await this.merkleTrees.getSiblingPath(MerkleTreeId.NULLIFIER_TREE, index);
+        // This just becomes a nullifier read hint
+        this.trace.traceNullifierCheck(
+          contractAddress,
+          nullifier,
+          /*exists=*/ update,
+          preimage as NullifierLeafPreimage,
+          new Fr(index),
+          path,
+        );
+        throw new NullifierCollisionError(
+          `Nullifier ${nullifier} at contract ${contractAddress} already exists in parent cache or host.`,
+        );
+      } else {
+        // Cache pending nullifiers for later access
+        await this.nullifiers.append(contractAddress, nullifier);
+        // We append the new nullifier
+        const appendResult = await this.merkleTrees.appendNullifier(siloedNullifier);
+        const lowLeafPreimage = appendResult.lowWitness.preimage as NullifierLeafPreimage;
+        const lowLeafIndex = appendResult.lowWitness.index;
+        const lowLeafPath = appendResult.lowWitness.siblingPath;
+        const insertionPath = appendResult.insertionPath;
+        this.trace.traceNewNullifier(
+          contractAddress,
+          nullifier,
+          lowLeafPreimage,
+          new Fr(lowLeafIndex),
+          lowLeafPath,
+          insertionPath,
+        );
       }
-      const insertionResult = await this.merkleTrees.batchInsert(
-        MerkleTreeId.NULLIFIER_TREE,
-        [siloedNullifier.toBuffer()],
-        0,
-      );
-      const lowLeafInfo = insertionResult.lowLeavesWitnessData![0];
-      const lowLeafPreimage = lowLeafInfo.leafPreimage as NullifierLeafPreimage;
-      const lowLeafIndex = lowLeafInfo.index;
-      const lowLeafPath = lowLeafInfo.siblingPath.toFields();
-      const insertionPath = insertionResult.newSubtreeSiblingPath.toFields();
-
-      this.trace.traceNewNullifier(
-        contractAddress,
-        nullifier,
-        lowLeafPreimage,
-        new Fr(lowLeafIndex),
-        lowLeafPath,
-        insertionPath,
-      );
     } else {
+      // Cache pending nullifiers for later access
+      await this.nullifiers.append(contractAddress, nullifier);
       this.trace.traceNewNullifier(contractAddress, nullifier);
     }
   }
@@ -404,7 +421,11 @@ export class AvmPersistableStateManager {
     if (this.doMerkleOperations) {
       // TODO(8287): We still return exists here, but we need to transmit both the requested msgHash and the value
       // such that the VM can constrain the equality and decide on exists based on that.
-      const path = await this.merkleTrees.getSiblingPath(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, msgLeafIndex.toBigInt());
+      // We should defintely add a helper here
+      const path = await this.merkleTrees.treeDb.getSiblingPath(
+        MerkleTreeId.L1_TO_L2_MESSAGE_TREE,
+        msgLeafIndex.toBigInt(),
+      );
       this.trace.traceL1ToL2MessageCheck(contractAddress, valueAtIndex, msgLeafIndex, exists, path.toFields());
     } else {
       this.trace.traceL1ToL2MessageCheck(contractAddress, valueAtIndex, msgLeafIndex, exists);
@@ -504,7 +525,6 @@ export class AvmPersistableStateManager {
     forkedState: AvmPersistableStateManager,
     nestedEnvironment: AvmExecutionEnvironment,
     startGasLeft: Gas,
-    endGasLeft: Gas,
     bytecode: Buffer,
     avmCallResults: AvmContractCallResult,
   ) {
@@ -521,7 +541,6 @@ export class AvmPersistableStateManager {
       forkedState.trace,
       nestedEnvironment,
       startGasLeft,
-      endGasLeft,
       bytecode,
       avmCallResults,
       functionName,
@@ -532,30 +551,3 @@ export class AvmPersistableStateManager {
     this.trace.traceEnqueuedCall(publicCallRequest, calldata, reverted);
   }
 }
-
-/**
- * Get leaf if present, low leaf if absent
- */
-export async function getLeafOrLowLeaf<TreePreimageType extends IndexedTreeLeafPreimage>(
-  treeId: IndexedTreeId,
-  key: bigint,
-  merkleTrees: MerkleTreeWriteOperations,
-) {
-  // "key" is siloed slot (leafSlot) or siloed nullifier
-  const previousValueIndex = await merkleTrees.getPreviousValueIndex(treeId, key);
-  assert(
-    previousValueIndex !== undefined,
-    `${MerkleTreeId[treeId]} low leaf index should always be found (even if target leaf does not exist)`,
-  );
-  const { index: leafIndex, alreadyPresent } = previousValueIndex;
-
-  const leafPreimage = await merkleTrees.getLeafPreimage(treeId, leafIndex);
-  assert(
-    leafPreimage !== undefined,
-    `${MerkleTreeId[treeId]}  low leaf preimage should never be undefined (even if target leaf does not exist)`,
-  );
-
-  const leafPath = await merkleTrees.getSiblingPath(treeId, leafIndex);
-
-  return [leafIndex, leafPreimage as TreePreimageType, leafPath.toFields(), alreadyPresent] as const;
-}

package/src/avm/journal/public_storage.ts

@@ -5,7 +5,6 @@ import type { PublicStateDB } from '../../index.js';
 
 type PublicStorageReadResult = {
   value: Fr;
-  exists: boolean;
   cached: boolean;
 };
 
@@ -77,17 +76,17 @@ export class PublicStorage {
     let value = this.readHereOrParent(contractAddress, slot);
     // Finally try the host's Aztec state (a trip to the database)
     if (!value) {
-      value = await this.hostPublicStorage.storageRead(contractAddress, slot);
+      // This functions returns Fr.ZERO if it has never been written to before
+      // we explicity coalesce to Fr.ZERO in case we have some implementations that cause this to return undefined
+      value = (await this.hostPublicStorage.storageRead(contractAddress, slot)) ?? Fr.ZERO;
       // TODO(dbanks12): if value retrieved from host storage, we can cache it here
       // any future reads to the same slot can read from cache instead of more expensive
       // DB access
     } else {
       cached = true;
     }
-    // if value is undefined, that means this slot has never been written to!
-    const exists = value !== undefined;
-    const valueOrZero = exists ? value : Fr.ZERO;
-    return Promise.resolve({ value: valueOrZero, exists, cached });
+    // if value is Fr.ZERO here, it that means this slot has never been written to!
+    return Promise.resolve({ value, cached });
   }
 
   /**

package/src/avm/opcodes/accrued_substate.ts

@@ -70,7 +70,7 @@ export class EmitNoteHash extends Instruction {
     }
 
     const noteHash = memory.get(noteHashOffset).toFr();
-    await context.persistableState.writeNoteHash(context.environment.address, noteHash);
+    context.persistableState.writeNoteHash(context.environment.address, noteHash);
 
     memory.assert({ reads: 1, addressing });
   }

package/src/avm/opcodes/addressing_mode.ts

@@ -1,6 +1,7 @@
 import { strict as assert } from 'assert';
 
-import { type TaggedMemoryInterface } from '../avm_memory_types.js';
+import { TaggedMemory, type TaggedMemoryInterface } from '../avm_memory_types.js';
+import { AddressOutOfRangeError } from '../errors.js';
 
 export enum AddressingMode {
   DIRECT = 0,
@@ -63,7 +64,11 @@ export class Addressing {
       resolved[i] = offset;
       if (mode & AddressingMode.RELATIVE) {
         mem.checkIsValidMemoryOffsetTag(0);
-        resolved[i] += Number(mem.get(0).toBigInt());
+        const baseAddr = Number(mem.get(0).toBigInt());
+        resolved[i] += baseAddr;
+        if (resolved[i] >= TaggedMemory.MAX_MEMORY_SIZE) {
+          throw new AddressOutOfRangeError(baseAddr, offset);
+        }
       }
       if (mode & AddressingMode.INDIRECT) {
         mem.checkIsValidMemoryOffsetTag(resolved[i]);

package/src/avm/opcodes/contract.ts

@@ -18,18 +18,18 @@ export class GetContractInstance extends Instruction {
   static readonly wireFormat: OperandType[] = [
     OperandType.UINT8, // opcode
     OperandType.UINT8, // indirect bits
-    OperandType.UINT8, // member enum (immediate)
     OperandType.UINT16, // addressOffset
     OperandType.UINT16, // dstOffset
     OperandType.UINT16, // existsOfsset
+    OperandType.UINT8, // member enum (immediate)
   ];
 
   constructor(
     private indirect: number,
-    private memberEnum: number,
     private addressOffset: number,
     private dstOffset: number,
     private existsOffset: number,
+    private memberEnum: number,
   ) {
     super();
   }

package/src/avm/opcodes/control_flow.ts

@@ -36,11 +36,11 @@ export class JumpI extends Instruction {
   static readonly wireFormat: OperandType[] = [
     OperandType.UINT8,
     OperandType.UINT8,
-    OperandType.UINT32,
     OperandType.UINT16,
+    OperandType.UINT32,
   ];
 
-  constructor(private indirect: number, private loc: number, private condOffset: number) {
+  constructor(private indirect: number, private condOffset: number, private loc: number) {
     super();
   }
 

package/src/avm/opcodes/environment_getters.ts

@@ -60,11 +60,11 @@ export class GetEnvVar extends Instruction {
   static readonly wireFormat16: OperandType[] = [
     OperandType.UINT8, // opcode
     OperandType.UINT8, // indirect
-    OperandType.UINT8, // variable enum (immediate)
     OperandType.UINT16, // dstOffset
+    OperandType.UINT8, // variable enum (immediate)
   ];
 
-  constructor(private indirect: number, private varEnum: number, private dstOffset: number) {
+  constructor(private indirect: number, private dstOffset: number, private varEnum: number) {
     super();
   }
 

package/src/avm/opcodes/external_calls.ts

@@ -2,7 +2,6 @@ import { Fr, FunctionSelector, Gas, PUBLIC_DISPATCH_SELECTOR } from '@aztec/circ
 
 import type { AvmContext } from '../avm_context.js';
 import { type AvmContractCallResult } from '../avm_contract_call_result.js';
-import { gasLeftToGas } from '../avm_gas.js';
 import { type Field, TypeTag, Uint1 } from '../avm_memory_types.js';
 import { AvmSimulator } from '../avm_simulator.js';
 import { Opcode, OperandType } from '../serialization/instruction_serialization.js';
@@ -95,7 +94,7 @@ abstract class ExternalCall extends Instruction {
     memory.set(successOffset, new Uint1(success ? 1 : 0));
 
     // Refund unused gas
-    context.machineState.refundGas(gasLeftToGas(nestedContext.machineState));
+    context.machineState.refundGas(nestedCallResults.gasLeft);
 
     // Merge nested call's state and trace based on whether it succeeded.
     if (success) {
@@ -107,7 +106,6 @@ abstract class ExternalCall extends Instruction {
       /*nestedState=*/ nestedContext.persistableState,
       /*nestedEnvironment=*/ nestedContext.environment,
       /*startGasLeft=*/ Gas.from(allocatedGas),
-      /*endGasLeft=*/ Gas.from(nestedContext.machineState.gasLeft),
       /*bytecode=*/ simulator.getBytecode()!,
       /*avmCallResults=*/ nestedCallResults,
     );

package/src/avm/opcodes/memory.ts

@@ -12,51 +12,51 @@ export class Set extends Instruction {
   public static readonly wireFormat8: OperandType[] = [
     OperandType.UINT8, // opcode
     OperandType.UINT8, // indirect
+    OperandType.UINT8, // dstOffset
     OperandType.UINT8, // tag
     OperandType.UINT8, // const (value)
-    OperandType.UINT8, // dstOffset
   ];
   public static readonly wireFormat16: OperandType[] = [
     OperandType.UINT8, // opcode
     OperandType.UINT8, // indirect
+    OperandType.UINT16, // dstOffset
     OperandType.UINT8, // tag
     OperandType.UINT16, // const (value)
-    OperandType.UINT16, // dstOffset
   ];
   public static readonly wireFormat32: OperandType[] = [
     OperandType.UINT8, // opcode
     OperandType.UINT8, // indirect
+    OperandType.UINT16, // dstOffset
     OperandType.UINT8, // tag
     OperandType.UINT32, // const (value)
-    OperandType.UINT16, // dstOffset
   ];
   public static readonly wireFormat64: OperandType[] = [
     OperandType.UINT8, // opcode
     OperandType.UINT8, // indirect
+    OperandType.UINT16, // dstOffset
     OperandType.UINT8, // tag
     OperandType.UINT64, // const (value)
-    OperandType.UINT16, // dstOffset
   ];
   public static readonly wireFormat128: OperandType[] = [
     OperandType.UINT8, // opcode
     OperandType.UINT8, // indirect
+    OperandType.UINT16, // dstOffset
     OperandType.UINT8, // tag
     OperandType.UINT128, // const (value)
-    OperandType.UINT16, // dstOffset
   ];
   public static readonly wireFormatFF: OperandType[] = [
     OperandType.UINT8, // opcode
     OperandType.UINT8, // indirect
+    OperandType.UINT16, // dstOffset
     OperandType.UINT8, // tag
     OperandType.FF, // const (value)
-    OperandType.UINT16, // dstOffset
   ];
 
   constructor(
     private indirect: number,
+    private dstOffset: number,
     private inTag: number,
     private value: bigint | number,
-    private dstOffset: number,
   ) {
     super();
   }
@@ -87,14 +87,14 @@ export class Cast extends Instruction {
     OperandType.UINT8,
   ];
   static readonly wireFormat16 = [
-    OperandType.UINT8,
     OperandType.UINT8,
     OperandType.UINT8,
     OperandType.UINT16,
     OperandType.UINT16,
+    OperandType.UINT8,
   ];
 
-  constructor(private indirect: number, private dstTag: number, private srcOffset: number, private dstOffset: number) {
+  constructor(private indirect: number, private srcOffset: number, private dstOffset: number, private dstTag: number) {
     super();
   }
 

package/src/avm/opcodes/misc.ts

@@ -16,17 +16,17 @@ export class DebugLog extends Instruction {
     OperandType.UINT8, // Opcode
     OperandType.UINT8, // Indirect
     OperandType.UINT16, // message memory address
-    OperandType.UINT16, // message size
     OperandType.UINT16, // fields memory address
     OperandType.UINT16, // fields size address
+    OperandType.UINT16, // message size
   ];
 
   constructor(
     private indirect: number,
     private messageOffset: number,
-    private messageSize: number,
     private fieldsOffset: number,
     private fieldsSizeOffset: number,
+    private messageSize: number,
   ) {
     super();
   }

package/src/index.ts

@@ -4,5 +4,4 @@ export * from './client/index.js';
 export * from './common/index.js';
 export * from './public/index.js';
 export * from './providers/index.js';
-export * from './mocks/index.js';
 export * from './stats/index.js';