@aztec/simulator 0.23.0 → 0.26.1

package/src/avm/serialization/bytecode_serialization.ts

@@ -0,0 +1,179 @@
+import { Keccak, Pedersen, Poseidon2, Sha256 } from '../opcodes/hashing.js';
+import {
+  Add,
+  Address,
+  And,
+  BlockNumber,
+  CMov,
+  Call,
+  CalldataCopy,
+  Cast,
+  ChainId,
+  Div,
+  EmitNoteHash,
+  EmitNullifier,
+  EmitUnencryptedLog,
+  Eq,
+  FeePerDAGas,
+  FeePerL1Gas,
+  FeePerL2Gas,
+  InternalCall,
+  InternalReturn,
+  Jump,
+  JumpI,
+  L1ToL2MessageExists,
+  Lt,
+  Lte,
+  Mov,
+  Mul,
+  Not,
+  NoteHashExists,
+  NullifierExists,
+  Or,
+  Origin,
+  Portal,
+  Return,
+  Revert,
+  SLoad,
+  SStore,
+  SendL2ToL1Message,
+  Sender,
+  Set,
+  Shl,
+  Shr,
+  StaticCall,
+  StorageAddress,
+  Sub,
+  Timestamp,
+  Version,
+  Xor,
+} from '../opcodes/index.js';
+import type { Instruction } from '../opcodes/index.js';
+import { BufferCursor } from './buffer_cursor.js';
+import { Opcode } from './instruction_serialization.js';
+
+interface DeserializableInstruction {
+  deserialize(buf: BufferCursor | Buffer): Instruction;
+  opcode: Opcode;
+}
+
+export type InstructionSet = Map<Opcode, DeserializableInstruction>;
+// TODO(4359): This is a function so that Call and StaticCall can be lazily resolved.
+// This is a temporary solution until we solve the dependency cycle.
+const INSTRUCTION_SET = () =>
+  new Map<Opcode, DeserializableInstruction>([
+    [Add.opcode, Add],
+    [Sub.opcode, Sub],
+    [Mul.opcode, Mul],
+    [Div.opcode, Div],
+    [Eq.opcode, Eq],
+    [Lt.opcode, Lt],
+    [Lte.opcode, Lte],
+    [And.opcode, And],
+    [Or.opcode, Or],
+    [Xor.opcode, Xor],
+    [Not.opcode, Not],
+    [Shl.opcode, Shl],
+    [Shr.opcode, Shr],
+    [Cast.opcode, Cast],
+    [Address.opcode, Address],
+    [StorageAddress.opcode, StorageAddress],
+    [Origin.opcode, Origin],
+    [Sender.opcode, Sender],
+    [Portal.opcode, Portal],
+    [FeePerL1Gas.opcode, FeePerL1Gas],
+    [FeePerL2Gas.opcode, FeePerL2Gas],
+    [FeePerDAGas.opcode, FeePerDAGas],
+    //[Contractcalldepth.opcode, Contractcalldepth],
+    // Execution Environment - Globals
+    [ChainId.opcode, ChainId],
+    [Version.opcode, Version],
+    [BlockNumber.opcode, BlockNumber],
+    [Timestamp.opcode, Timestamp],
+    //[Coinbase.opcode, Coinbase],
+    //[Blockl1gaslimit.opcode, Blockl1gaslimit],
+    //[Blockl2gaslimit.opcode, Blockl2gaslimit],
+    //[Blockdagaslimit.opcode, Blockdagaslimit],
+    // Execution Environment - Calldata
+    [CalldataCopy.opcode, CalldataCopy],
+
+    // Machine State
+    // Machine State - Gas
+    //[L1gasleft.opcode, L1gasleft],
+    //[L2gasleft.opcode, L2gasleft],
+    //[Dagasleft.opcode, Dagasleft],
+    // Machine State - Internal Control Flow
+    [Jump.opcode, Jump],
+    [JumpI.opcode, JumpI],
+    [InternalCall.opcode, InternalCall],
+    [InternalReturn.opcode, InternalReturn],
+    [Set.opcode, Set],
+    [Mov.opcode, Mov],
+    [CMov.opcode, CMov],
+
+    // World State
+    [SLoad.opcode, SLoad], // Public Storage
+    [SStore.opcode, SStore], // Public Storage
+    [NoteHashExists.opcode, NoteHashExists], // Notes & Nullifiers
+    [EmitNoteHash.opcode, EmitNoteHash], // Notes & Nullifiers
+    [NullifierExists.opcode, NullifierExists], // Notes & Nullifiers
+    [EmitNullifier.opcode, EmitNullifier], // Notes & Nullifiers
+    [L1ToL2MessageExists.opcode, L1ToL2MessageExists], // Messages
+    //[HeaderMember.opcode, HeaderMember], // Header
+
+    // Accrued Substate
+    [EmitUnencryptedLog.opcode, EmitUnencryptedLog],
+    [SendL2ToL1Message.opcode, SendL2ToL1Message],
+
+    // Control Flow - Contract Calls
+    [Call.opcode, Call],
+    [StaticCall.opcode, StaticCall],
+    //[DelegateCall.opcode, DelegateCall],
+    [Return.opcode, Return],
+    [Revert.opcode, Revert],
+
+    // //// Gadgets
+    [Keccak.opcode, Keccak],
+    [Poseidon2.opcode, Poseidon2],
+    [Sha256.opcode, Sha256],
+    [Pedersen.opcode, Pedersen],
+  ]);
+
+interface Serializable {
+  serialize(): Buffer;
+}
+
+/**
+ * Serializes an array of instructions to bytecode.
+ */
+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
+ */
+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: DeserializableInstruction = instructionDeserializerOrUndef;
+    const i: Instruction = instructionDeserializer.deserialize(cursor);
+    instructions.push(i);
+  }
+
+  return instructions;
+}

package/src/avm/serialization/instruction_serialization.ts

@@ -0,0 +1,170 @@
+import { strict as assert } from 'assert';
+
+import { BufferCursor } from './buffer_cursor.js';
+
+/**
+ * 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 {
+  ADD,
+  SUB,
+  MUL,
+  DIV,
+  EQ,
+  LT,
+  LTE,
+  AND,
+  OR,
+  XOR,
+  NOT,
+  SHL,
+  SHR,
+  CAST,
+  ADDRESS,
+  STORAGEADDRESS,
+  ORIGIN,
+  SENDER,
+  PORTAL,
+  FEEPERL1GAS,
+  FEEPERL2GAS,
+  FEEPERDAGAS,
+  CONTRACTCALLDEPTH,
+  CHAINID,
+  VERSION,
+  BLOCKNUMBER,
+  TIMESTAMP,
+  COINBASE,
+  BLOCKL1GASLIMIT,
+  BLOCKL2GASLIMIT,
+  BLOCKDAGASLIMIT,
+  CALLDATACOPY,
+  L1GASLEFT,
+  L2GASLEFT,
+  DAGASLEFT,
+  JUMP,
+  JUMPI,
+  INTERNALCALL,
+  INTERNALRETURN,
+  SET,
+  MOV,
+  CMOV,
+  SLOAD,
+  SSTORE,
+  NOTEHASHEXISTS,
+  EMITNOTEHASH,
+  NULLIFIEREXISTS,
+  EMITNULLIFIER,
+  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/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 {
+  UINT8,
+  UINT16,
+  UINT32,
+  UINT64,
+  UINT128,
+}
+
+type OperandNativeType = number | bigint;
+type OperandWriter = (value: any) => void;
+
+// Specifies how to read and write each operand type.
+const OPERAND_SPEC = new Map<OperandType, [number, () => OperandNativeType, OperandWriter]>([
+  [OperandType.UINT8, [1, Buffer.prototype.readUint8, Buffer.prototype.writeUint8]],
+  [OperandType.UINT16, [2, Buffer.prototype.readUint16BE, Buffer.prototype.writeUint16BE]],
+  [OperandType.UINT32, [4, Buffer.prototype.readUint32BE, Buffer.prototype.writeUint32BE]],
+  [OperandType.UINT64, [8, Buffer.prototype.readBigInt64BE, Buffer.prototype.writeBigInt64BE]],
+  [OperandType.UINT128, [16, readBigInt128BE, writeBigInt128BE]],
+]);
+
+function readBigInt128BE(this: Buffer): bigint {
+  const totalBytes = 16;
+  let ret: bigint = 0n;
+  for (let i = 0; i < totalBytes; ++i) {
+    ret <<= 8n;
+    ret |= BigInt(this.readUint8(i));
+  }
+  return ret;
+}
+
+function writeBigInt128BE(this: Buffer, value: bigint): void {
+  const totalBytes = 16;
+  for (let offset = totalBytes - 1; offset >= 0; --offset) {
+    this.writeUint8(Number(value & 0xffn), offset);
+    value >>= 8n;
+  }
+}
+
+/**
+ * Reads an array of operands from a buffer.
+ * @param cursor Buffer to read from. Might be longer than needed.
+ * @param operands Specification of the operand types.
+ * @returns An array as big as {@code operands}, with the converted TS values.
+ */
+export function deserialize(cursor: BufferCursor | Buffer, operands: OperandType[]): (number | bigint)[] {
+  const argValues = [];
+  if (cursor instanceof Buffer) {
+    cursor = new BufferCursor(cursor);
+  }
+
+  for (const op of operands) {
+    const opType = op;
+    const [sizeBytes, reader, _writer] = OPERAND_SPEC.get(opType)!;
+    argValues.push(reader.call(cursor.bufferAtPosition()));
+    cursor.advance(sizeBytes);
+  }
+
+  return argValues;
+}
+
+/**
+ * Serializes a class using the specified operand types.
+ * More specifically, this serializes {@code [cls.constructor.opcode, ...Object.values(cls)]}.
+ * Observe in particular that:
+ *   (1) the first operand type specified must correspond to the opcode;
+ *   (2) the rest of the operand types must be specified in the order returned by {@code Object.values()}.
+ * @param operands Type specification for the values to be serialized.
+ * @param cls The class to be serialized.
+ * @returns
+ */
+export function serialize(operands: OperandType[], cls: any): Buffer {
+  const chunks: Buffer[] = [];
+
+  // TODO: infer opcode not in this loop
+  assert(cls.constructor.opcode !== undefined && cls.constructor.opcode !== null);
+  const rawClassValues: any[] = [cls.constructor.opcode, ...Object.values(cls)];
+  assert(
+    rawClassValues.length === operands.length,
+    `Got ${rawClassValues.length} values but only ${operands.length} serialization operands are specified!`,
+  );
+  const classValues = rawClassValues as OperandNativeType[];
+
+  for (let i = 0; i < operands.length; i++) {
+    const opType = operands[i];
+    const [sizeBytes, _reader, writer] = OPERAND_SPEC.get(opType)!;
+    const buf = Buffer.alloc(sizeBytes);
+    writer.call(buf, classValues[i]);
+    chunks.push(buf);
+  }
+
+  return Buffer.concat(chunks);
+}

package/src/avm/temporary_executor_migration.ts

@@ -0,0 +1,109 @@
+// All code in this file needs to die once the public executor is phased out.
+import { FunctionL2Logs } from '@aztec/circuit-types';
+import {
+  ContractStorageRead,
+  ContractStorageUpdateRequest,
+  GlobalVariables,
+  L2ToL1Message,
+  SideEffect,
+  SideEffectLinkedToNoteHash,
+} from '@aztec/circuits.js';
+import { Fr } from '@aztec/foundation/fields';
+
+import { PublicExecution, PublicExecutionResult } from '../public/execution.js';
+import { AvmExecutionEnvironment } from './avm_execution_environment.js';
+import { AvmContractCallResults } from './avm_message_call_result.js';
+import { JournalData } from './journal/journal.js';
+
+/** Temporary Method
+ *
+ * Convert a PublicExecution(Environment) object to an AvmExecutionEnvironment
+ *
+ * @param current
+ * @param globalVariables
+ * @returns
+ */
+export function temporaryCreateAvmExecutionEnvironment(
+  current: PublicExecution,
+  globalVariables: GlobalVariables,
+): AvmExecutionEnvironment {
+  // Function selector is included temporarily until noir codegens public contract bytecode in a single blob
+  return new AvmExecutionEnvironment(
+    current.contractAddress,
+    current.callContext.storageContractAddress,
+    current.callContext.msgSender, // TODO: origin is not available
+    current.callContext.msgSender,
+    current.callContext.portalContractAddress,
+    /*feePerL1Gas=*/ Fr.zero(),
+    /*feePerL2Gas=*/ Fr.zero(),
+    /*feePerDaGas=*/ Fr.zero(),
+    /*contractCallDepth=*/ Fr.zero(),
+    globalVariables,
+    current.callContext.isStaticCall,
+    current.callContext.isDelegateCall,
+    current.args,
+    current.functionData.selector,
+  );
+}
+
+/** Temporary Method
+ *
+ * Convert the result of an AVM contract call to a PublicExecutionResult for the public kernel
+ *
+ * @param execution
+ * @param newWorldState
+ * @param result
+ * @returns
+ */
+export function temporaryConvertAvmResults(
+  execution: PublicExecution,
+  newWorldState: JournalData,
+  result: AvmContractCallResults,
+): PublicExecutionResult {
+  const newNoteHashes = newWorldState.newNoteHashes.map(noteHash => new SideEffect(noteHash, Fr.zero()));
+
+  const contractStorageReads: ContractStorageRead[] = [];
+  const reduceStorageReadRequests = (contractAddress: bigint, storageReads: Map<bigint, Fr[]>) => {
+    return storageReads.forEach((innerArray, key) => {
+      innerArray.forEach(value => {
+        contractStorageReads.push(new ContractStorageRead(new Fr(key), new Fr(value), 0));
+      });
+    });
+  };
+  newWorldState.storageReads.forEach((storageMap: Map<bigint, Fr[]>, address: bigint) =>
+    reduceStorageReadRequests(address, storageMap),
+  );
+
+  const contractStorageUpdateRequests: ContractStorageUpdateRequest[] = [];
+  const reduceStorageUpdateRequests = (contractAddress: bigint, storageUpdateRequests: Map<bigint, Fr[]>) => {
+    return storageUpdateRequests.forEach((innerArray, key) => {
+      innerArray.forEach(value => {
+        contractStorageUpdateRequests.push(new ContractStorageUpdateRequest(new Fr(key), new Fr(value), 0));
+      });
+    });
+  };
+  newWorldState.storageWrites.forEach((storageMap: Map<bigint, Fr[]>, address: bigint) =>
+    reduceStorageUpdateRequests(address, storageMap),
+  );
+
+  const returnValues = result.output;
+
+  // TODO(follow up in pr tree): NOT SUPPORTED YET, make sure hashing and log resolution is done correctly
+  // Disabled.
+  const nestedExecutions: PublicExecutionResult[] = [];
+  const newNullifiers: SideEffectLinkedToNoteHash[] = [];
+  const unencryptedLogs = FunctionL2Logs.empty();
+  const newL2ToL1Messages = newWorldState.newL1Messages.map(() => L2ToL1Message.empty());
+
+  return {
+    execution,
+    newNoteHashes,
+    newL2ToL1Messages,
+    newNullifiers,
+    contractStorageReads,
+    contractStorageUpdateRequests,
+    returnValues,
+    nestedExecutions,
+    unencryptedLogs,
+  };
+}