@aztec/simulator 0.86.0 → 0.87.0

package/src/public/avm/opcodes/accrued_substate.ts

@@ -29,9 +29,10 @@ export class NoteHashExists extends Instruction {
 
   public async execute(context: AvmContext): Promise<void> {
     const memory = context.machineState.memory;
+    const addressing = Addressing.fromWire(this.indirect);
+
     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);
 
@@ -50,16 +51,20 @@ export class EmitNoteHash extends Instruction {
   // Informs (de)serialization. See Instruction.deserialize.
   static readonly wireFormat = [OperandType.UINT8, OperandType.UINT8, OperandType.UINT16];
 
-  constructor(private indirect: number, private noteHashOffset: number) {
+  constructor(
+    private indirect: number,
+    private noteHashOffset: number,
+  ) {
     super();
   }
 
   public async execute(context: AvmContext): Promise<void> {
     const memory = context.machineState.memory;
+    const addressing = Addressing.fromWire(this.indirect);
+
     context.machineState.consumeGas(this.gasCost());
 
     const operands = [this.noteHashOffset];
-    const addressing = Addressing.fromWire(this.indirect, operands.length);
     const [noteHashOffset] = addressing.resolve(operands, memory);
     memory.checkTag(TypeTag.FIELD, noteHashOffset);
 
@@ -95,10 +100,11 @@ export class NullifierExists extends Instruction {
 
   public async execute(context: AvmContext): Promise<void> {
     const memory = context.machineState.memory;
+    const addressing = Addressing.fromWire(this.indirect);
+
     context.machineState.consumeGas(this.gasCost());
 
     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);
 
@@ -116,7 +122,10 @@ export class EmitNullifier extends Instruction {
   // Informs (de)serialization. See Instruction.deserialize.
   static readonly wireFormat = [OperandType.UINT8, OperandType.UINT8, OperandType.UINT16];
 
-  constructor(private indirect: number, private nullifierOffset: number) {
+  constructor(
+    private indirect: number,
+    private nullifierOffset: number,
+  ) {
     super();
   }
 
@@ -126,10 +135,11 @@ export class EmitNullifier extends Instruction {
     }
 
     const memory = context.machineState.memory;
+    const addressing = Addressing.fromWire(this.indirect);
+
     context.machineState.consumeGas(this.gasCost());
 
     const operands = [this.nullifierOffset];
-    const addressing = Addressing.fromWire(this.indirect, operands.length);
     const [nullifierOffset] = addressing.resolve(operands, memory);
     memory.checkTag(TypeTag.FIELD, nullifierOffset);
 
@@ -172,10 +182,11 @@ export class L1ToL2MessageExists extends Instruction {
 
   public async execute(context: AvmContext): Promise<void> {
     const memory = context.machineState.memory;
+    const addressing = Addressing.fromWire(this.indirect);
+
     context.machineState.consumeGas(this.gasCost());
 
     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);
 
@@ -193,7 +204,11 @@ export class EmitUnencryptedLog extends Instruction {
   // Informs (de)serialization. See Instruction.deserialize.
   static readonly wireFormat = [OperandType.UINT8, OperandType.UINT8, OperandType.UINT16, OperandType.UINT16];
 
-  constructor(private indirect: number, private logOffset: number, private logSizeOffset: number) {
+  constructor(
+    private indirect: number,
+    private logOffset: number,
+    private logSizeOffset: number,
+  ) {
     super();
   }
 
@@ -203,9 +218,9 @@ export class EmitUnencryptedLog extends Instruction {
     }
 
     const memory = context.machineState.memory;
+    const addressing = Addressing.fromWire(this.indirect);
 
     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();
@@ -225,7 +240,11 @@ export class SendL2ToL1Message extends Instruction {
   // Informs (de)serialization. See Instruction.deserialize.
   static readonly wireFormat = [OperandType.UINT8, OperandType.UINT8, OperandType.UINT16, OperandType.UINT16];
 
-  constructor(private indirect: number, private recipientOffset: number, private contentOffset: number) {
+  constructor(
+    private indirect: number,
+    private recipientOffset: number,
+    private contentOffset: number,
+  ) {
     super();
   }
 
@@ -235,10 +254,11 @@ export class SendL2ToL1Message extends Instruction {
     }
 
     const memory = context.machineState.memory;
+    const addressing = Addressing.fromWire(this.indirect);
+
     context.machineState.consumeGas(this.gasCost());
 
     const operands = [this.recipientOffset, this.contentOffset];
-    const addressing = Addressing.fromWire(this.indirect, operands.length);
     const [recipientOffset, contentOffset] = addressing.resolve(operands, memory);
     memory.checkTags(TypeTag.FIELD, recipientOffset, contentOffset);
 

package/src/public/avm/opcodes/addressing_mode.ts

@@ -1,4 +1,6 @@
-import { strict as assert } from 'assert';
+import { AVM_MAX_OPERANDS } from '@aztec/constants';
+import { padArrayEnd } from '@aztec/foundation/collection';
+import type { Tuple } from '@aztec/foundation/serialize';
 
 import { TaggedMemory, type TaggedMemoryInterface } from '../avm_memory_types.js';
 import { RelativeAddressOutOfRangeError } from '../errors.js';
@@ -13,21 +15,28 @@ export enum AddressingMode {
 /** A class to represent the addressing mode of an instruction. */
 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[],
+    /** The addressing mode for each possible operand. */
+    private readonly modePerOperand: Tuple<AddressingMode, typeof AVM_MAX_OPERANDS>,
   ) {}
 
-  // 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>(numOperands);
-    for (let i = 0; i < numOperands; i++) {
+  public static fromModes(modes: AddressingMode[]): Addressing {
+    if (modes.length > AVM_MAX_OPERANDS) {
+      throw new Error('Too many operands for addressing mode');
+    }
+    return new Addressing(padArrayEnd(modes, AddressingMode.DIRECT, AVM_MAX_OPERANDS));
+  }
+
+  public static fromWire(wireModes: number): Addressing {
+    // The modes are stored in the wire format as one or two bytes, with each two bits representing the modes for an operand.
+    // Even bits are indirect, odd bits are relative.
+    const modes = new Array<AddressingMode>(AVM_MAX_OPERANDS);
+    for (let i = 0; i < AVM_MAX_OPERANDS; i++) {
       modes[i] =
-        (((wireModes >> i) & 1) * AddressingMode.INDIRECT) |
-        (((wireModes >> (i + numOperands)) & 1) * AddressingMode.RELATIVE);
+        (((wireModes >> (i * 2)) & 1) * AddressingMode.INDIRECT) |
+        (((wireModes >> (i * 2 + 1)) & 1) * AddressingMode.RELATIVE);
     }
-    return new Addressing(modes);
+    // Casting the array to tuple since it should be more performant than using makeTuple
+    return new Addressing(modes as Tuple<AddressingMode, typeof AVM_MAX_OPERANDS>);
   }
 
   public toWire(): number {
@@ -36,20 +45,15 @@ export class Addressing {
     let wire: number = 0;
     for (let i = 0; i < this.modePerOperand.length; i++) {
       if (this.modePerOperand[i] & AddressingMode.INDIRECT) {
-        wire |= 1 << i;
+        wire |= 1 << (i * 2);
       }
       if (this.modePerOperand[i] & AddressingMode.RELATIVE) {
-        wire |= 1 << (this.modePerOperand.length + i);
+        wire |= 1 << (i * 2 + 1);
       }
     }
     return wire;
   }
 
-  /** Returns how many operands use the given addressing mode. */
-  public count(mode: AddressingMode): number {
-    return this.modePerOperand.filter(m => (m & mode) !== 0).length;
-  }
-
   /**
    * Resolves the offsets using the addressing mode.
    * @param offsets The offsets to resolve.
@@ -57,7 +61,6 @@ export class Addressing {
    * @returns The resolved offsets. The length of the returned array is the same as the length of the input array.
    */
   public resolve(offsets: number[], mem: TaggedMemoryInterface): number[] {
-    assert(offsets.length <= this.modePerOperand.length);
     const resolved = new Array(offsets.length);
 
     let didRelativeOnce = false;

package/src/public/avm/opcodes/arithmetic.ts

@@ -14,10 +14,11 @@ import { ThreeOperandInstruction } from './instruction_impl.js';
 export abstract class ThreeOperandArithmeticInstruction extends ThreeOperandInstruction {
   public async execute(context: AvmContext): Promise<void> {
     const memory = context.machineState.memory;
+    const addressing = Addressing.fromWire(this.indirect);
+
     context.machineState.consumeGas(this.gasCost());
 
     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, aOffset, bOffset);
 

package/src/public/avm/opcodes/bitwise.ts

@@ -8,10 +8,11 @@ import { ThreeOperandInstruction } from './instruction_impl.js';
 abstract class ThreeOperandBitwiseInstruction extends ThreeOperandInstruction {
   public async execute(context: AvmContext): Promise<void> {
     const memory = context.machineState.memory;
+    const addressing = Addressing.fromWire(this.indirect);
+
     context.machineState.consumeGas(this.gasCost());
 
     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, aOffset, bOffset);
 
@@ -89,16 +90,21 @@ export class Not extends Instruction {
   static readonly wireFormat8 = [OperandType.UINT8, OperandType.UINT8, OperandType.UINT8, OperandType.UINT8];
   static readonly wireFormat16 = [OperandType.UINT8, OperandType.UINT8, OperandType.UINT16, OperandType.UINT16];
 
-  constructor(private indirect: number, private srcOffset: number, private dstOffset: number) {
+  constructor(
+    private indirect: number,
+    private srcOffset: number,
+    private dstOffset: number,
+  ) {
     super();
   }
 
   public async execute(context: AvmContext): Promise<void> {
     const memory = context.machineState.memory;
+    const addressing = Addressing.fromWire(this.indirect);
+
     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);
     TaggedMemory.checkIsIntegralTag(memory.getTag(srcOffset));
     const value = memory.getAs<IntegralValue>(srcOffset);

package/src/public/avm/opcodes/comparators.ts

@@ -7,10 +7,11 @@ import { ThreeOperandInstruction } from './instruction_impl.js';
 abstract class ComparatorInstruction extends ThreeOperandInstruction {
   public async execute(context: AvmContext): Promise<void> {
     const memory = context.machineState.memory;
+    const addressing = Addressing.fromWire(this.indirect);
+
     context.machineState.consumeGas(this.gasCost());
 
     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.checkTagsAreSame(aOffset, bOffset);
 

package/src/public/avm/opcodes/contract.ts

@@ -20,7 +20,6 @@ export class GetContractInstance extends Instruction {
     OperandType.UINT8, // indirect bits
     OperandType.UINT16, // addressOffset
     OperandType.UINT16, // dstOffset
-    OperandType.UINT16, // existsOfsset
     OperandType.UINT8, // member enum (immediate)
   ];
 
@@ -28,7 +27,6 @@ export class GetContractInstance extends Instruction {
     private indirect: number,
     private addressOffset: number,
     private dstOffset: number,
-    private existsOffset: number,
     private memberEnum: number,
   ) {
     super();
@@ -36,15 +34,16 @@ export class GetContractInstance extends Instruction {
 
   async execute(context: AvmContext): Promise<void> {
     const memory = context.machineState.memory;
+    const addressing = Addressing.fromWire(this.indirect);
+
     context.machineState.consumeGas(this.gasCost());
 
     if (!(this.memberEnum in ContractInstanceMember)) {
       throw new InstructionExecutionError(`Invalid GETCONSTRACTINSTANCE member enum ${this.memberEnum}`);
     }
 
-    const operands = [this.addressOffset, this.dstOffset, this.existsOffset];
-    const addressing = Addressing.fromWire(this.indirect, operands.length);
-    const [addressOffset, dstOffset, existsOffset] = addressing.resolve(operands, memory);
+    const operands = [this.addressOffset, this.dstOffset];
+    const [addressOffset, dstOffset] = addressing.resolve(operands, memory);
     memory.checkTag(TypeTag.FIELD, addressOffset);
 
     const address = memory.get(addressOffset).toAztecAddress();
@@ -66,7 +65,9 @@ export class GetContractInstance extends Instruction {
       }
     }
 
+    const existsOffset = dstOffset;
+    const memberValueOffset = dstOffset + 1;
     memory.set(existsOffset, new Uint1(exists ? 1 : 0));
-    memory.set(dstOffset, memberValue);
+    memory.set(memberValueOffset, memberValue);
   }
 }

package/src/public/avm/opcodes/control_flow.ts

@@ -38,16 +38,21 @@ export class JumpI extends Instruction {
     OperandType.UINT32,
   ];
 
-  constructor(private indirect: number, private condOffset: number, private loc: number) {
+  constructor(
+    private indirect: number,
+    private condOffset: number,
+    private loc: number,
+  ) {
     super();
   }
 
   public async execute(context: AvmContext): Promise<void> {
     const memory = context.machineState.memory;
+    const addressing = Addressing.fromWire(this.indirect);
+
     context.machineState.consumeGas(this.gasCost());
 
     const operands = [this.condOffset];
-    const addressing = Addressing.fromWire(this.indirect, operands.length);
     const [condOffset] = addressing.resolve(operands, memory);
     const condition = memory.getAs<IntegralValue>(condOffset);
 

package/src/public/avm/opcodes/conversion.ts

@@ -33,8 +33,9 @@ export class ToRadixBE extends Instruction {
 
   public async execute(context: AvmContext): Promise<void> {
     const memory = context.machineState.memory;
+    const addressing = Addressing.fromWire(this.indirect);
+
     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);
 
     // The radix gadget only takes in a Field

package/src/public/avm/opcodes/ec_add.ts

@@ -39,6 +39,8 @@ export class EcAdd extends Instruction {
 
   public async execute(context: AvmContext): Promise<void> {
     const memory = context.machineState.memory;
+    const addressing = Addressing.fromWire(this.indirect);
+
     context.machineState.consumeGas(this.gasCost());
 
     const operands = [
@@ -50,7 +52,6 @@ export class EcAdd extends Instruction {
       this.p2IsInfiniteOffset,
       this.dstOffset,
     ];
-    const addressing = Addressing.fromWire(this.indirect, operands.length);
     const [p1XOffset, p1YOffset, p1IsInfiniteOffset, p2XOffset, p2YOffset, p2IsInfiniteOffset, dstOffset] =
       addressing.resolve(operands, memory);
 

package/src/public/avm/opcodes/environment_getters.ts

@@ -61,12 +61,18 @@ export class GetEnvVar extends Instruction {
     OperandType.UINT8, // variable enum (immediate)
   ];
 
-  constructor(private indirect: number, private dstOffset: number, private varEnum: number) {
+  constructor(
+    private indirect: number,
+    private dstOffset: number,
+    private varEnum: number,
+  ) {
     super();
   }
 
   public async execute(context: AvmContext): Promise<void> {
     const memory = context.machineState.memory;
+    const addressing = Addressing.fromWire(this.indirect);
+
     context.machineState.consumeGas(this.gasCost());
 
     if (!(this.varEnum in EnvironmentVariable)) {
@@ -74,7 +80,6 @@ export class GetEnvVar extends Instruction {
     }
 
     const operands = [this.dstOffset];
-    const addressing = Addressing.fromWire(this.indirect, operands.length);
     const [dstOffset] = addressing.resolve(operands, memory);
 
     memory.set(dstOffset, getValue(this.varEnum as EnvironmentVariable, context));

package/src/public/avm/opcodes/external_calls.ts

@@ -22,17 +22,18 @@ abstract class ExternalCall extends Instruction {
     private l2GasOffset: number,
     private daGasOffset: number,
     private addrOffset: number,
-    private argsOffset: number,
     private argsSizeOffset: number,
+    private argsOffset: number,
   ) {
     super();
   }
 
   public async execute(context: AvmContext) {
     const memory = context.machineState.memory;
-    const operands = [this.l2GasOffset, this.daGasOffset, this.addrOffset, this.argsOffset, this.argsSizeOffset];
-    const addressing = Addressing.fromWire(this.indirect, operands.length);
-    const [l2GasOffset, daGasOffset, addrOffset, argsOffset, argsSizeOffset] = addressing.resolve(operands, memory);
+    const addressing = Addressing.fromWire(this.indirect);
+
+    const operands = [this.l2GasOffset, this.daGasOffset, this.addrOffset, this.argsSizeOffset, this.argsOffset];
+    const [l2GasOffset, daGasOffset, addrOffset, argsSizeOffset, argsOffset] = addressing.resolve(operands, memory);
     // TODO: Should be U32
     memory.checkTags(TypeTag.FIELD, l2GasOffset);
     memory.checkTags(TypeTag.FIELD, daGasOffset);
@@ -133,15 +134,18 @@ export class SuccessCopy extends Instruction {
     OperandType.UINT16, // dstOffset (16-bit)
   ];
 
-  constructor(private indirect: number, private dstOffset: number) {
+  constructor(
+    private indirect: number,
+    private dstOffset: number,
+  ) {
     super();
   }
 
   public async execute(context: AvmContext): Promise<void> {
     const memory = context.machineState.memory;
+    const addressing = Addressing.fromWire(this.indirect);
 
     const operands = [this.dstOffset];
-    const addressing = Addressing.fromWire(this.indirect, operands.length);
     const [dstOffset] = addressing.resolve(operands, memory);
 
     // Use the direct success tracking property
@@ -163,16 +167,20 @@ export class Return extends Instruction {
     OperandType.UINT16,
   ];
 
-  constructor(private indirect: number, private returnOffset: number, private returnSizeOffset: number) {
+  constructor(
+    private indirect: number,
+    private returnSizeOffset: number,
+    private returnOffset: number,
+  ) {
     super();
   }
 
   public async execute(context: AvmContext): Promise<void> {
     const memory = context.machineState.memory;
+    const addressing = Addressing.fromWire(this.indirect);
 
-    const operands = [this.returnOffset, this.returnSizeOffset];
-    const addressing = Addressing.fromWire(this.indirect, operands.length);
-    const [returnOffset, returnSizeOffset] = addressing.resolve(operands, memory);
+    const operands = [this.returnSizeOffset, this.returnOffset];
+    const [returnSizeOffset, returnOffset] = addressing.resolve(operands, memory);
 
     memory.checkTag(TypeTag.UINT32, returnSizeOffset);
     const returnSize = memory.get(returnSizeOffset).toNumber();
@@ -205,16 +213,20 @@ export class Revert extends Instruction {
     OperandType.UINT16,
   ];
 
-  constructor(private indirect: number, private returnOffset: number, private retSizeOffset: number) {
+  constructor(
+    private indirect: number,
+    private retSizeOffset: number,
+    private returnOffset: number,
+  ) {
     super();
   }
 
   public async execute(context: AvmContext): Promise<void> {
     const memory = context.machineState.memory;
+    const addressing = Addressing.fromWire(this.indirect);
 
-    const operands = [this.returnOffset, this.retSizeOffset];
-    const addressing = Addressing.fromWire(this.indirect, operands.length);
-    const [returnOffset, retSizeOffset] = addressing.resolve(operands, memory);
+    const operands = [this.retSizeOffset, this.returnOffset];
+    const [retSizeOffset, returnOffset] = addressing.resolve(operands, memory);
 
     memory.checkTag(TypeTag.UINT32, retSizeOffset);
     const retSize = memory.get(retSizeOffset).toNumber();

package/src/public/avm/opcodes/hashing.ts

@@ -19,16 +19,22 @@ export class Poseidon2 extends Instruction {
     OperandType.UINT16,
   ];
 
-  constructor(private indirect: number, private inputStateOffset: number, private outputStateOffset: number) {
+  constructor(
+    private indirect: number,
+    private inputStateOffset: number,
+    private outputStateOffset: number,
+  ) {
     super();
   }
 
   public async execute(context: AvmContext): Promise<void> {
     const memory = context.machineState.memory;
+    const addressing = Addressing.fromWire(this.indirect);
+
     context.machineState.consumeGas(this.gasCost());
 
     const operands = [this.inputStateOffset, this.outputStateOffset];
-    const addressing = Addressing.fromWire(this.indirect, operands.length);
+
     const [inputOffset, outputOffset] = addressing.resolve(operands, memory);
 
     const inputState = memory.getSlice(inputOffset, Poseidon2.stateSize);
@@ -54,7 +60,11 @@ export class KeccakF1600 extends Instruction {
     OperandType.UINT16,
   ];
 
-  constructor(private indirect: number, private dstOffset: number, private inputOffset: number) {
+  constructor(
+    private indirect: number,
+    private dstOffset: number,
+    private inputOffset: number,
+  ) {
     super();
   }
 
@@ -62,8 +72,9 @@ export class KeccakF1600 extends Instruction {
   public async execute(context: AvmContext): Promise<void> {
     const inputSize = 25;
     const memory = context.machineState.memory;
+    const addressing = Addressing.fromWire(this.indirect);
+
     const operands = [this.dstOffset, this.inputOffset];
-    const addressing = Addressing.fromWire(this.indirect, operands.length);
     const [dstOffset, inputOffset] = addressing.resolve(operands, memory);
     context.machineState.consumeGas(this.gasCost());
 
@@ -104,8 +115,9 @@ export class Sha256Compression extends Instruction {
     const INPUTS_SIZE = 16;
 
     const memory = context.machineState.memory;
+    const addressing = Addressing.fromWire(this.indirect);
+
     const operands = [this.outputOffset, this.stateOffset, this.inputsOffset];
-    const addressing = Addressing.fromWire(this.indirect, operands.length);
     const [outputOffset, stateOffset, inputsOffset] = addressing.resolve(operands, memory);
 
     // Note: size of output is same as size of state