@aztec/simulator 0.62.0 → 0.63.1

package/src/avm/opcodes/arithmetic.ts

@@ -1,5 +1,12 @@
 import type { AvmContext } from '../avm_context.js';
-import { type Field, type MemoryValue } from '../avm_memory_types.js';
+import {
+  type Field,
+  type MemoryValue,
+  TaggedMemory,
+  type TaggedMemoryInterface,
+  TypeTag,
+} from '../avm_memory_types.js';
+import { ArithmeticError } from '../errors.js';
 import { Opcode } from '../serialization/instruction_serialization.js';
 import { Addressing } from './addressing_mode.js';
 import { ThreeOperandInstruction } from './instruction_impl.js';
@@ -12,7 +19,7 @@ export abstract class ThreeOperandArithmeticInstruction extends ThreeOperandInst
     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);
+    this.checkTags(memory, aOffset, bOffset);
 
     const a = memory.get(aOffset);
     const b = memory.get(bOffset);
@@ -21,10 +28,12 @@ export abstract class ThreeOperandArithmeticInstruction extends ThreeOperandInst
     memory.set(dstOffset, dest);
 
     memory.assert({ reads: 2, writes: 1, addressing });
-    context.machineState.incrementPc();
   }
 
   protected abstract compute(a: MemoryValue, b: MemoryValue): MemoryValue;
+  protected checkTags(memory: TaggedMemoryInterface, aOffset: number, bOffset: number) {
+    memory.checkTagsAreSame(aOffset, bOffset);
+  }
 }
 
 export class Add extends ThreeOperandArithmeticInstruction {
@@ -59,11 +68,19 @@ export class Div extends ThreeOperandArithmeticInstruction {
   static readonly opcode = Opcode.DIV_8; // FIXME: needed for gas.
 
   protected compute(a: MemoryValue, b: MemoryValue): MemoryValue {
+    if (b.toBigInt() === 0n) {
+      throw new ArithmeticError('Division by zero');
+    }
+
     return a.div(b);
   }
+
+  protected override checkTags(memory: TaggedMemoryInterface, aOffset: number, bOffset: number) {
+    memory.checkTagsAreSame(aOffset, bOffset);
+    TaggedMemory.checkIsIntegralTag(memory.getTag(aOffset)); // Follows that bOffset tag is also of integral type
+  }
 }
 
-// TODO: This class now temporarily has a tag, until all tags are removed.
 export class FieldDiv extends ThreeOperandArithmeticInstruction {
   static type: string = 'FDIV';
   static readonly opcode = Opcode.FDIV_8; // FIXME: needed for gas.
@@ -72,4 +89,9 @@ export class FieldDiv extends ThreeOperandArithmeticInstruction {
     // return (a as Field).fdiv(b as Field);
     return a.fdiv(b);
   }
+
+  protected override checkTags(memory: TaggedMemoryInterface, aOffset: number, bOffset: number) {
+    memory.checkTagsAreSame(aOffset, bOffset);
+    memory.checkTag(TypeTag.FIELD, aOffset); // Follows that bOffset has also tag of type Field
+  }
 }

package/src/avm/opcodes/bitwise.ts

@@ -22,7 +22,6 @@ abstract class ThreeOperandBitwiseInstruction extends ThreeOperandInstruction {
     memory.set(dstOffset, res);
 
     memory.assert({ reads: 2, writes: 1, addressing });
-    context.machineState.incrementPc();
   }
 
   protected abstract compute(a: IntegralValue, b: IntegralValue): IntegralValue;
@@ -110,6 +109,5 @@ export class Not extends Instruction {
     memory.set(dstOffset, res);
 
     memory.assert({ reads: 1, writes: 1, addressing });
-    context.machineState.incrementPc();
   }
 }

package/src/avm/opcodes/comparators.ts

@@ -21,7 +21,6 @@ abstract class ComparatorInstruction extends ThreeOperandInstruction {
     memory.set(dstOffset, dest);
 
     memory.assert({ reads: 2, writes: 1, addressing });
-    context.machineState.incrementPc();
   }
 
   protected abstract compare(a: MemoryValue, b: MemoryValue): boolean;

package/src/avm/opcodes/contract.ts

@@ -47,7 +47,7 @@ export class GetContractInstance extends Instruction {
     const [addressOffset, dstOffset, existsOffset] = addressing.resolve(operands, memory);
     memory.checkTag(TypeTag.FIELD, addressOffset);
 
-    const address = memory.get(addressOffset).toFr();
+    const address = memory.get(addressOffset).toAztecAddress();
     const instance = await context.persistableState.getContractInstance(address);
     const exists = instance !== undefined;
 
@@ -70,6 +70,5 @@ export class GetContractInstance extends Instruction {
     memory.set(dstOffset, memberValue);
 
     memory.assert({ reads: 1, writes: 2, addressing });
-    context.machineState.incrementPc();
   }
 }

package/src/avm/opcodes/control_flow.ts

@@ -22,6 +22,10 @@ export class Jump extends Instruction {
 
     context.machineState.memory.assert({});
   }
+
+  public override handlesPC(): boolean {
+    return true;
+  }
 }
 
 export class JumpI extends Instruction {
@@ -50,13 +54,17 @@ export class JumpI extends Instruction {
     const condition = memory.getAs<IntegralValue>(condOffset);
 
     if (condition.toBigInt() == 0n) {
-      context.machineState.incrementPc();
+      context.machineState.pc = context.machineState.nextPc;
     } else {
       context.machineState.pc = this.loc;
     }
 
     memory.assert({ reads: 1, addressing });
   }
+
+  public override handlesPC(): boolean {
+    return true;
+  }
 }
 
 export class InternalCall extends Instruction {
@@ -72,11 +80,18 @@ export class InternalCall extends Instruction {
   public async execute(context: AvmContext): Promise<void> {
     context.machineState.consumeGas(this.gasCost());
 
-    context.machineState.internalCallStack.push(context.machineState.pc + 1);
+    context.machineState.internalCallStack.push({
+      callPc: context.machineState.pc,
+      returnPc: context.machineState.nextPc,
+    });
     context.machineState.pc = this.loc;
 
     context.machineState.memory.assert({});
   }
+
+  public override handlesPC(): boolean {
+    return true;
+  }
 }
 
 export class InternalReturn extends Instruction {
@@ -92,12 +107,16 @@ export class InternalReturn extends Instruction {
   public async execute(context: AvmContext): Promise<void> {
     context.machineState.consumeGas(this.gasCost());
 
-    const jumpOffset = context.machineState.internalCallStack.pop();
-    if (jumpOffset === undefined) {
+    const stackEntry = context.machineState.internalCallStack.pop();
+    if (stackEntry === undefined) {
       throw new InstructionExecutionError('Internal call stack empty!');
     }
-    context.machineState.pc = jumpOffset;
+    context.machineState.pc = stackEntry.returnPc;
 
     context.machineState.memory.assert({});
   }
+
+  public override handlesPC(): boolean {
+    return true;
+  }
 }

package/src/avm/opcodes/conversion.ts

@@ -64,6 +64,5 @@ export class ToRadixBE extends Instruction {
     memory.setSlice(dstOffset, res);
 
     memory.assert({ reads: 2, writes: this.numLimbs, addressing });
-    context.machineState.incrementPc();
   }
 }

package/src/avm/opcodes/ec_add.ts

@@ -2,7 +2,7 @@ import { Grumpkin } from '@aztec/circuits.js/barretenberg';
 import { Point } from '@aztec/foundation/fields';
 
 import { type AvmContext } from '../avm_context.js';
-import { Field } from '../avm_memory_types.js';
+import { Field, TypeTag, Uint1 } from '../avm_memory_types.js';
 import { Opcode, OperandType } from '../serialization/instruction_serialization.js';
 import { Addressing } from './addressing_mode.js';
 import { Instruction } from './instruction.js';
@@ -54,6 +54,9 @@ export class EcAdd extends Instruction {
     const [p1XOffset, p1YOffset, p1IsInfiniteOffset, p2XOffset, p2YOffset, p2IsInfiniteOffset, dstOffset] =
       addressing.resolve(operands, memory);
 
+    memory.checkTags(TypeTag.FIELD, p1XOffset, p1YOffset, p2XOffset, p2YOffset);
+    memory.checkTags(TypeTag.UINT1, p1IsInfiniteOffset, p2IsInfiniteOffset);
+
     const p1X = memory.get(p1XOffset);
     const p1Y = memory.get(p1YOffset);
     const p1IsInfinite = memory.get(p1IsInfiniteOffset).toNumber() === 1;
@@ -80,18 +83,12 @@ export class EcAdd extends Instruction {
     } else {
       dest = grumpkin.add(p1, p2);
     }
-    // Temporary,
-    if (p1IsInfinite) {
-      dest = p2;
-    } else if (p2IsInfinite) {
-      dest = p1;
-    }
+
     memory.set(dstOffset, new Field(dest.x));
     memory.set(dstOffset + 1, new Field(dest.y));
     // Check representation of infinity for grumpkin
-    memory.set(dstOffset + 2, new Field(dest.equals(Point.ZERO) ? 1 : 0));
+    memory.set(dstOffset + 2, new Uint1(dest.equals(Point.ZERO) ? 1 : 0));
 
     memory.assert({ reads: 6, writes: 3, addressing });
-    context.machineState.incrementPc();
   }
 }

package/src/avm/opcodes/environment_getters.ts

@@ -83,6 +83,5 @@ export class GetEnvVar extends Instruction {
     memory.set(dstOffset, getValue(this.varEnum as EnvironmentVariable, context));
 
     memory.assert({ writes: 1, addressing });
-    context.machineState.incrementPc();
   }
 }

package/src/avm/opcodes/external_calls.ts

@@ -5,7 +5,6 @@ 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 { RethrownError } from '../errors.js';
 import { Opcode, OperandType } from '../serialization/instruction_serialization.js';
 import { Addressing } from './addressing_mode.js';
 import { Instruction } from './instruction.js';
@@ -65,7 +64,7 @@ abstract class ExternalCall extends Instruction {
     context.machineState.consumeGas(allocatedGas);
 
     const nestedContext = context.createNestedContractCallContext(
-      callAddress.toFr(),
+      callAddress.toAztecAddress(),
       calldata,
       allocatedGas,
       callType,
@@ -76,28 +75,35 @@ abstract class ExternalCall extends Instruction {
     const nestedCallResults: AvmContractCallResult = await simulator.execute();
     const success = !nestedCallResults.reverted;
 
-    // TRANSITIONAL: We rethrow here so that the MESSAGE gets propagated.
-    //               This means that for now, the caller cannot recover from errors.
-    if (!success) {
-      if (!nestedCallResults.revertReason) {
-        throw new Error('A reverted nested call should be assigned a revert reason in the AVM execution loop');
-      }
-      // The nested call's revertReason will be used to track the stack of error causes down to the root.
-      throw new RethrownError(nestedCallResults.revertReason.message, nestedCallResults.revertReason);
-    }
-
     // Save return/revert data for later.
     const fullReturnData = nestedCallResults.output;
     context.machineState.nestedReturndata = fullReturnData;
 
+    // If the nested call reverted, we try to save the reason and the revert data.
+    // This will be used by the caller to try to reconstruct the call stack.
+    // This is only a heuristic and may not always work. It is intended to work
+    // for the case where a nested call reverts and the caller always rethrows
+    // (in Noir code).
+    if (!success) {
+      context.machineState.collectedRevertInfo = {
+        revertDataRepresentative: fullReturnData,
+        recursiveRevertReason: nestedCallResults.revertReason!,
+      };
+    }
+
     // Write our success flag into memory.
     memory.set(successOffset, new Uint1(success ? 1 : 0));
 
     // Refund unused gas
     context.machineState.refundGas(gasLeftToGas(nestedContext.machineState));
 
-    // Accept the nested call's state and trace the nested call
-    await context.persistableState.processNestedCall(
+    // Merge nested call's state and trace based on whether it succeeded.
+    if (success) {
+      context.persistableState.merge(nestedContext.persistableState);
+    } else {
+      context.persistableState.reject(nestedContext.persistableState);
+    }
+    await context.persistableState.traceNestedCall(
       /*nestedState=*/ nestedContext.persistableState,
       /*nestedEnvironment=*/ nestedContext.environment,
       /*startGasLeft=*/ Gas.from(allocatedGas),
@@ -107,7 +113,6 @@ abstract class ExternalCall extends Instruction {
     );
 
     memory.assert({ reads: calldataSize + 4, writes: 1, addressing });
-    context.machineState.incrementPc();
   }
 
   public abstract override get type(): 'CALL' | 'STATICCALL';
@@ -142,22 +147,29 @@ export class Return extends Instruction {
     OperandType.UINT16,
   ];
 
-  constructor(private indirect: number, private returnOffset: number, private copySize: number) {
+  constructor(private indirect: number, private returnOffset: number, private returnSizeOffset: number) {
     super();
   }
 
   public async execute(context: AvmContext): Promise<void> {
     const memory = context.machineState.memory.track(this.type);
-    context.machineState.consumeGas(this.gasCost(this.copySize));
 
-    const operands = [this.returnOffset];
+    const operands = [this.returnOffset, this.returnSizeOffset];
     const addressing = Addressing.fromWire(this.indirect, operands.length);
-    const [returnOffset] = addressing.resolve(operands, memory);
+    const [returnOffset, returnSizeOffset] = addressing.resolve(operands, memory);
+
+    memory.checkTag(TypeTag.UINT32, returnSizeOffset);
+    const returnSize = memory.get(returnSizeOffset).toNumber();
+    context.machineState.consumeGas(this.gasCost(returnSize));
 
-    const output = memory.getSlice(returnOffset, this.copySize).map(word => word.toFr());
+    const output = memory.getSlice(returnOffset, returnSize).map(word => word.toFr());
 
     context.machineState.return(output);
-    memory.assert({ reads: this.copySize, addressing });
+    memory.assert({ reads: returnSize + 1, addressing });
+  }
+
+  public override handlesPC(): boolean {
+    return true;
   }
 }
 
@@ -197,6 +209,12 @@ export class Revert extends Instruction {
     context.machineState.revert(output);
     memory.assert({ reads: retSize + 1, addressing });
   }
+
+  // We don't want to increase the PC after reverting because it breaks messages.
+  // Maybe we can remove this once messages don't depend on PCs.
+  public override handlesPC(): boolean {
+    return true;
+  }
 }
 
 /** Returns the smaller of two bigints. */

package/src/avm/opcodes/hashing.ts

@@ -40,7 +40,6 @@ export class Poseidon2 extends Instruction {
     );
 
     memory.assert({ reads: Poseidon2.stateSize, writes: Poseidon2.stateSize, addressing });
-    context.machineState.incrementPc();
   }
 }
 
@@ -78,7 +77,6 @@ export class KeccakF1600 extends Instruction {
     memory.setSlice(dstOffset, res);
 
     memory.assert({ reads: inputSize, writes: inputSize, addressing });
-    context.machineState.incrementPc();
   }
 }
 
@@ -127,6 +125,5 @@ export class Sha256Compression extends Instruction {
     memory.setSlice(outputOffset, res);
 
     memory.assert({ reads: STATE_SIZE + INPUTS_SIZE, writes: STATE_SIZE, addressing });
-    context.machineState.incrementPc();
   }
 }

package/src/avm/opcodes/instruction.ts

@@ -22,6 +22,13 @@ export abstract class Instruction {
    */
   public abstract execute(context: AvmContext): Promise<void>;
 
+  /**
+   * Whether the instruction will modify the PC itself.
+   */
+  public handlesPC(): boolean {
+    return false;
+  }
+
   /**
    * Generate a string representation of the instruction including
    * the instruction sub-class name all of its flags and operands.

package/src/avm/opcodes/memory.ts

@@ -72,7 +72,6 @@ export class Set extends Instruction {
     memory.set(dstOffset, res);
 
     memory.assert({ writes: 1, addressing });
-    context.machineState.incrementPc();
   }
 }
 
@@ -113,7 +112,6 @@ export class Cast extends Instruction {
     memory.set(dstOffset, casted);
 
     memory.assert({ reads: 1, writes: 1, addressing });
-    context.machineState.incrementPc();
   }
 }
 
@@ -152,7 +150,6 @@ export class Mov extends Instruction {
     memory.set(dstOffset, a);
 
     memory.assert({ reads: 1, writes: 1, addressing });
-    context.machineState.incrementPc();
   }
 }
 
@@ -193,7 +190,6 @@ export class CalldataCopy extends Instruction {
     memory.setSlice(dstOffset, transformedData);
 
     memory.assert({ reads: 2, writes: copySize, addressing });
-    context.machineState.incrementPc();
   }
 }
 
@@ -217,7 +213,6 @@ export class ReturndataSize extends Instruction {
     memory.set(dstOffset, new Uint32(context.machineState.nestedReturndata.length));
 
     memory.assert({ writes: 1, addressing });
-    context.machineState.incrementPc();
   }
 }
 
@@ -260,6 +255,5 @@ export class ReturndataCopy extends Instruction {
     memory.setSlice(dstOffset, transformedData);
 
     memory.assert({ reads: 2, writes: copySize, addressing });
-    context.machineState.incrementPc();
   }
 }

package/src/avm/opcodes/misc.ts

@@ -37,11 +37,12 @@ export class DebugLog extends Instruction {
     const addressing = Addressing.fromWire(this.indirect, operands.length);
     const [messageOffset, fieldsOffset, fieldsSizeOffset] = addressing.resolve(operands, memory);
 
+    memory.checkTag(TypeTag.UINT32, fieldsSizeOffset);
     const fieldsSize = memory.get(fieldsSizeOffset).toNumber();
     memory.checkTagsRange(TypeTag.UINT8, messageOffset, this.messageSize);
     memory.checkTagsRange(TypeTag.FIELD, fieldsOffset, fieldsSize);
 
-    context.machineState.consumeGas(this.gasCost());
+    context.machineState.consumeGas(this.gasCost(this.messageSize + fieldsSize));
 
     const rawMessage = memory.getSlice(messageOffset, this.messageSize);
     const fields = memory.getSlice(fieldsOffset, fieldsSize);
@@ -56,6 +57,5 @@ export class DebugLog extends Instruction {
     DebugLog.logger.verbose(formattedStr);
 
     memory.assert({ reads: 1 + fieldsSize + this.messageSize, addressing });
-    context.machineState.incrementPc();
   }
 }

package/src/avm/opcodes/multi_scalar_mul.ts

@@ -2,7 +2,7 @@ import { Fq, Point } from '@aztec/circuits.js';
 import { Grumpkin } from '@aztec/circuits.js/barretenberg';
 
 import { type AvmContext } from '../avm_context.js';
-import { Field, TypeTag } from '../avm_memory_types.js';
+import { Field, TypeTag, Uint1 } from '../avm_memory_types.js';
 import { InstructionExecutionError } from '../errors.js';
 import { Opcode, OperandType } from '../serialization/instruction_serialization.js';
 import { Addressing } from './addressing_mode.js';
@@ -105,15 +105,16 @@ export class MultiScalarMul extends Instruction {
         return grumpkin.add(acc, grumpkin.mul(curr[0], curr[1]));
       }
     }, grumpkin.mul(firstBaseScalarPair[0], firstBaseScalarPair[1]));
-    const output = outputPoint.toFields().map(f => new Field(f));
 
-    memory.setSlice(outputOffset, output);
+    memory.set(outputOffset, new Field(outputPoint.x));
+    memory.set(outputOffset + 1, new Field(outputPoint.y));
+    // Check representation of infinity for grumpkin
+    memory.set(outputOffset + 2, new Uint1(outputPoint.equals(Point.ZERO) ? 1 : 0));
 
     memory.assert({
       reads: 1 + pointsReadLength + scalarReadLength /* points and scalars */,
       writes: 3 /* output triplet */,
       addressing,
     });
-    context.machineState.incrementPc();
   }
 }

package/src/avm/opcodes/storage.ts

@@ -43,10 +43,9 @@ export class SStore extends BaseStorageInstruction {
 
     const slot = memory.get(slotOffset).toFr();
     const value = memory.get(srcOffset).toFr();
-    context.persistableState.writeStorage(context.environment.address, slot, value);
+    await context.persistableState.writeStorage(context.environment.address, slot, value);
 
     memory.assert({ reads: 2, addressing });
-    context.machineState.incrementPc();
   }
 }
 
@@ -71,7 +70,6 @@ export class SLoad extends BaseStorageInstruction {
     const value = await context.persistableState.readStorage(context.environment.address, slot);
     memory.set(dstOffset, new Field(value));
 
-    context.machineState.incrementPc();
     memory.assert({ writes: 1, reads: 1, addressing });
   }
 }

package/src/avm/serialization/bytecode_serialization.ts

@@ -143,12 +143,11 @@ const INSTRUCTION_SET = () =>
     [EcAdd.opcode, Instruction.deserialize.bind(EcAdd)],
     [Poseidon2.opcode, Instruction.deserialize.bind(Poseidon2)],
     [Sha256Compression.opcode, Instruction.deserialize.bind(Sha256Compression)],
+    [KeccakF1600.opcode, Instruction.deserialize.bind(KeccakF1600)],
     [MultiScalarMul.opcode, Instruction.deserialize.bind(MultiScalarMul)],
+
     // Conversions
     [ToRadixBE.opcode, Instruction.deserialize.bind(ToRadixBE)],
-    // Future Gadgets -- pending changes in noir
-    // SHA256COMPRESSION,
-    [KeccakF1600.opcode, Instruction.deserialize.bind(KeccakF1600)],
   ]);
 
 /**
@@ -158,30 +157,40 @@ export function encodeToBytecode(instructions: Serializable[]): Buffer {
   return Buffer.concat(instructions.map(i => i.serialize()));
 }
 
-/**
- * Convert a buffer of bytecode into an array of instructions.
- * @param bytecode Buffer of bytecode.
- * @param instructionSet Optional {@code InstructionSet} to be used for deserialization.
- * @returns Bytecode decoded into an ordered array of Instructions
- */
+// For testing only
 export function decodeFromBytecode(
   bytecode: Buffer,
   instructionSet: InstructionSet = INSTRUCTION_SET(),
 ): Instruction[] {
   const instructions: Instruction[] = [];
-  const cursor = new BufferCursor(bytecode);
-
-  while (!cursor.eof()) {
-    const opcode: Opcode = cursor.bufferAtPosition().readUint8(); // peek.
-    const instructionDeserializerOrUndef = instructionSet.get(opcode);
-    if (instructionDeserializerOrUndef === undefined) {
-      throw new Error(`Opcode ${Opcode[opcode]} (0x${opcode.toString(16)}) not implemented`);
-    }
-
-    const instructionDeserializer: InstructionDeserializer = instructionDeserializerOrUndef;
-    const i: Instruction = instructionDeserializer(cursor);
-    instructions.push(i);
+  let pc = 0;
+  while (pc < bytecode.length) {
+    const [instruction, bytesConsumed] = decodeInstructionFromBytecode(bytecode, pc, instructionSet);
+    instructions.push(instruction);
+    pc += bytesConsumed;
   }
-
   return instructions;
 }
+
+// Returns the instruction and the number of bytes consumed.
+export function decodeInstructionFromBytecode(
+  bytecode: Buffer,
+  pc: number,
+  instructionSet: InstructionSet = INSTRUCTION_SET(),
+): [Instruction, number] {
+  if (pc >= bytecode.length) {
+    throw new Error(`pc ${pc} is out of bounds for bytecode of length ${bytecode.length}`);
+  }
+  const cursor = new BufferCursor(bytecode, pc);
+  const startingPosition = cursor.position();
+  const opcode: Opcode = cursor.bufferAtPosition().readUint8(); // peek.
+
+  const instructionDeserializerOrUndef = instructionSet.get(opcode);
+  if (instructionDeserializerOrUndef === undefined) {
+    throw new Error(`Opcode ${Opcode[opcode]} (0x${opcode.toString(16)}) not implemented`);
+  }
+
+  const instructionDeserializer: InstructionDeserializer = instructionDeserializerOrUndef;
+  const instruction = instructionDeserializer(cursor);
+  return [instruction, cursor.position() - startingPosition];
+}