@aztec/simulator 0.24.0 → 0.26.1

package/src/avm/opcodes/environment_getters.ts

@@ -1,3 +1,5 @@
+import { Fr } from '@aztec/circuits.js';
+
 import type { AvmContext } from '../avm_context.js';
 import type { AvmExecutionEnvironment } from '../avm_execution_environment.js';
 import { Field } from '../avm_memory_types.js';
@@ -18,14 +20,14 @@ abstract class GetterInstruction extends Instruction {
     context.machineState.incrementPc();
   }
 
-  protected abstract getIt(env: AvmExecutionEnvironment): any;
+  protected abstract getIt(env: AvmExecutionEnvironment): Fr | number | bigint;
 }
 
 export class Address extends GetterInstruction {
   static type: string = 'ADDRESS';
   static readonly opcode: Opcode = Opcode.ADDRESS;
 
-  protected getIt(env: AvmExecutionEnvironment): any {
+  protected getIt(env: AvmExecutionEnvironment) {
     return env.address;
   }
 }
@@ -34,7 +36,7 @@ export class StorageAddress extends GetterInstruction {
   static type: string = 'STORAGEADDRESS';
   static readonly opcode: Opcode = Opcode.STORAGEADDRESS;
 
-  protected getIt(env: AvmExecutionEnvironment): any {
+  protected getIt(env: AvmExecutionEnvironment) {
     return env.storageAddress;
   }
 }
@@ -43,7 +45,7 @@ export class Sender extends GetterInstruction {
   static type: string = 'SENDER';
   static readonly opcode: Opcode = Opcode.SENDER;
 
-  protected getIt(env: AvmExecutionEnvironment): any {
+  protected getIt(env: AvmExecutionEnvironment) {
     return env.sender;
   }
 }
@@ -52,7 +54,7 @@ export class Origin extends GetterInstruction {
   static type: string = 'ORIGIN';
   static readonly opcode: Opcode = Opcode.ORIGIN;
 
-  protected getIt(env: AvmExecutionEnvironment): any {
+  protected getIt(env: AvmExecutionEnvironment) {
     return env.origin;
   }
 }
@@ -61,7 +63,7 @@ export class FeePerL1Gas extends GetterInstruction {
   static type: string = 'FEEPERL1GAS';
   static readonly opcode: Opcode = Opcode.FEEPERL1GAS;
 
-  protected getIt(env: AvmExecutionEnvironment): any {
+  protected getIt(env: AvmExecutionEnvironment) {
     return env.feePerL1Gas;
   }
 }
@@ -70,7 +72,7 @@ export class FeePerL2Gas extends GetterInstruction {
   static type: string = 'FEEPERL2GAS';
   static readonly opcode: Opcode = Opcode.FEEPERL2GAS;
 
-  protected getIt(env: AvmExecutionEnvironment): any {
+  protected getIt(env: AvmExecutionEnvironment) {
     return env.feePerL2Gas;
   }
 }
@@ -79,7 +81,7 @@ export class FeePerDAGas extends GetterInstruction {
   static type: string = 'FEEPERDAGAS';
   static readonly opcode: Opcode = Opcode.FEEPERDAGAS;
 
-  protected getIt(env: AvmExecutionEnvironment): any {
+  protected getIt(env: AvmExecutionEnvironment) {
     return env.feePerDaGas;
   }
 }
@@ -88,7 +90,7 @@ export class Portal extends GetterInstruction {
   static type: string = 'PORTAL';
   static readonly opcode: Opcode = Opcode.PORTAL;
 
-  protected getIt(env: AvmExecutionEnvironment): any {
+  protected getIt(env: AvmExecutionEnvironment) {
     return env.portal.toField();
   }
 }
@@ -97,7 +99,7 @@ export class ChainId extends GetterInstruction {
   static type: string = 'CHAINID';
   static readonly opcode: Opcode = Opcode.CHAINID;
 
-  protected getIt(env: AvmExecutionEnvironment): any {
+  protected getIt(env: AvmExecutionEnvironment) {
     return env.globals.chainId;
   }
 }
@@ -106,7 +108,7 @@ export class Version extends GetterInstruction {
   static type: string = 'VERSION';
   static readonly opcode: Opcode = Opcode.VERSION;
 
-  protected getIt(env: AvmExecutionEnvironment): any {
+  protected getIt(env: AvmExecutionEnvironment) {
     return env.globals.version;
   }
 }
@@ -115,7 +117,7 @@ export class BlockNumber extends GetterInstruction {
   static type: string = 'BLOCKNUMBER';
   static readonly opcode: Opcode = Opcode.BLOCKNUMBER;
 
-  protected getIt(env: AvmExecutionEnvironment): any {
+  protected getIt(env: AvmExecutionEnvironment) {
     return env.globals.blockNumber;
   }
 }
@@ -124,7 +126,7 @@ export class Timestamp extends GetterInstruction {
   static type: string = 'TIMESTAMP';
   static readonly opcode: Opcode = Opcode.TIMESTAMP;
 
-  protected getIt(env: AvmExecutionEnvironment): any {
+  protected getIt(env: AvmExecutionEnvironment) {
     return env.globals.timestamp;
   }
 }

package/src/avm/opcodes/external_calls.ts

@@ -54,9 +54,9 @@ export class Call extends Instruction {
     context.machineState.memory.setSlice(this.retOffset, convertedReturnData);
 
     if (success) {
-      context.worldState.acceptNestedWorldState(nestedContext.worldState);
+      context.persistableState.acceptNestedCallState(nestedContext.persistableState);
     } else {
-      context.worldState.rejectNestedWorldState(nestedContext.worldState);
+      context.persistableState.rejectNestedCallState(nestedContext.persistableState);
     }
 
     context.machineState.incrementPc();
@@ -112,9 +112,9 @@ export class StaticCall extends Instruction {
     context.machineState.memory.setSlice(this.retOffset, convertedReturnData);
 
     if (success) {
-      context.worldState.acceptNestedWorldState(nestedContext.worldState);
+      context.persistableState.acceptNestedCallState(nestedContext.persistableState);
     } else {
-      context.worldState.rejectNestedWorldState(nestedContext.worldState);
+      context.persistableState.rejectNestedCallState(nestedContext.persistableState);
     }
 
     context.machineState.incrementPc();

package/src/avm/opcodes/hashing.ts

@@ -0,0 +1,170 @@
+import { toBigIntBE } from '@aztec/foundation/bigint-buffer';
+import { keccak, pedersenHash, poseidonHash, sha256 } from '@aztec/foundation/crypto';
+
+import { AvmContext } from '../avm_context.js';
+import { Field } from '../avm_memory_types.js';
+import { Opcode, OperandType } from '../serialization/instruction_serialization.js';
+import { Addressing } from './addressing_mode.js';
+import { Instruction } from './instruction.js';
+
+export class Poseidon2 extends Instruction {
+  static type: string = 'POSEIDON2';
+  static readonly opcode: Opcode = Opcode.POSEIDON;
+
+  // Informs (de)serialization. See Instruction.deserialize.
+  static readonly wireFormat: OperandType[] = [
+    OperandType.UINT8,
+    OperandType.UINT8,
+    OperandType.UINT32,
+    OperandType.UINT32,
+    OperandType.UINT32,
+  ];
+
+  constructor(
+    private indirect: number,
+    private dstOffset: number,
+    private hashOffset: number,
+    private hashSize: number,
+  ) {
+    super();
+  }
+
+  async execute(context: AvmContext): Promise<void> {
+    // We hash a set of field elements
+    const [hashOffset] = Addressing.fromWire(this.indirect).resolve([this.hashOffset], context.machineState.memory);
+
+    // Memory pointer will be indirect
+    const hashData = context.machineState.memory.getSlice(hashOffset, this.hashSize).map(word => word.toBuffer());
+
+    const hash = poseidonHash(hashData);
+    context.machineState.memory.set(this.dstOffset, new Field(hash));
+
+    context.machineState.incrementPc();
+  }
+}
+
+export class Keccak extends Instruction {
+  static type: string = 'KECCAK';
+  static readonly opcode: Opcode = Opcode.KECCAK;
+
+  // Informs (de)serialization. See Instruction.deserialize.
+  static readonly wireFormat: OperandType[] = [
+    OperandType.UINT8,
+    OperandType.UINT8,
+    OperandType.UINT32,
+    OperandType.UINT32,
+    OperandType.UINT32,
+  ];
+
+  constructor(
+    private indirect: number,
+    private dstOffset: number,
+    private hashOffset: number,
+    private hashSize: number,
+  ) {
+    super();
+  }
+
+  // Note hash output is 32 bytes, so takes up two fields
+  async execute(context: AvmContext): Promise<void> {
+    // We hash a set of field elements
+    const [hashOffset, dstOffset] = Addressing.fromWire(this.indirect).resolve(
+      [this.hashOffset, this.dstOffset],
+      context.machineState.memory,
+    );
+
+    const hashData = context.machineState.memory.getSlice(hashOffset, this.hashSize).map(word => word.toBuffer());
+
+    const hash = keccak(Buffer.concat(hashData));
+
+    // Split output into two fields
+    const high = new Field(toBigIntBE(hash.subarray(0, 16)));
+    const low = new Field(toBigIntBE(hash.subarray(16, 32)));
+
+    context.machineState.memory.set(dstOffset, high);
+    context.machineState.memory.set(dstOffset + 1, low);
+
+    context.machineState.incrementPc();
+  }
+}
+
+export class Sha256 extends Instruction {
+  static type: string = 'SHA256';
+  static readonly opcode: Opcode = Opcode.SHA256;
+
+  // Informs (de)serialization. See Instruction.deserialize.
+  static readonly wireFormat: OperandType[] = [
+    OperandType.UINT8,
+    OperandType.UINT8,
+    OperandType.UINT32,
+    OperandType.UINT32,
+    OperandType.UINT32,
+  ];
+
+  constructor(
+    private indirect: number,
+    private dstOffset: number,
+    private hashOffset: number,
+    private hashSize: number,
+  ) {
+    super();
+  }
+
+  // Note hash output is 32 bytes, so takes up two fields
+  async execute(context: AvmContext): Promise<void> {
+    const [hashOffset, dstOffset] = Addressing.fromWire(this.indirect).resolve(
+      [this.hashOffset, this.dstOffset],
+      context.machineState.memory,
+    );
+
+    // We hash a set of field elements
+    const hashData = context.machineState.memory.getSlice(hashOffset, this.hashSize).map(word => word.toBuffer());
+
+    const hash = sha256(Buffer.concat(hashData));
+
+    // Split output into two fields
+    const high = new Field(toBigIntBE(hash.subarray(0, 16)));
+    const low = new Field(toBigIntBE(hash.subarray(16, 32)));
+
+    context.machineState.memory.set(dstOffset, high);
+    context.machineState.memory.set(dstOffset + 1, low);
+
+    context.machineState.incrementPc();
+  }
+}
+
+export class Pedersen extends Instruction {
+  static type: string = 'PEDERSEN';
+  static readonly opcode: Opcode = Opcode.PEDERSEN;
+
+  // Informs (de)serialization. See Instruction.deserialize.
+  static readonly wireFormat: OperandType[] = [
+    OperandType.UINT8,
+    OperandType.UINT8,
+    OperandType.UINT32,
+    OperandType.UINT32,
+    OperandType.UINT32,
+  ];
+
+  constructor(
+    private indirect: number,
+    private dstOffset: number,
+    private hashOffset: number,
+    private hashSize: number,
+  ) {
+    super();
+  }
+
+  async execute(context: AvmContext): Promise<void> {
+    const [hashOffset] = Addressing.fromWire(this.indirect).resolve([this.hashOffset], context.machineState.memory);
+
+    // We hash a set of field elements
+    const hashData = context.machineState.memory.getSlice(hashOffset, this.hashSize).map(word => word.toBuffer());
+
+    // No domain sep for now
+    const hash = pedersenHash(hashData);
+    context.machineState.memory.set(this.dstOffset, new Field(hash));
+
+    context.machineState.incrementPc();
+  }
+}

package/src/avm/opcodes/memory.ts

@@ -186,6 +186,7 @@ export class CalldataCopy extends Instruction {
     const transformedData = context.environment.calldata
       .slice(this.cdOffset, this.cdOffset + this.copySize)
       .map(f => new Field(f));
+
     context.machineState.memory.setSlice(this.dstOffset, transformedData);
 
     context.machineState.incrementPc();

package/src/avm/opcodes/storage.ts

@@ -36,7 +36,7 @@ export class SStore extends BaseStorageInstruction {
     const slot = context.machineState.memory.get(this.aOffset);
     const data = context.machineState.memory.get(this.bOffset);
 
-    context.worldState.writeStorage(
+    context.persistableState.writeStorage(
       context.environment.storageAddress,
       new Fr(slot.toBigInt()),
       new Fr(data.toBigInt()),
@@ -57,7 +57,10 @@ export class SLoad extends BaseStorageInstruction {
   async execute(context: AvmContext): Promise<void> {
     const slot = context.machineState.memory.get(this.aOffset);
 
-    const data: Fr = await context.worldState.readStorage(context.environment.storageAddress, new Fr(slot.toBigInt()));
+    const data: Fr = await context.persistableState.readStorage(
+      context.environment.storageAddress,
+      new Fr(slot.toBigInt()),
+    );
 
     context.machineState.memory.set(this.bOffset, new Field(data));
 

package/src/avm/serialization/bytecode_serialization.ts

@@ -1,3 +1,4 @@
+import { Keccak, Pedersen, Poseidon2, Sha256 } from '../opcodes/hashing.js';
 import {
   Add,
   Address,
@@ -20,11 +21,14 @@ import {
   InternalReturn,
   Jump,
   JumpI,
+  L1ToL2MessageExists,
   Lt,
   Lte,
   Mov,
   Mul,
   Not,
+  NoteHashExists,
+  NullifierExists,
   Or,
   Origin,
   Portal,
@@ -110,11 +114,11 @@ const INSTRUCTION_SET = () =>
     // World State
     [SLoad.opcode, SLoad], // Public Storage
     [SStore.opcode, SStore], // Public Storage
-    //[NoteHashExists.opcode, NoteHashExists], // Notes & Nullifiers
+    [NoteHashExists.opcode, NoteHashExists], // Notes & Nullifiers
     [EmitNoteHash.opcode, EmitNoteHash], // Notes & Nullifiers
-    //[NullifierExists.opcode, NullifierExists], // Notes & Nullifiers
+    [NullifierExists.opcode, NullifierExists], // Notes & Nullifiers
     [EmitNullifier.opcode, EmitNullifier], // Notes & Nullifiers
-    //[Readl1tol2msg.opcode, Readl1tol2msg], // Messages
+    [L1ToL2MessageExists.opcode, L1ToL2MessageExists], // Messages
     //[HeaderMember.opcode, HeaderMember], // Header
 
     // Accrued Substate
@@ -124,12 +128,15 @@ const INSTRUCTION_SET = () =>
     // Control Flow - Contract Calls
     [Call.opcode, Call],
     [StaticCall.opcode, StaticCall],
+    //[DelegateCall.opcode, DelegateCall],
     [Return.opcode, Return],
     [Revert.opcode, Revert],
 
-    // Gadgets
-    //[Keccak.opcode, Keccak],
-    //[Poseidon.opcode, Poseidon],
+    // //// Gadgets
+    [Keccak.opcode, Keccak],
+    [Poseidon2.opcode, Poseidon2],
+    [Sha256.opcode, Sha256],
+    [Pedersen.opcode, Pedersen],
   ]);
 
 interface Serializable {

package/src/avm/serialization/instruction_serialization.ts

@@ -3,7 +3,7 @@ import { strict as assert } from 'assert';
 import { BufferCursor } from './buffer_cursor.js';
 
 /**
- * All AVM opcodes. (Keep in sync with cpp counterpart code AvmMini_opcode.hpp).
+ * All AVM opcodes. (Keep in sync with cpp counterpart code avm_opcode.hpp).
  * Source: https://yp-aztec.netlify.app/docs/public-vm/instruction-set
  */
 export enum Opcode {
@@ -55,22 +55,25 @@ export enum Opcode {
   EMITNOTEHASH,
   NULLIFIEREXISTS,
   EMITNULLIFIER,
-  READL1TOL2MSG,
+  L1TOL2MSGEXISTS,
   HEADERMEMBER,
   EMITUNENCRYPTEDLOG,
   SENDL2TOL1MSG,
   CALL,
   STATICCALL,
+  DELEGATECALL,
   RETURN,
   REVERT,
   KECCAK,
   POSEIDON,
   // Add new opcodes before this
+  SHA256, // temp - may be removed, but alot of contracts rely on it
+  PEDERSEN, // temp - may be removed, but alot of contracts rely on it
   TOTAL_OPCODES_NUMBER,
 }
 
 // Possible types for an instruction's operand in its wire format. (Keep in sync with CPP code.
-// See vm/avm_trace/AvmMini_deserialization.cpp)
+// See vm/avm_trace/avm_deserialization.cpp)
 // Note that cpp code introduced an additional enum value TAG to express the instruction tag. In TS,
 // this one is parsed as UINT8.
 export enum OperandType {

package/src/avm/temporary_executor_migration.ts

@@ -4,6 +4,7 @@ import {
   ContractStorageRead,
   ContractStorageUpdateRequest,
   GlobalVariables,
+  L2ToL1Message,
   SideEffect,
   SideEffectLinkedToNoteHash,
 } from '@aztec/circuits.js';
@@ -59,7 +60,7 @@ export function temporaryConvertAvmResults(
   newWorldState: JournalData,
   result: AvmContractCallResults,
 ): PublicExecutionResult {
-  const newCommitments = newWorldState.newNoteHashes.map(noteHash => new SideEffect(noteHash, Fr.zero()));
+  const newNoteHashes = newWorldState.newNoteHashes.map(noteHash => new SideEffect(noteHash, Fr.zero()));
 
   const contractStorageReads: ContractStorageRead[] = [];
   const reduceStorageReadRequests = (contractAddress: bigint, storageReads: Map<bigint, Fr[]>) => {
@@ -92,11 +93,11 @@ export function temporaryConvertAvmResults(
   const nestedExecutions: PublicExecutionResult[] = [];
   const newNullifiers: SideEffectLinkedToNoteHash[] = [];
   const unencryptedLogs = FunctionL2Logs.empty();
-  const newL2ToL1Messages = newWorldState.newL1Messages.map(() => Fr.zero());
+  const newL2ToL1Messages = newWorldState.newL1Messages.map(() => L2ToL1Message.empty());
 
   return {
     execution,
-    newCommitments,
+    newNoteHashes,
     newL2ToL1Messages,
     newNullifiers,
     contractStorageReads,