@aztec/simulator 0.22.0 → 0.24.0

package/src/avm/serialization/instruction_serialization.ts

@@ -0,0 +1,167 @@
+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).
+ * 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,
+  READL1TOL2MSG,
+  HEADERMEMBER,
+  EMITUNENCRYPTEDLOG,
+  SENDL2TOL1MSG,
+  CALL,
+  STATICCALL,
+  RETURN,
+  REVERT,
+  KECCAK,
+  POSEIDON,
+  // Add new opcodes before this
+  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)
+// 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,108 @@
+// 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,
+  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 newCommitments = 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(() => Fr.zero());
+
+  return {
+    execution,
+    newCommitments,
+    newL2ToL1Messages,
+    newNullifiers,
+    contractStorageReads,
+    contractStorageUpdateRequests,
+    returnValues,
+    nestedExecutions,
+    unencryptedLogs,
+  };
+}