@aztec/simulator 0.75.0 → 0.76.0

package/src/avm/avm_simulator.ts

@@ -18,6 +18,7 @@ import {
   revertReasonFromExplicitRevert,
 } from './errors.js';
 import { type AvmPersistableStateManager } from './journal/journal.js';
+import { type Instruction } from './opcodes/instruction.js';
 import {
   INSTRUCTION_SET,
   type InstructionSet,
@@ -33,20 +34,26 @@ export class AvmSimulator {
   private log: Logger;
   private bytecode: Buffer | undefined;
   private opcodeTallies: Map<string, OpcodeTally> = new Map();
+  // maps pc to [instr, bytesRead]
+  private deserializedInstructionsCache: Map<number, [Instruction, number]> = new Map();
 
   private tallyPrintFunction = () => {};
   private tallyInstructionFunction = (_b: string, _c: Gas) => {};
 
   // Test Purposes only: Logger will not have the proper function name. Use this constructor for testing purposes
   // only. Otherwise, use build() below.
-  constructor(private context: AvmContext, private instructionSet: InstructionSet = INSTRUCTION_SET()) {
+  constructor(
+    private context: AvmContext,
+    private instructionSet: InstructionSet = INSTRUCTION_SET(),
+    enableTallying = false,
+  ) {
     assert(
       context.machineState.gasLeft.l2Gas <= MAX_L2_GAS_PER_TX_PUBLIC_PORTION,
       `Cannot allocate more than ${MAX_L2_GAS_PER_TX_PUBLIC_PORTION} to the AVM for execution.`,
     );
     this.log = createLogger(`simulator:avm(calldata[0]: ${context.environment.calldata[0]})`);
-    // TODO(palla/log): Should tallies be printed on debug, or only on trace?
-    if (this.log.isLevelEnabled('debug')) {
+    // Turn on tallying if explicitly enabled or if trace logging
+    if (enableTallying || this.log.isLevelEnabled('trace')) {
       this.tallyPrintFunction = this.printOpcodeTallies;
       this.tallyInstructionFunction = this.tallyInstruction;
     }
@@ -125,6 +132,7 @@ export class AvmSimulator {
    * This method is useful for testing and debugging.
    */
   public async executeBytecode(bytecode: Buffer): Promise<AvmContractCallResult> {
+    const startTotalTime = performance.now();
     assert(isAvmBytecode(bytecode), "AVM simulator can't execute non-AVM bytecode");
     assert(bytecode.length > 0, "AVM simulator can't execute empty bytecode");
 
@@ -137,19 +145,32 @@ export class AvmSimulator {
       // continuing until the machine state signifies a halt
       let instrCounter = 0;
       while (!machineState.getHalted()) {
-        const [instruction, bytesRead] = decodeInstructionFromBytecode(bytecode, machineState.pc, this.instructionSet);
+        // Get the instruction from cache, or deserialize for the first time
+        let cachedInstruction = this.deserializedInstructionsCache.get(machineState.pc);
+
+        if (cachedInstruction === undefined) {
+          cachedInstruction = decodeInstructionFromBytecode(bytecode, machineState.pc, this.instructionSet);
+          this.deserializedInstructionsCache.set(machineState.pc, cachedInstruction);
+        }
+        const [instruction, bytesRead] = cachedInstruction;
+
         const instrStartGas = machineState.gasLeft; // Save gas before executing instruction (for profiling)
 
-        this.log.trace(
-          `[PC:${machineState.pc}] [IC:${instrCounter++}] ${instruction.toString()} (gasLeft l2=${
-            machineState.l2GasLeft
-          } da=${machineState.daGasLeft})`,
-        );
+        if (this.log.isLevelEnabled('trace')) {
+          // Skip this entirely to avoid toStringing etc if trace is not enabled
+          this.log.trace(
+            `[PC:${machineState.pc}] [IC:${instrCounter}] ${instruction.toString()} (gasLeft l2=${
+              machineState.l2GasLeft
+            } da=${machineState.daGasLeft})`,
+          );
+        }
+        instrCounter++;
+
+        machineState.nextPc = machineState.pc + bytesRead;
+
         // Execute the instruction.
         // Normal returns and reverts will return normally here.
         // "Exceptional halts" will throw.
-        machineState.nextPc = machineState.pc + bytesRead;
-
         await instruction.execute(this.context);
         if (!instruction.handlesPC()) {
           // Increment PC if the instruction doesn't handle it itself
@@ -181,6 +202,11 @@ export class AvmSimulator {
       this.log.debug(`Executed ${instrCounter} instructions and consumed ${totalGasUsed.l2Gas} L2 Gas`);
 
       this.tallyPrintFunction();
+
+      const endTotalTime = performance.now();
+      const totalTime = endTotalTime - startTotalTime;
+      this.log.debug(`Total execution time: ${totalTime}ms`);
+
       // Return results for processing by calling context
       return results;
     } catch (err: any) {

package/src/avm/opcodes/accrued_substate.ts

@@ -28,7 +28,7 @@ export class NoteHashExists extends Instruction {
   }
 
   public async execute(context: AvmContext): Promise<void> {
-    const memory = context.machineState.memory.track(this.type);
+    const memory = context.machineState.memory;
     context.machineState.consumeGas(this.gasCost());
     const operands = [this.noteHashOffset, this.leafIndexOffset, this.existsOffset];
     const addressing = Addressing.fromWire(this.indirect, operands.length);
@@ -41,8 +41,6 @@ export class NoteHashExists extends Instruction {
 
     const exists = await context.persistableState.checkNoteHashExists(context.environment.address, noteHash, leafIndex);
     memory.set(existsOffset, exists ? new Uint1(1) : new Uint1(0));
-
-    memory.assert({ reads: 2, writes: 1, addressing });
   }
 }
 
@@ -57,7 +55,7 @@ export class EmitNoteHash extends Instruction {
   }
 
   public async execute(context: AvmContext): Promise<void> {
-    const memory = context.machineState.memory.track(this.type);
+    const memory = context.machineState.memory;
     context.machineState.consumeGas(this.gasCost());
 
     const operands = [this.noteHashOffset];
@@ -71,8 +69,6 @@ export class EmitNoteHash extends Instruction {
 
     const noteHash = memory.get(noteHashOffset).toFr();
     await context.persistableState.writeNoteHash(context.environment.address, noteHash);
-
-    memory.assert({ reads: 1, addressing });
   }
 }
 
@@ -98,7 +94,7 @@ export class NullifierExists extends Instruction {
   }
 
   public async execute(context: AvmContext): Promise<void> {
-    const memory = context.machineState.memory.track(this.type);
+    const memory = context.machineState.memory;
     context.machineState.consumeGas(this.gasCost());
 
     const operands = [this.nullifierOffset, this.addressOffset, this.existsOffset];
@@ -111,8 +107,6 @@ export class NullifierExists extends Instruction {
     const exists = await context.persistableState.checkNullifierExists(address, nullifier);
 
     memory.set(existsOffset, exists ? new Uint1(1) : new Uint1(0));
-
-    memory.assert({ reads: 2, writes: 1, addressing });
   }
 }
 
@@ -131,7 +125,7 @@ export class EmitNullifier extends Instruction {
       throw new StaticCallAlterationError();
     }
 
-    const memory = context.machineState.memory.track(this.type);
+    const memory = context.machineState.memory;
     context.machineState.consumeGas(this.gasCost());
 
     const operands = [this.nullifierOffset];
@@ -152,8 +146,6 @@ export class EmitNullifier extends Instruction {
         throw e;
       }
     }
-
-    memory.assert({ reads: 1, addressing });
   }
 }
 
@@ -179,7 +171,7 @@ export class L1ToL2MessageExists extends Instruction {
   }
 
   public async execute(context: AvmContext): Promise<void> {
-    const memory = context.machineState.memory.track(this.type);
+    const memory = context.machineState.memory;
     context.machineState.consumeGas(this.gasCost());
 
     const operands = [this.msgHashOffset, this.msgLeafIndexOffset, this.existsOffset];
@@ -195,8 +187,6 @@ export class L1ToL2MessageExists extends Instruction {
       msgLeafIndex,
     );
     memory.set(existsOffset, exists ? new Uint1(1) : new Uint1(0));
-
-    memory.assert({ reads: 2, writes: 1, addressing });
   }
 }
 
@@ -216,7 +206,7 @@ export class EmitUnencryptedLog extends Instruction {
       throw new StaticCallAlterationError();
     }
 
-    const memory = context.machineState.memory.track(this.type);
+    const memory = context.machineState.memory;
 
     const operands = [this.logOffset, this.logSizeOffset];
     const addressing = Addressing.fromWire(this.indirect, operands.length);
@@ -230,8 +220,6 @@ export class EmitUnencryptedLog extends Instruction {
     context.machineState.consumeGas(this.gasCost(logSize));
     const log = memory.getSlice(logOffset, logSize).map(f => f.toFr());
     context.persistableState.writePublicLog(contractAddress, log);
-
-    memory.assert({ reads: 1 + logSize, addressing });
   }
 }
 
@@ -250,7 +238,7 @@ export class SendL2ToL1Message extends Instruction {
       throw new StaticCallAlterationError();
     }
 
-    const memory = context.machineState.memory.track(this.type);
+    const memory = context.machineState.memory;
     context.machineState.consumeGas(this.gasCost());
 
     const operands = [this.recipientOffset, this.contentOffset];
@@ -261,7 +249,5 @@ export class SendL2ToL1Message extends Instruction {
     const recipient = memory.get(recipientOffset).toFr();
     const content = memory.get(contentOffset).toFr();
     context.persistableState.writeL2ToL1Message(context.environment.address, recipient, content);
-
-    memory.assert({ reads: 2, addressing });
   }
 }

package/src/avm/opcodes/addressing_mode.ts

@@ -59,12 +59,19 @@ export class Addressing {
   public resolve(offsets: number[], mem: TaggedMemoryInterface): number[] {
     assert(offsets.length <= this.modePerOperand.length);
     const resolved = new Array(offsets.length);
+
+    let didRelativeOnce = false;
+    let baseAddr = 0;
+
     for (const [i, offset] of offsets.entries()) {
       const mode = this.modePerOperand[i];
       resolved[i] = offset;
       if (mode & AddressingMode.RELATIVE) {
-        mem.checkIsValidMemoryOffsetTag(0);
-        const baseAddr = Number(mem.get(0).toBigInt());
+        if (!didRelativeOnce) {
+          mem.checkIsValidMemoryOffsetTag(0);
+          baseAddr = Number(mem.get(0).toBigInt());
+          didRelativeOnce = true;
+        }
         resolved[i] += baseAddr;
         if (resolved[i] >= TaggedMemory.MAX_MEMORY_SIZE) {
           throw new RelativeAddressOutOfRangeError(baseAddr, offset);

package/src/avm/opcodes/arithmetic.ts

@@ -13,7 +13,7 @@ import { ThreeOperandInstruction } from './instruction_impl.js';
 
 export abstract class ThreeOperandArithmeticInstruction extends ThreeOperandInstruction {
   public async execute(context: AvmContext): Promise<void> {
-    const memory = context.machineState.memory.track(this.type);
+    const memory = context.machineState.memory;
     context.machineState.consumeGas(this.gasCost());
 
     const operands = [this.aOffset, this.bOffset, this.dstOffset];
@@ -26,8 +26,6 @@ export abstract class ThreeOperandArithmeticInstruction extends ThreeOperandInst
 
     const dest = this.compute(a, b);
     memory.set(dstOffset, dest);
-
-    memory.assert({ reads: 2, writes: 1, addressing });
   }
 
   protected abstract compute(a: MemoryValue, b: MemoryValue): MemoryValue;

package/src/avm/opcodes/bitwise.ts

@@ -7,7 +7,7 @@ import { ThreeOperandInstruction } from './instruction_impl.js';
 
 abstract class ThreeOperandBitwiseInstruction extends ThreeOperandInstruction {
   public async execute(context: AvmContext): Promise<void> {
-    const memory = context.machineState.memory.track(this.type);
+    const memory = context.machineState.memory;
     context.machineState.consumeGas(this.gasCost());
 
     const operands = [this.aOffset, this.bOffset, this.dstOffset];
@@ -20,8 +20,6 @@ abstract class ThreeOperandBitwiseInstruction extends ThreeOperandInstruction {
 
     const res = this.compute(a, b);
     memory.set(dstOffset, res);
-
-    memory.assert({ reads: 2, writes: 1, addressing });
   }
 
   protected abstract compute(a: IntegralValue, b: IntegralValue): IntegralValue;
@@ -96,7 +94,7 @@ export class Not extends Instruction {
   }
 
   public async execute(context: AvmContext): Promise<void> {
-    const memory = context.machineState.memory.track(this.type);
+    const memory = context.machineState.memory;
     context.machineState.consumeGas(this.gasCost());
 
     const operands = [this.srcOffset, this.dstOffset];
@@ -107,7 +105,5 @@ export class Not extends Instruction {
 
     const res = value.not();
     memory.set(dstOffset, res);
-
-    memory.assert({ reads: 1, writes: 1, addressing });
   }
 }

package/src/avm/opcodes/comparators.ts

@@ -6,7 +6,7 @@ import { ThreeOperandInstruction } from './instruction_impl.js';
 
 abstract class ComparatorInstruction extends ThreeOperandInstruction {
   public async execute(context: AvmContext): Promise<void> {
-    const memory = context.machineState.memory.track(this.type);
+    const memory = context.machineState.memory;
     context.machineState.consumeGas(this.gasCost());
 
     const operands = [this.aOffset, this.bOffset, this.dstOffset];
@@ -19,8 +19,6 @@ abstract class ComparatorInstruction extends ThreeOperandInstruction {
 
     const dest = new Uint1(this.compare(a, b) ? 1 : 0);
     memory.set(dstOffset, dest);
-
-    memory.assert({ reads: 2, writes: 1, addressing });
   }
 
   protected abstract compare(a: MemoryValue, b: MemoryValue): boolean;

package/src/avm/opcodes/contract.ts

@@ -35,7 +35,7 @@ export class GetContractInstance extends Instruction {
   }
 
   async execute(context: AvmContext): Promise<void> {
-    const memory = context.machineState.memory.track(this.type);
+    const memory = context.machineState.memory;
     context.machineState.consumeGas(this.gasCost());
 
     if (!(this.memberEnum in ContractInstanceMember)) {
@@ -68,7 +68,5 @@ export class GetContractInstance extends Instruction {
 
     memory.set(existsOffset, new Uint1(exists ? 1 : 0));
     memory.set(dstOffset, memberValue);
-
-    memory.assert({ reads: 1, writes: 2, addressing });
   }
 }

package/src/avm/opcodes/control_flow.ts

@@ -19,8 +19,6 @@ export class Jump extends Instruction {
     context.machineState.consumeGas(this.gasCost());
 
     context.machineState.pc = this.jumpOffset;
-
-    context.machineState.memory.assert({});
   }
 
   public override handlesPC(): boolean {
@@ -45,7 +43,7 @@ export class JumpI extends Instruction {
   }
 
   public async execute(context: AvmContext): Promise<void> {
-    const memory = context.machineState.memory.track(this.type);
+    const memory = context.machineState.memory;
     context.machineState.consumeGas(this.gasCost());
 
     const operands = [this.condOffset];
@@ -58,8 +56,6 @@ export class JumpI extends Instruction {
     } else {
       context.machineState.pc = this.loc;
     }
-
-    memory.assert({ reads: 1, addressing });
   }
 
   public override handlesPC(): boolean {
@@ -85,8 +81,6 @@ export class InternalCall extends Instruction {
       returnPc: context.machineState.nextPc,
     });
     context.machineState.pc = this.loc;
-
-    context.machineState.memory.assert({});
   }
 
   public override handlesPC(): boolean {
@@ -112,8 +106,6 @@ export class InternalReturn extends Instruction {
       throw new InstructionExecutionError('Internal call stack empty!');
     }
     context.machineState.pc = stackEntry.returnPc;
-
-    context.machineState.memory.assert({});
   }
 
   public override handlesPC(): boolean {

package/src/avm/opcodes/conversion.ts

@@ -32,7 +32,7 @@ export class ToRadixBE extends Instruction {
   }
 
   public async execute(context: AvmContext): Promise<void> {
-    const memory = context.machineState.memory.track(this.type);
+    const memory = context.machineState.memory;
     const operands = [this.srcOffset, this.radixOffset, this.numLimbsOffset, this.outputBitsOffset, this.dstOffset];
     const addressing = Addressing.fromWire(this.indirect, operands.length);
     const [srcOffset, radixOffset, numLimbsOffset, outputBitsOffset, dstOffset] = addressing.resolve(operands, memory);
@@ -76,7 +76,5 @@ export class ToRadixBE extends Instruction {
     const outputType = outputBits != 0 ? Uint1 : Uint8;
     const res = limbArray.map(byte => new outputType(byte));
     memory.setSlice(dstOffset, res);
-
-    memory.assert({ reads: 4, writes: numLimbs, addressing });
   }
 }

package/src/avm/opcodes/ec_add.ts

@@ -38,7 +38,7 @@ export class EcAdd extends Instruction {
   }
 
   public async execute(context: AvmContext): Promise<void> {
-    const memory = context.machineState.memory.track(this.type);
+    const memory = context.machineState.memory;
     context.machineState.consumeGas(this.gasCost());
 
     const operands = [
@@ -89,7 +89,5 @@ export class EcAdd extends Instruction {
     memory.setSlice(dstOffset, [new Field(dest.x), new Field(dest.y)]);
     // Check representation of infinity for grumpkin
     memory.setSlice(dstOffset + 2, [new Uint1(dest.equals(Point.ZERO) ? 1 : 0)]);
-
-    memory.assert({ reads: 6, writes: 3, addressing });
   }
 }

package/src/avm/opcodes/environment_getters.ts

@@ -66,7 +66,7 @@ export class GetEnvVar extends Instruction {
   }
 
   public async execute(context: AvmContext): Promise<void> {
-    const memory = context.machineState.memory.track(this.type);
+    const memory = context.machineState.memory;
     context.machineState.consumeGas(this.gasCost());
 
     if (!(this.varEnum in EnvironmentVariable)) {
@@ -78,7 +78,5 @@ export class GetEnvVar extends Instruction {
     const [dstOffset] = addressing.resolve(operands, memory);
 
     memory.set(dstOffset, getValue(this.varEnum as EnvironmentVariable, context));
-
-    memory.assert({ writes: 1, addressing });
   }
 }

package/src/avm/opcodes/external_calls.ts

@@ -30,7 +30,7 @@ abstract class ExternalCall extends Instruction {
   }
 
   public async execute(context: AvmContext) {
-    const memory = context.machineState.memory.track(this.type);
+    const memory = context.machineState.memory;
     const operands = [this.gasOffset, this.addrOffset, this.argsOffset, this.argsSizeOffset, this.successOffset];
     const addressing = Addressing.fromWire(this.indirect, operands.length);
     const [gasOffset, addrOffset, argsOffset, argsSizeOffset, successOffset] = addressing.resolve(operands, memory);
@@ -94,7 +94,6 @@ abstract class ExternalCall extends Instruction {
     } else {
       context.persistableState.reject(nestedContext.persistableState);
     }
-    memory.assert({ reads: calldataSize + 4, writes: 1, addressing });
   }
 
   public abstract override get type(): 'CALL' | 'STATICCALL';
@@ -134,7 +133,7 @@ export class Return extends Instruction {
   }
 
   public async execute(context: AvmContext): Promise<void> {
-    const memory = context.machineState.memory.track(this.type);
+    const memory = context.machineState.memory;
 
     const operands = [this.returnOffset, this.returnSizeOffset];
     const addressing = Addressing.fromWire(this.indirect, operands.length);
@@ -147,7 +146,6 @@ export class Return extends Instruction {
     const output = memory.getSlice(returnOffset, returnSize).map(word => word.toFr());
 
     context.machineState.return(output);
-    memory.assert({ reads: returnSize + 1, addressing });
   }
 
   public override handlesPC(): boolean {
@@ -177,7 +175,7 @@ export class Revert extends Instruction {
   }
 
   public async execute(context: AvmContext): Promise<void> {
-    const memory = context.machineState.memory.track(this.type);
+    const memory = context.machineState.memory;
 
     const operands = [this.returnOffset, this.retSizeOffset];
     const addressing = Addressing.fromWire(this.indirect, operands.length);
@@ -189,7 +187,6 @@ export class Revert extends Instruction {
     const output = memory.getSlice(returnOffset, retSize).map(word => word.toFr());
 
     context.machineState.revert(output);
-    memory.assert({ reads: retSize + 1, addressing });
   }
 
   // We don't want to increase the PC after reverting because it breaks messages.

package/src/avm/opcodes/hashing.ts

@@ -24,7 +24,7 @@ export class Poseidon2 extends Instruction {
   }
 
   public async execute(context: AvmContext): Promise<void> {
-    const memory = context.machineState.memory.track(this.type);
+    const memory = context.machineState.memory;
     context.machineState.consumeGas(this.gasCost());
 
     const operands = [this.inputStateOffset, this.outputStateOffset];
@@ -39,8 +39,6 @@ export class Poseidon2 extends Instruction {
       outputOffset,
       outputState.map(word => new Field(word)),
     );
-
-    memory.assert({ reads: Poseidon2.stateSize, writes: Poseidon2.stateSize, addressing });
   }
 }
 
@@ -63,7 +61,7 @@ export class KeccakF1600 extends Instruction {
   // pub fn keccakf1600(input: [u64; 25]) -> [u64; 25]
   public async execute(context: AvmContext): Promise<void> {
     const inputSize = 25;
-    const memory = context.machineState.memory.track(this.type);
+    const memory = context.machineState.memory;
     const operands = [this.dstOffset, this.inputOffset];
     const addressing = Addressing.fromWire(this.indirect, operands.length);
     const [dstOffset, inputOffset] = addressing.resolve(operands, memory);
@@ -76,8 +74,6 @@ export class KeccakF1600 extends Instruction {
 
     const res = updatedState.map(word => new Uint64(word));
     memory.setSlice(dstOffset, res);
-
-    memory.assert({ reads: inputSize, writes: inputSize, addressing });
   }
 }
 
@@ -107,7 +103,7 @@ export class Sha256Compression extends Instruction {
     const STATE_SIZE = 8;
     const INPUTS_SIZE = 16;
 
-    const memory = context.machineState.memory.track(this.type);
+    const memory = context.machineState.memory;
     const operands = [this.outputOffset, this.stateOffset, this.inputsOffset];
     const addressing = Addressing.fromWire(this.indirect, operands.length);
     const [outputOffset, stateOffset, inputsOffset] = addressing.resolve(operands, memory);
@@ -125,7 +121,5 @@ export class Sha256Compression extends Instruction {
     // Conversion required from Uint32Array to Uint32[] (can't map directly, need `...`)
     const res = [...output].map(word => new Uint32(word));
     memory.setSlice(outputOffset, res);
-
-    memory.assert({ reads: STATE_SIZE + INPUTS_SIZE, writes: STATE_SIZE, addressing });
   }
 }

package/src/avm/opcodes/memory.ts

@@ -66,15 +66,13 @@ export class Set extends Instruction {
     // Constructor ensured that this.inTag is a valid tag
     const res = TaggedMemory.buildFromTagTruncating(this.value, this.inTag);
 
-    const memory = context.machineState.memory.track(this.type);
+    const memory = context.machineState.memory;
     context.machineState.consumeGas(this.gasCost());
 
     const operands = [this.dstOffset];
     const addressing = Addressing.fromWire(this.indirect, operands.length);
     const [dstOffset] = addressing.resolve(operands, memory);
     memory.set(dstOffset, res);
-
-    memory.assert({ writes: 1, addressing });
   }
 }
 
@@ -103,7 +101,7 @@ export class Cast extends Instruction {
   }
 
   public async execute(context: AvmContext): Promise<void> {
-    const memory = context.machineState.memory.track(this.type);
+    const memory = context.machineState.memory;
     context.machineState.consumeGas(this.gasCost());
 
     const operands = [this.srcOffset, this.dstOffset];
@@ -115,8 +113,6 @@ export class Cast extends Instruction {
     const casted = TaggedMemory.buildFromTagTruncating(a.toBigInt(), this.dstTag);
 
     memory.set(dstOffset, casted);
-
-    memory.assert({ reads: 1, writes: 1, addressing });
   }
 }
 
@@ -143,18 +139,14 @@ export class Mov extends Instruction {
   }
 
   public async execute(context: AvmContext): Promise<void> {
-    const memory = context.machineState.memory.track(this.type);
+    const memory = context.machineState.memory;
     context.machineState.consumeGas(this.gasCost());
 
     const operands = [this.srcOffset, this.dstOffset];
     const addressing = Addressing.fromWire(this.indirect, operands.length);
     const [srcOffset, dstOffset] = addressing.resolve(operands, memory);
-
     const a = memory.get(srcOffset);
-
     memory.set(dstOffset, a);
-
-    memory.assert({ reads: 1, writes: 1, addressing });
   }
 }
 
@@ -180,7 +172,7 @@ export class CalldataCopy extends Instruction {
   }
 
   public async execute(context: AvmContext): Promise<void> {
-    const memory = context.machineState.memory.track(this.type);
+    const memory = context.machineState.memory;
     const operands = [this.cdStartOffset, this.copySizeOffset, this.dstOffset];
     const addressing = Addressing.fromWire(this.indirect, operands.length);
     const [cdStartOffset, copySizeOffset, dstOffset] = addressing.resolve(operands, memory);
@@ -196,8 +188,6 @@ export class CalldataCopy extends Instruction {
     const transformedData = [...slice, ...Array(copySize - slice.length).fill(new Field(0))];
 
     memory.setSlice(dstOffset, transformedData);
-
-    memory.assert({ reads: 2, writes: copySize, addressing });
   }
 }
 
@@ -212,15 +202,13 @@ export class ReturndataSize extends Instruction {
   }
 
   public async execute(context: AvmContext): Promise<void> {
-    const memory = context.machineState.memory.track(this.type);
+    const memory = context.machineState.memory;
     const operands = [this.dstOffset];
     const addressing = Addressing.fromWire(this.indirect, operands.length);
     const [dstOffset] = addressing.resolve(operands, memory);
     context.machineState.consumeGas(this.gasCost());
 
     memory.set(dstOffset, new Uint32(context.machineState.nestedReturndata.length));
-
-    memory.assert({ writes: 1, addressing });
   }
 }
 
@@ -246,7 +234,7 @@ export class ReturndataCopy extends Instruction {
   }
 
   public async execute(context: AvmContext): Promise<void> {
-    const memory = context.machineState.memory.track(this.type);
+    const memory = context.machineState.memory;
     const operands = [this.rdStartOffset, this.copySizeOffset, this.dstOffset];
     const addressing = Addressing.fromWire(this.indirect, operands.length);
     const [rdStartOffset, copySizeOffset, dstOffset] = addressing.resolve(operands, memory);
@@ -262,7 +250,5 @@ export class ReturndataCopy extends Instruction {
     const transformedData = [...slice, ...Array(copySize - slice.length).fill(new Field(0))];
 
     memory.setSlice(dstOffset, transformedData);
-
-    memory.assert({ reads: 2, writes: copySize, addressing });
   }
 }

package/src/avm/opcodes/misc.ts

@@ -32,7 +32,7 @@ export class DebugLog extends Instruction {
   }
 
   public async execute(context: AvmContext): Promise<void> {
-    const memory = context.machineState.memory.track(this.type);
+    const memory = context.machineState.memory;
     const operands = [this.messageOffset, this.fieldsOffset, this.fieldsSizeOffset];
     const addressing = Addressing.fromWire(this.indirect, operands.length);
     const [messageOffset, fieldsOffset, fieldsSizeOffset] = addressing.resolve(operands, memory);
@@ -56,7 +56,5 @@ export class DebugLog extends Instruction {
     );
 
     DebugLog.logger.verbose(formattedStr);
-
-    memory.assert({ reads: 1 + fieldsSize + this.messageSize, addressing });
   }
 }

package/src/avm/opcodes/multi_scalar_mul.ts

@@ -33,7 +33,7 @@ export class MultiScalarMul extends Instruction {
   }
 
   public async execute(context: AvmContext): Promise<void> {
-    const memory = context.machineState.memory.track(this.type);
+    const memory = context.machineState.memory;
     // Resolve indirects
     const operands = [this.pointsOffset, this.scalarsOffset, this.outputOffset, this.pointsLengthOffset];
     const addressing = Addressing.fromWire(this.indirect, operands.length);
@@ -117,11 +117,5 @@ export class MultiScalarMul extends Instruction {
     memory.setSlice(outputOffset, [new Field(outputPoint.x), new Field(outputPoint.y)]);
     // Check representation of infinity for grumpkin
     memory.setSlice(outputOffset + 2, [new Uint1(outputPoint.equals(Point.ZERO) ? 1 : 0)]);
-
-    memory.assert({
-      reads: 1 + pointsReadLength + scalarReadLength /* points and scalars */,
-      writes: 3 /* output triplet */,
-      addressing,
-    });
   }
 }