@aztec/simulator 0.56.0 → 0.57.0

package/src/avm/journal/journal.ts

@@ -3,6 +3,7 @@ import { Fr } from '@aztec/foundation/fields';
 import { type DebugLogger, createDebugLogger } from '@aztec/foundation/log';
 import { SerializableContractInstance } from '@aztec/types/contracts';
 
+import { getPublicFunctionDebugName } from '../../common/debug_fn_name.js';
 import { type WorldStateDB } from '../../public/public_db_sources.js';
 import { type TracedContractInstance } from '../../public/side_effect_trace.js';
 import { type PublicSideEffectTraceInterface } from '../../public/side_effect_trace_interface.js';
@@ -187,12 +188,13 @@ export class AvmPersistableStateManager {
 
   /**
    * Write an L2 to L1 message.
+   * @param contractAddress - L2 contract address that created this message
    * @param recipient - L1 contract address to send the message to.
    * @param content - Message content.
    */
-  public writeL2ToL1Message(recipient: Fr, content: Fr) {
-    this.log.debug(`L1Messages(${recipient}) += ${content}.`);
-    this.trace.traceNewL2ToL1Message(recipient, content);
+  public writeL2ToL1Message(contractAddress: Fr, recipient: Fr, content: Fr) {
+    this.log.debug(`L2ToL1Messages(${contractAddress}) += (recipient: ${recipient}, content: ${content}).`);
+    this.trace.traceNewL2ToL1Message(contractAddress, recipient, content);
   }
 
   /**
@@ -256,9 +258,12 @@ export class AvmPersistableStateManager {
     if (!avmCallResults.reverted) {
       this.acceptNestedCallState(nestedState);
     }
-    const functionName =
-      (await this.worldStateDB.getDebugFunctionName(nestedEnvironment.address, nestedEnvironment.functionSelector)) ??
-      `${nestedEnvironment.address}:${nestedEnvironment.functionSelector}`;
+    const functionName = await getPublicFunctionDebugName(
+      this.worldStateDB,
+      nestedEnvironment.address,
+      nestedEnvironment.functionSelector,
+      nestedEnvironment.calldata,
+    );
 
     this.log.verbose(`[AVM] Calling nested function ${functionName}`);
 

package/src/avm/opcodes/accrued_substate.ts

@@ -28,13 +28,11 @@ export class NoteHashExists extends Instruction {
   }
 
   public async execute(context: AvmContext): Promise<void> {
-    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,
-    );
+    context.machineState.consumeGas(this.gasCost());
+    const operands = [this.noteHashOffset, this.leafIndexOffset, this.existsOffset];
+    const addressing = Addressing.fromWire(this.indirect, operands.length);
+    const [noteHashOffset, leafIndexOffset, existsOffset] = addressing.resolve(operands, memory);
     memory.checkTags(TypeTag.FIELD, noteHashOffset, leafIndexOffset);
 
     // Note that this instruction accepts any type in memory, and converts to Field.
@@ -48,7 +46,7 @@ export class NoteHashExists extends Instruction {
     );
     memory.set(existsOffset, exists ? new Uint8(1) : new Uint8(0));
 
-    memory.assert(memoryOperations);
+    memory.assert({ reads: 2, writes: 1, addressing });
     context.machineState.incrementPc();
   }
 }
@@ -64,11 +62,12 @@ export class EmitNoteHash extends Instruction {
   }
 
   public async execute(context: AvmContext): Promise<void> {
-    const memoryOperations = { reads: 1, indirect: this.indirect };
     const memory = context.machineState.memory.track(this.type);
-    context.machineState.consumeGas(this.gasCost(memoryOperations));
+    context.machineState.consumeGas(this.gasCost());
 
-    const [noteHashOffset] = Addressing.fromWire(this.indirect).resolve([this.noteHashOffset], memory);
+    const operands = [this.noteHashOffset];
+    const addressing = Addressing.fromWire(this.indirect, operands.length);
+    const [noteHashOffset] = addressing.resolve(operands, memory);
     memory.checkTag(TypeTag.FIELD, noteHashOffset);
 
     if (context.environment.isStaticCall) {
@@ -78,7 +77,7 @@ export class EmitNoteHash extends Instruction {
     const noteHash = memory.get(noteHashOffset).toFr();
     context.persistableState.writeNoteHash(context.environment.storageAddress, noteHash);
 
-    memory.assert(memoryOperations);
+    memory.assert({ reads: 1, addressing });
     context.machineState.incrementPc();
   }
 }
@@ -105,14 +104,12 @@ export class NullifierExists extends Instruction {
   }
 
   public async execute(context: AvmContext): Promise<void> {
-    const memoryOperations = { reads: 2, writes: 1, indirect: this.indirect };
     const memory = context.machineState.memory.track(this.type);
-    context.machineState.consumeGas(this.gasCost(memoryOperations));
+    context.machineState.consumeGas(this.gasCost());
 
-    const [nullifierOffset, addressOffset, existsOffset] = Addressing.fromWire(this.indirect).resolve(
-      [this.nullifierOffset, this.addressOffset, this.existsOffset],
-      memory,
-    );
+    const operands = [this.nullifierOffset, this.addressOffset, this.existsOffset];
+    const addressing = Addressing.fromWire(this.indirect, operands.length);
+    const [nullifierOffset, addressOffset, existsOffset] = addressing.resolve(operands, memory);
     memory.checkTags(TypeTag.FIELD, nullifierOffset, addressOffset);
 
     const nullifier = memory.get(nullifierOffset).toFr();
@@ -121,7 +118,7 @@ export class NullifierExists extends Instruction {
 
     memory.set(existsOffset, exists ? new Uint8(1) : new Uint8(0));
 
-    memory.assert(memoryOperations);
+    memory.assert({ reads: 2, writes: 1, addressing });
     context.machineState.incrementPc();
   }
 }
@@ -141,11 +138,12 @@ export class EmitNullifier extends Instruction {
       throw new StaticCallAlterationError();
     }
 
-    const memoryOperations = { reads: 1, indirect: this.indirect };
     const memory = context.machineState.memory.track(this.type);
-    context.machineState.consumeGas(this.gasCost(memoryOperations));
+    context.machineState.consumeGas(this.gasCost());
 
-    const [nullifierOffset] = Addressing.fromWire(this.indirect).resolve([this.nullifierOffset], memory);
+    const operands = [this.nullifierOffset];
+    const addressing = Addressing.fromWire(this.indirect, operands.length);
+    const [nullifierOffset] = addressing.resolve(operands, memory);
     memory.checkTag(TypeTag.FIELD, nullifierOffset);
 
     const nullifier = memory.get(nullifierOffset).toFr();
@@ -162,7 +160,7 @@ export class EmitNullifier extends Instruction {
       }
     }
 
-    memory.assert(memoryOperations);
+    memory.assert({ reads: 1, addressing });
     context.machineState.incrementPc();
   }
 }
@@ -189,14 +187,12 @@ export class L1ToL2MessageExists extends Instruction {
   }
 
   public async execute(context: AvmContext): Promise<void> {
-    const memoryOperations = { reads: 2, writes: 1, indirect: this.indirect };
     const memory = context.machineState.memory.track(this.type);
-    context.machineState.consumeGas(this.gasCost(memoryOperations));
+    context.machineState.consumeGas(this.gasCost());
 
-    const [msgHashOffset, msgLeafIndexOffset, existsOffset] = Addressing.fromWire(this.indirect).resolve(
-      [this.msgHashOffset, this.msgLeafIndexOffset, this.existsOffset],
-      memory,
-    );
+    const operands = [this.msgHashOffset, this.msgLeafIndexOffset, this.existsOffset];
+    const addressing = Addressing.fromWire(this.indirect, operands.length);
+    const [msgHashOffset, msgLeafIndexOffset, existsOffset] = addressing.resolve(operands, memory);
     memory.checkTags(TypeTag.FIELD, msgHashOffset, msgLeafIndexOffset);
 
     const msgHash = memory.get(msgHashOffset).toFr();
@@ -208,7 +204,7 @@ export class L1ToL2MessageExists extends Instruction {
     );
     memory.set(existsOffset, exists ? new Uint8(1) : new Uint8(0));
 
-    memory.assert(memoryOperations);
+    memory.assert({ reads: 2, writes: 1, addressing });
     context.machineState.incrementPc();
   }
 }
@@ -230,22 +226,20 @@ export class EmitUnencryptedLog extends Instruction {
 
     const memory = context.machineState.memory.track(this.type);
 
-    const [logOffset, logSizeOffset] = Addressing.fromWire(this.indirect).resolve(
-      [this.logOffset, this.logSizeOffset],
-      memory,
-    );
+    const operands = [this.logOffset, this.logSizeOffset];
+    const addressing = Addressing.fromWire(this.indirect, operands.length);
+    const [logOffset, logSizeOffset] = addressing.resolve(operands, memory);
     memory.checkTag(TypeTag.UINT32, logSizeOffset);
     const logSize = memory.get(logSizeOffset).toNumber();
     memory.checkTagsRange(TypeTag.FIELD, logOffset, logSize);
 
     const contractAddress = context.environment.address;
 
-    const memoryOperations = { reads: 1 + logSize, indirect: this.indirect };
-    context.machineState.consumeGas(this.gasCost({ ...memoryOperations, dynMultiplier: logSize }));
+    context.machineState.consumeGas(this.gasCost(logSize));
     const log = memory.getSlice(logOffset, logSize).map(f => f.toFr());
     context.persistableState.writeUnencryptedLog(contractAddress, log);
 
-    memory.assert(memoryOperations);
+    memory.assert({ reads: 1 + logSize, addressing });
     context.machineState.incrementPc();
   }
 }
@@ -265,20 +259,18 @@ export class SendL2ToL1Message extends Instruction {
       throw new StaticCallAlterationError();
     }
 
-    const memoryOperations = { reads: 2, indirect: this.indirect };
     const memory = context.machineState.memory.track(this.type);
-    context.machineState.consumeGas(this.gasCost(memoryOperations));
+    context.machineState.consumeGas(this.gasCost());
 
-    const [recipientOffset, contentOffset] = Addressing.fromWire(this.indirect).resolve(
-      [this.recipientOffset, this.contentOffset],
-      memory,
-    );
+    const operands = [this.recipientOffset, this.contentOffset];
+    const addressing = Addressing.fromWire(this.indirect, operands.length);
+    const [recipientOffset, contentOffset] = addressing.resolve(operands, memory);
 
     const recipient = memory.get(recipientOffset).toFr();
     const content = memory.get(contentOffset).toFr();
-    context.persistableState.writeL2ToL1Message(recipient, content);
+    context.persistableState.writeL2ToL1Message(context.environment.address, recipient, content);
 
-    memory.assert(memoryOperations);
+    memory.assert({ reads: 2, addressing });
     context.machineState.incrementPc();
   }
 }

package/src/avm/opcodes/addressing_mode.ts

@@ -3,9 +3,10 @@ import { strict as assert } from 'assert';
 import { type TaggedMemoryInterface } from '../avm_memory_types.js';
 
 export enum AddressingMode {
-  DIRECT,
-  INDIRECT,
-  INDIRECT_PLUS_CONSTANT, // Not implemented yet.
+  DIRECT = 0,
+  INDIRECT = 1,
+  RELATIVE = 2,
+  INDIRECT_RELATIVE = 3,
 }
 
 /** A class to represent the addressing mode of an instruction. */
@@ -13,16 +14,17 @@ export class Addressing {
   public constructor(
     /** The addressing mode for each operand. The length of this array is the number of operands of the instruction. */
     private readonly modePerOperand: AddressingMode[],
-  ) {
-    assert(modePerOperand.length <= 8, 'At most 8 operands are supported');
-  }
+  ) {}
 
-  public static fromWire(wireModes: number): Addressing {
+  // TODO(facundo): 8 for backwards compatibility.
+  public static fromWire(wireModes: number, numOperands: number = 8): Addressing {
     // The modes are stored in the wire format as a byte, with each bit representing the mode for an operand.
     // The least significant bit represents the zeroth operand, and the most significant bit represents the last operand.
-    const modes = new Array<AddressingMode>(8);
-    for (let i = 0; i < 8; i++) {
-      modes[i] = (wireModes & (1 << i)) === 0 ? AddressingMode.DIRECT : AddressingMode.INDIRECT;
+    const modes = new Array<AddressingMode>(numOperands);
+    for (let i = 0; i < numOperands; i++) {
+      modes[i] =
+        (((wireModes >> i) & 1) * AddressingMode.INDIRECT) |
+        (((wireModes >> (i + numOperands)) & 1) * AddressingMode.RELATIVE);
     }
     return new Addressing(modes);
   }
@@ -31,17 +33,20 @@ export class Addressing {
     // The modes are stored in the wire format as a byte, with each bit representing the mode for an operand.
     // The least significant bit represents the zeroth operand, and the least significant bit represents the last operand.
     let wire: number = 0;
-    for (let i = 0; i < 8; i++) {
-      if (this.modePerOperand[i] === AddressingMode.INDIRECT) {
+    for (let i = 0; i < this.modePerOperand.length; i++) {
+      if (this.modePerOperand[i] & AddressingMode.INDIRECT) {
         wire |= 1 << i;
       }
+      if (this.modePerOperand[i] & AddressingMode.RELATIVE) {
+        wire |= 1 << (this.modePerOperand.length + i);
+      }
     }
     return wire;
   }
 
   /** Returns how many operands use the given addressing mode. */
   public count(mode: AddressingMode): number {
-    return this.modePerOperand.filter(m => m === mode).length;
+    return this.modePerOperand.filter(m => (m & mode) !== 0).length;
   }
 
   /**
@@ -54,17 +59,15 @@ export class Addressing {
     assert(offsets.length <= this.modePerOperand.length);
     const resolved = new Array(offsets.length);
     for (const [i, offset] of offsets.entries()) {
-      switch (this.modePerOperand[i]) {
-        case AddressingMode.INDIRECT:
-          // NOTE(reviewer): less than equal is a deviation from the spec - i dont see why this shouldnt be possible!
-          mem.checkIsValidMemoryOffsetTag(offset);
-          resolved[i] = Number(mem.get(offset).toBigInt());
-          break;
-        case AddressingMode.DIRECT:
-          resolved[i] = offset;
-          break;
-        default:
-          throw new Error(`Unimplemented addressing mode: ${AddressingMode[this.modePerOperand[i]]}`);
+      const mode = this.modePerOperand[i];
+      resolved[i] = offset;
+      if (mode & AddressingMode.RELATIVE) {
+        mem.checkIsValidMemoryOffsetTag(0);
+        resolved[i] += Number(mem.get(0).toBigInt());
+      }
+      if (mode & AddressingMode.INDIRECT) {
+        mem.checkIsValidMemoryOffsetTag(resolved[i]);
+        resolved[i] = Number(mem.get(resolved[i]).toBigInt());
       }
     }
     return resolved;

package/src/avm/opcodes/arithmetic.ts

@@ -6,14 +6,12 @@ import { ThreeOperandInstruction } from './instruction_impl.js';
 
 export abstract class ThreeOperandArithmeticInstruction extends ThreeOperandInstruction {
   public async execute(context: AvmContext): Promise<void> {
-    const memoryOperations = { reads: 2, writes: 1, indirect: this.indirect };
     const memory = context.machineState.memory.track(this.type);
-    context.machineState.consumeGas(this.gasCost(memoryOperations));
+    context.machineState.consumeGas(this.gasCost());
 
-    const [aOffset, bOffset, dstOffset] = Addressing.fromWire(this.indirect).resolve(
-      [this.aOffset, this.bOffset, this.dstOffset],
-      memory,
-    );
+    const operands = [this.aOffset, this.bOffset, this.dstOffset];
+    const addressing = Addressing.fromWire(this.indirect, operands.length);
+    const [aOffset, bOffset, dstOffset] = addressing.resolve(operands, memory);
     memory.checkTags(this.inTag, aOffset, bOffset);
 
     const a = memory.get(aOffset);
@@ -22,7 +20,7 @@ export abstract class ThreeOperandArithmeticInstruction extends ThreeOperandInst
     const dest = this.compute(a, b);
     memory.set(dstOffset, dest);
 
-    memory.assert(memoryOperations);
+    memory.assert({ reads: 2, writes: 1, addressing });
     context.machineState.incrementPc();
   }
 

package/src/avm/opcodes/bitwise.ts

@@ -7,14 +7,12 @@ import { ThreeOperandInstruction } from './instruction_impl.js';
 
 abstract class ThreeOperandBitwiseInstruction extends ThreeOperandInstruction {
   public async execute(context: AvmContext): Promise<void> {
-    const memoryOperations = { reads: 2, writes: 1, indirect: this.indirect };
     const memory = context.machineState.memory.track(this.type);
-    context.machineState.consumeGas(this.gasCost(memoryOperations));
+    context.machineState.consumeGas(this.gasCost());
 
-    const [aOffset, bOffset, dstOffset] = Addressing.fromWire(this.indirect).resolve(
-      [this.aOffset, this.bOffset, this.dstOffset],
-      memory,
-    );
+    const operands = [this.aOffset, this.bOffset, this.dstOffset];
+    const addressing = Addressing.fromWire(this.indirect, operands.length);
+    const [aOffset, bOffset, dstOffset] = addressing.resolve(operands, memory);
     this.checkTags(memory, this.inTag, aOffset, bOffset);
 
     const a = memory.getAs<IntegralValue>(aOffset);
@@ -23,7 +21,7 @@ abstract class ThreeOperandBitwiseInstruction extends ThreeOperandInstruction {
     const res = this.compute(a, b);
     memory.set(dstOffset, res);
 
-    memory.assert(memoryOperations);
+    memory.assert({ reads: 2, writes: 1, addressing });
     context.machineState.incrementPc();
   }
 
@@ -98,18 +96,19 @@ export class Not extends Instruction {
   }
 
   public async execute(context: AvmContext): Promise<void> {
-    const memoryOperations = { reads: 1, writes: 1, indirect: this.indirect };
     const memory = context.machineState.memory.track(this.type);
-    context.machineState.consumeGas(this.gasCost(memoryOperations));
+    context.machineState.consumeGas(this.gasCost());
 
-    const [srcOffset, dstOffset] = Addressing.fromWire(this.indirect).resolve([this.srcOffset, this.dstOffset], memory);
+    const operands = [this.srcOffset, this.dstOffset];
+    const addressing = Addressing.fromWire(this.indirect, operands.length);
+    const [srcOffset, dstOffset] = addressing.resolve(operands, memory);
     TaggedMemory.checkIsIntegralTag(memory.getTag(srcOffset));
     const value = memory.getAs<IntegralValue>(srcOffset);
 
     const res = value.not();
     memory.set(dstOffset, res);
 
-    memory.assert(memoryOperations);
+    memory.assert({ reads: 1, writes: 1, addressing });
     context.machineState.incrementPc();
   }
 }

package/src/avm/opcodes/commitment.ts

@@ -32,10 +32,10 @@ export class PedersenCommitment extends Instruction {
 
   public async execute(context: AvmContext): Promise<void> {
     const memory = context.machineState.memory.track(this.type);
-    const [inputOffset, outputOffset, inputSizeOffset, genIndexOffset] = Addressing.fromWire(this.indirect).resolve(
-      [this.inputOffset, this.outputOffset, this.inputSizeOffset, this.genIndexOffset],
-      memory,
-    );
+
+    const operands = [this.inputOffset, this.outputOffset, this.inputSizeOffset, this.genIndexOffset];
+    const addressing = Addressing.fromWire(this.indirect, operands.length);
+    const [inputOffset, outputOffset, inputSizeOffset, genIndexOffset] = addressing.resolve(operands, memory);
 
     const inputSize = memory.get(inputSizeOffset).toNumber();
     memory.checkTag(TypeTag.UINT32, inputSizeOffset);
@@ -46,8 +46,7 @@ export class PedersenCommitment extends Instruction {
     const generatorIndex = memory.get(genIndexOffset).toNumber();
     memory.checkTag(TypeTag.UINT32, genIndexOffset);
 
-    const memoryOperations = { reads: inputSize + 2, writes: 3, indirect: this.indirect };
-    context.machineState.consumeGas(this.gasCost({ ...memoryOperations, dynMultiplier: inputSize }));
+    context.machineState.consumeGas(this.gasCost(inputSize));
 
     const inputBuffer: Buffer[] = inputs.map(input => input.toBuffer());
     // TODO: Add the generate index to the pedersenCommit function
@@ -60,7 +59,7 @@ export class PedersenCommitment extends Instruction {
     memory.set(outputOffset + 1, commitment[1]); // Field typed
     memory.set(outputOffset + 2, new Uint8(isInfinity ? 1 : 0)); // U8 typed
 
-    memory.assert(memoryOperations);
+    memory.assert({ reads: inputSize + 2, writes: 3, addressing });
     context.machineState.incrementPc();
   }
 }

package/src/avm/opcodes/comparators.ts

@@ -6,14 +6,12 @@ import { ThreeOperandInstruction } from './instruction_impl.js';
 
 abstract class ComparatorInstruction extends ThreeOperandInstruction {
   public async execute(context: AvmContext): Promise<void> {
-    const memoryOperations = { reads: 2, writes: 1, indirect: this.indirect };
     const memory = context.machineState.memory.track(this.type);
-    context.machineState.consumeGas(this.gasCost(memoryOperations));
+    context.machineState.consumeGas(this.gasCost());
 
-    const [aOffset, bOffset, dstOffset] = Addressing.fromWire(this.indirect).resolve(
-      [this.aOffset, this.bOffset, this.dstOffset],
-      memory,
-    );
+    const operands = [this.aOffset, this.bOffset, this.dstOffset];
+    const addressing = Addressing.fromWire(this.indirect, operands.length);
+    const [aOffset, bOffset, dstOffset] = addressing.resolve(operands, memory);
     memory.checkTags(this.inTag, aOffset, bOffset);
 
     const a = memory.get(aOffset);
@@ -22,7 +20,7 @@ abstract class ComparatorInstruction extends ThreeOperandInstruction {
     const dest = new Uint1(this.compare(a, b) ? 1 : 0);
     memory.set(dstOffset, dest);
 
-    memory.assert(memoryOperations);
+    memory.assert({ reads: 2, writes: 1, addressing });
     context.machineState.incrementPc();
   }
 

package/src/avm/opcodes/contract.ts

@@ -22,14 +22,12 @@ 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));
+    context.machineState.consumeGas(this.gasCost());
 
-    const [addressOffset, dstOffset] = Addressing.fromWire(this.indirect).resolve(
-      [this.addressOffset, this.dstOffset],
-      memory,
-    );
+    const operands = [this.addressOffset, this.dstOffset];
+    const addressing = Addressing.fromWire(this.indirect, operands.length);
+    const [addressOffset, dstOffset] = addressing.resolve(operands, memory);
     memory.checkTag(TypeTag.FIELD, addressOffset);
 
     const address = memory.get(addressOffset).toFr();
@@ -46,7 +44,7 @@ export class GetContractInstance extends Instruction {
 
     memory.setSlice(dstOffset, data);
 
-    memory.assert(memoryOperations);
+    memory.assert({ reads: 1, writes: 6, addressing });
     context.machineState.incrementPc();
   }
 }

package/src/avm/opcodes/control_flow.ts

@@ -41,21 +41,21 @@ export class JumpI extends Instruction {
   }
 
   public async execute(context: AvmContext): Promise<void> {
-    const memoryOperations = { reads: 1, indirect: this.indirect };
     const memory = context.machineState.memory.track(this.type);
-    context.machineState.consumeGas(this.gasCost(memoryOperations));
+    context.machineState.consumeGas(this.gasCost());
 
-    const [condOffset] = Addressing.fromWire(this.indirect).resolve([this.condOffset], memory);
+    const operands = [this.condOffset];
+    const addressing = Addressing.fromWire(this.indirect, operands.length);
+    const [condOffset] = addressing.resolve(operands, memory);
     const condition = memory.getAs<IntegralValue>(condOffset);
 
-    // TODO: reconsider this casting
     if (condition.toBigInt() == 0n) {
       context.machineState.incrementPc();
     } else {
       context.machineState.pc = this.loc;
     }
 
-    memory.assert(memoryOperations);
+    memory.assert({ reads: 1, addressing });
   }
 }
 

package/src/avm/opcodes/conversion.ts

@@ -17,7 +17,7 @@ export class ToRadixLE extends Instruction {
     OperandType.UINT32, // dst memory address
     OperandType.UINT32, // radix memory address
     OperandType.UINT32, // number of limbs (Immediate)
-    OperandType.UINT1, // output is in "bits" mode (Immediate - Uint1 still takes up a whole byte)
+    OperandType.UINT8, // output is in "bits" mode (Immediate - Uint1 still takes up a whole byte)
   ];
 
   constructor(
@@ -33,12 +33,10 @@ export class ToRadixLE extends Instruction {
 
   public async execute(context: AvmContext): Promise<void> {
     const memory = context.machineState.memory.track(this.type);
-    const [srcOffset, dstOffset, radixOffset] = Addressing.fromWire(this.indirect).resolve(
-      [this.srcOffset, this.dstOffset, this.radixOffset],
-      memory,
-    );
-    const memoryOperations = { reads: 2, writes: this.numLimbs, indirect: this.indirect };
-    context.machineState.consumeGas(this.gasCost({ ...memoryOperations, dynMultiplier: this.numLimbs }));
+    const operands = [this.srcOffset, this.dstOffset, this.radixOffset];
+    const addressing = Addressing.fromWire(this.indirect, operands.length);
+    const [srcOffset, dstOffset, radixOffset] = addressing.resolve(operands, memory);
+    context.machineState.consumeGas(this.gasCost(this.numLimbs));
 
     // The radix gadget only takes in a Field
     memory.checkTag(TypeTag.FIELD, srcOffset);
@@ -62,7 +60,7 @@ export class ToRadixLE extends Instruction {
     const res = limbArray.map(byte => new outputType(byte));
     memory.setSlice(dstOffset, res);
 
-    memory.assert(memoryOperations);
+    memory.assert({ reads: 2, writes: this.numLimbs, addressing });
     context.machineState.incrementPc();
   }
 }

package/src/avm/opcodes/ec_add.ts

@@ -14,7 +14,7 @@ export class EcAdd extends Instruction {
   // Informs (de)serialization. See Instruction.deserialize.
   static readonly wireFormat: OperandType[] = [
     OperandType.UINT8, // reserved
-    OperandType.UINT8, // indirect
+    OperandType.UINT16, // indirect
     OperandType.UINT32, // p1X
     OperandType.UINT32, // p1Y
     OperandType.UINT32, // p1IsInfinite
@@ -38,23 +38,21 @@ export class EcAdd extends Instruction {
   }
 
   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));
+    context.machineState.consumeGas(this.gasCost());
 
+    const operands = [
+      this.p1XOffset,
+      this.p1YOffset,
+      this.p1IsInfiniteOffset,
+      this.p2XOffset,
+      this.p2YOffset,
+      this.p2IsInfiniteOffset,
+      this.dstOffset,
+    ];
+    const addressing = Addressing.fromWire(this.indirect, operands.length);
     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,
-      );
+      addressing.resolve(operands, memory);
 
     const p1X = memory.get(p1XOffset);
     const p1Y = memory.get(p1YOffset);
@@ -86,7 +84,7 @@ export class EcAdd extends Instruction {
     // Check representation of infinity for grumpkin
     memory.set(dstOffset + 2, new Field(dest.equals(Point.ZERO) ? 1 : 0));
 
-    memory.assert(memoryOperations);
+    memory.assert({ reads: 6, writes: 3, addressing });
     context.machineState.incrementPc();
   }
 }

package/src/avm/opcodes/environment_getters.ts

@@ -71,15 +71,16 @@ export class GetEnvVar extends Instruction {
   }
 
   public async execute(context: AvmContext): Promise<void> {
-    const memoryOperations = { writes: 1, indirect: this.indirect };
     const memory = context.machineState.memory.track(this.type);
-    context.machineState.consumeGas(this.gasCost(memoryOperations));
+    context.machineState.consumeGas(this.gasCost());
 
-    const [dstOffset] = Addressing.fromWire(this.indirect).resolve([this.dstOffset], memory);
+    const operands = [this.dstOffset];
+    const addressing = Addressing.fromWire(this.indirect, operands.length);
+    const [dstOffset] = addressing.resolve(operands, memory);
 
     memory.set(dstOffset, getValue(this.varEnum, context));
 
-    memory.assert(memoryOperations);
+    memory.assert({ writes: 1, addressing });
     context.machineState.incrementPc();
   }
 }