@proto-kit/common 0.1.1-develop.165 → 0.1.1-develop.1665

package/src/events/EventEmitterProxy.ts

@@ -0,0 +1,81 @@
+import type {
+  BaseModuleType,
+  ModuleContainer,
+  ModulesRecord,
+} from "../config/ModuleContainer";
+import { StringKeyOf, UnionToIntersection } from "../types";
+
+import { EventEmitter } from "./EventEmitter";
+import {
+  EventEmittingComponent,
+  EventEmittingContainer,
+  EventsRecord,
+} from "./EventEmittingComponent";
+
+export type CastToEventsRecord<Record> = Record extends EventsRecord
+  ? Record
+  : {};
+
+export type ModuleEvents<ModuleType extends BaseModuleType> =
+  InstanceType<ModuleType> extends EventEmittingComponent<infer Events>
+    ? Events
+    : InstanceType<ModuleType> extends ModuleContainer<infer NestedModules>
+      ? CastToEventsRecord<ContainerEvents<NestedModules>>
+      : // &
+        // (InstanceType<ModuleType> extends EventEmittingContainer<
+        //   infer ContainerEvents
+        // >
+        //   ? ContainerEvents
+        //   : {})
+        EventsRecord;
+
+export type ContainerEvents<Modules extends ModulesRecord> = {
+  [Key in StringKeyOf<Modules>]: ModuleEvents<Modules[Key]>;
+};
+
+export type FlattenObject<Target extends Record<string, EventsRecord>> =
+  UnionToIntersection<Target[keyof Target]>;
+
+export type FlattenedContainerEvents<Modules extends ModulesRecord> =
+  FlattenObject<ContainerEvents<Modules>>; // & FlattenObject<any>;
+
+export class EventEmitterProxy<
+  Modules extends ModulesRecord,
+> extends EventEmitter<CastToEventsRecord<FlattenedContainerEvents<Modules>>> {
+  public constructor(private readonly container: ModuleContainer<Modules>) {
+    super();
+    container.moduleNames.forEach((moduleName) => {
+      if (container.isValidModuleName(container.definition, moduleName)) {
+        const module = container.resolve(moduleName);
+        if (this.isEventEmitter(module)) {
+          module.events.onAll((events: any, args: any[]) => {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+            this.emit(events, ...args);
+          });
+        }
+        if (this.isEventEmittingContainer(module)) {
+          module.containerEvents.onAll((events: any, args: any[]) => {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+            this.emit(events, ...args);
+          });
+        }
+      }
+    });
+  }
+
+  private isEventEmittingContainer(
+    module: any
+  ): module is EventEmittingContainer<EventsRecord> {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+    const emitter = module.containerEvents;
+    return emitter !== undefined && emitter instanceof EventEmitter;
+  }
+
+  private isEventEmitter(
+    module: any
+  ): module is EventEmittingComponent<EventsRecord> {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+    const emitter = module.events;
+    return emitter !== undefined && emitter instanceof EventEmitter;
+  }
+}

package/src/events/EventEmittingComponent.ts

@@ -0,0 +1,11 @@
+import type { EventEmitter } from "./EventEmitter";
+
+export type EventsRecord = Record<string, unknown[]>;
+
+export interface EventEmittingComponent<Events extends EventsRecord> {
+  events: EventEmitter<Events>;
+}
+
+export interface EventEmittingContainer<Events extends EventsRecord> {
+  containerEvents: EventEmitter<Events>;
+}

package/src/events/ReplayingSingleUseEventEmitter.ts

@@ -0,0 +1,42 @@
+import { EventsRecord } from "./EventEmittingComponent";
+import { EventEmitter } from "./EventEmitter";
+
+/**
+ * Event Emitter variant that emits a certain event only once to a registered listener.
+ * Additionally, if a listener registers to a event that has already been emitted, it
+ * re-emits it to said listener.
+ * This pattern is especially useful for listening for inclusions of transactions.
+ * Those events will only occur once, and listeners could come too late to the party,
+ * so we need to make sure they get notified as well in those cases.
+ */
+export class ReplayingSingleUseEventEmitter<
+  Events extends EventsRecord,
+> extends EventEmitter<Events> {
+  public emitted: Partial<Events> = {};
+
+  public emit<Key extends keyof Events>(
+    event: Key,
+    ...parameters: Events[Key]
+  ) {
+    super.emit(event, ...parameters);
+    this.emitted[event] = parameters;
+    this.listeners[event] = [];
+  }
+
+  public onAll(listener: (event: keyof Events, args: unknown[]) => void) {
+    Object.entries(this.emitted).forEach(([key, params]) => {
+      if (params !== undefined) listener(key, params);
+    });
+    super.onAll(listener);
+  }
+
+  public on<Key extends keyof Events>(
+    event: Key,
+    listener: (...args: Events[Key]) => void
+  ) {
+    if (this.emitted[event] !== undefined) {
+      listener(...this.emitted[event]!);
+    }
+    super.on(event, listener);
+  }
+}

package/src/index.ts

@@ -1,9 +1,31 @@
 export * from "./config/ModuleContainer";
 export * from "./config/ConfigurableModule";
+export * from "./config/ChildContainerProvider";
+export * from "./config/ChildContainerCreatable";
+export * from "./config/injectAlias";
+export * from "./config/Startable";
 export * from "./types";
 export * from "./zkProgrammable/ZkProgrammable";
 export * from "./zkProgrammable/ProvableMethodExecutionContext";
 export * from "./zkProgrammable/provableMethod";
 export * from "./utils";
-// eslint-disable-next-line import/no-unused-modules
-export { default as log } from "loglevel";
+export * from "./dependencyFactory/DependencyFactory";
+export * from "./log";
+export * from "./events/EventEmittingComponent";
+export * from "./events/EventEmitter";
+export * from "./trees/sparse/MerkleTreeStore";
+export * from "./trees/sparse/InMemoryMerkleTreeStorage";
+export * from "./trees/sparse/RollupMerkleTree";
+export * from "./trees/lmt/LinkedLeafStore";
+export * from "./trees/lmt/LinkedMerkleTree";
+export * from "./trees/lmt/InMemoryLinkedLeafStore";
+export * from "./trees/lmt/LinkedMerkleTreeCircuitOps";
+export * from "./trees/lmt/AbstractLinkedMerkleTree";
+export * from "./trees/lmt/LinkedMerkleTreeTypes";
+export * from "./events/EventEmitterProxy";
+export * from "./events/ReplayingSingleUseEventEmitter";
+export * from "./trees/sparse/MockAsyncMerkleStore";
+export * from "./compiling/AtomicCompileHelper";
+export * from "./compiling/CompileRegistry";
+export * from "./compiling/CompilableModule";
+export * from "./compiling/services/ChildVerificationKeyService";

package/src/log.ts

@@ -0,0 +1,143 @@
+import loglevel, { LogLevelDesc, LogLevelNames } from "loglevel";
+import { Provable } from "o1js";
+
+/* eslint-disable @typescript-eslint/no-unsafe-argument */
+function logProvable(
+  logFunction: (...args: unknown[]) => void,
+  ...args: any[]
+) {
+  Provable.asProver(() => {
+    const prettyArguments: string[] = [];
+
+    args.forEach((argument) => {
+      if (argument?.toPretty !== undefined) {
+        prettyArguments.push(argument.toPretty());
+      } else {
+        try {
+          prettyArguments.push(JSON.parse(JSON.stringify(argument)));
+        } catch {
+          prettyArguments.push(argument);
+        }
+      }
+    });
+    logFunction(...prettyArguments);
+  });
+}
+/* eslint-enable */
+
+// eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
+if (process.env?.IN_CI ?? false) {
+  loglevel.setLevel("ERROR");
+}
+
+const timeMap: Record<string, number> = {};
+
+function time(label = "time") {
+  timeMap[label] = Date.now();
+}
+
+function timeLog(label = "time"): string {
+  const prev = timeMap[label];
+  if (prev === undefined) {
+    return "Label not found";
+  }
+  return `${label} took ${Date.now() - prev}ms`;
+}
+
+function timeEnd(label = "time"): string {
+  const str = timeLog(label);
+  delete timeMap[label];
+  return str;
+}
+
+export const log = {
+  provable: {
+    info: (...args: unknown[]) => {
+      logProvable(loglevel.info, ...args);
+    },
+
+    debug: (...args: unknown[]) => {
+      logProvable(loglevel.debug, ...args);
+    },
+
+    error: (...args: unknown[]) => {
+      logProvable(loglevel.error, ...args);
+    },
+
+    trace: (...args: unknown[]) => {
+      logProvable(log.trace, ...args);
+    },
+
+    warn: (...args: unknown[]) => {
+      logProvable(loglevel.warn, ...args);
+    },
+  },
+
+  time,
+
+  timeLog: {
+    info: (label?: string) => loglevel.info(timeLog(label)),
+    debug: (label?: string) => loglevel.debug(timeLog(label)),
+    error: (label?: string) => loglevel.error(timeLog(label)),
+    trace: (label?: string) => loglevel.trace(timeLog(label)),
+    warn: (label?: string) => loglevel.warn(timeLog(label)),
+  },
+
+  timeEnd: {
+    info: (label?: string) => loglevel.info(timeEnd(label)),
+    debug: (label?: string) => loglevel.debug(timeEnd(label)),
+    error: (label?: string) => loglevel.error(timeEnd(label)),
+    trace: (label?: string) => loglevel.trace(timeEnd(label)),
+    warn: (label?: string) => loglevel.warn(timeEnd(label)),
+  },
+
+  info: (...args: unknown[]) => {
+    loglevel.info(...args);
+  },
+
+  debug: (...args: unknown[]) => {
+    loglevel.debug(...args);
+  },
+
+  error: (...args: unknown[]) => {
+    loglevel.error(...args);
+  },
+
+  trace: (...args: unknown[]) => {
+    // Loglevel prints the stack trace by default. To still be able to use trace
+    // inside out application, we use the level, but call debug() under the hood
+    if (loglevel.getLevel() <= loglevel.levels.TRACE) {
+      loglevel.debug(...args);
+    }
+  },
+
+  warn: (...args: unknown[]) => {
+    loglevel.warn(...args);
+  },
+
+  setLevel: (level: LogLevelDesc) => {
+    // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
+    if (!(process.env?.IN_CI ?? false)) {
+      loglevel.setLevel(level);
+    }
+  },
+
+  get levels() {
+    return loglevel.levels;
+  },
+
+  getLevel: () => loglevel.getLevel(),
+};
+
+const validLogLevels = ["TRACE", "DEBUG", "INFO", "WARN", "ERROR", "SILENT"];
+
+export function assertValidTextLogLevel(
+  level: string | number
+): asserts level is LogLevelNames {
+  if (
+    typeof level === "number" ||
+    !validLogLevels.includes(level.toUpperCase())
+  ) {
+    throw new Error(`${level} is not a valid loglevel`);
+  }
+}

package/src/trees/lmt/AbstractLinkedMerkleTree.ts

@@ -0,0 +1,102 @@
+import { Bool, Field, Struct } from "o1js";
+
+import { createMerkleTree, RollupMerkleTree } from "../sparse/RollupMerkleTree";
+import { TypedClass } from "../../types";
+import { MerkleTreeStore } from "../sparse/MerkleTreeStore";
+
+import { LinkedLeafStore } from "./LinkedLeafStore";
+import { LinkedLeafStruct } from "./LinkedMerkleTreeTypes";
+
+class RollupMerkleTreeWitness extends createMerkleTree(40).WITNESS {}
+
+type LinkedMerkleWitnessValue = {
+  leaf: LinkedLeafStruct;
+  merkleWitness: RollupMerkleTreeWitness;
+  checkMembership(root: Field, path: Field, value: Field): Bool;
+};
+
+// We use the RollupMerkleTreeWitness here, although we will actually implement
+// the RollupMerkleTreeWitnessV2 defined below when instantiating the class.
+class LinkedMerkleWitnessTemplate extends Struct({
+  leaf: LinkedLeafStruct,
+  merkleWitness: RollupMerkleTreeWitness,
+}) {
+  public checkMembership(root: Field, path: Field, value: Field): Bool {
+    // Mock implementation for typing
+    return Bool(true);
+  }
+}
+
+type LinkedOperationWitnessValue = {
+  leafPrevious: LinkedMerkleWitnessValue;
+  leafCurrent: LinkedMerkleWitnessValue;
+};
+
+class LinkedOperationWitnessTemplate extends Struct({
+  leafPrevious: LinkedMerkleWitnessTemplate,
+  leafCurrent: LinkedMerkleWitnessTemplate,
+}) {}
+
+export interface AbstractLinkedMerkleTree {
+  leafStore: LinkedLeafStore;
+
+  tree: RollupMerkleTree;
+
+  /**
+   * Returns the root of the [Merkle Tree](https://en.wikipedia.org/wiki/Merkle_tree).
+   * @returns The root of the Merkle Tree.
+   */
+  getRoot(): Field;
+
+  /**
+   * Sets the value of a leaf node at a given index to a given value.
+   * @param path of the leaf node.
+   * @param value New value.
+   */
+  setLeaf(path: bigint, value?: bigint): LinkedOperationWitnessValue;
+
+  setLeaves(batch: { path: bigint; value: bigint }[]): void;
+
+  /**
+   * Returns a leaf which lives at a given path.
+   * Errors otherwise.
+   * @param path Index of the node.
+   * @returns The data of the leaf.
+   */
+  getLeaf(path: bigint): LinkedLeafStruct | undefined;
+
+  /**
+   * Returns the witness (also known as
+   * [Merkle Proof or Merkle Witness](https://computersciencewiki.org/index.php/Merkle_proof))
+   * for the leaf at the given path.
+   * @param path Position of the leaf node.
+   * @returns The witness that belongs to the leaf.
+   */
+  getReadWitness(path: bigint): LinkedMerkleWitnessValue;
+}
+
+export interface AbstractLinkedMerkleTreeClass {
+  new (
+    store: MerkleTreeStore,
+    leafStore: LinkedLeafStore
+  ): AbstractLinkedMerkleTree;
+
+  WITNESS: typeof LinkedOperationWitnessTemplate & {
+    fromReadWitness(
+      readWitness: LinkedMerkleWitnessTemplate
+    ): LinkedOperationWitnessTemplate;
+  };
+
+  READ_WITNESS: typeof LinkedMerkleWitnessTemplate &
+    TypedClass<{
+      checkMembership(root: Field, path: Field, value: Field): Bool;
+    }>;
+
+  HEIGHT: number;
+
+  EMPTY_ROOT: Field;
+
+  dummyWitness(): LinkedOperationWitnessValue;
+
+  dummyReadWitness(): LinkedMerkleWitnessValue;
+}

package/src/trees/lmt/InMemoryLinkedLeafStore.ts

@@ -0,0 +1,42 @@
+import { LinkedLeafStore, LinkedLeaf } from "./LinkedLeafStore";
+
+export class InMemoryLinkedLeafStore implements LinkedLeafStore {
+  public leaves: {
+    [key: string]: { leaf: LinkedLeaf; index: bigint };
+  } = {};
+
+  public maximumIndex?: bigint;
+
+  public getLeaf(
+    path: bigint
+  ): { leaf: LinkedLeaf; index: bigint } | undefined {
+    return this.leaves[path.toString()];
+  }
+
+  public setLeaf(index: bigint, value: LinkedLeaf): void {
+    const leaf = this.getLeaf(value.path);
+
+    if (leaf !== undefined && leaf?.index !== index) {
+      throw new Error("Cannot change index of existing leaf");
+    }
+
+    this.leaves[value.path.toString()] = { leaf: value, index: index };
+    if (index > (this.maximumIndex ?? -1)) {
+      this.maximumIndex = index;
+    }
+  }
+
+  public getMaximumIndex(): bigint | undefined {
+    return this.maximumIndex;
+  }
+
+  // This gets the leaf with the closest path.
+  public getPreviousLeaf(
+    path: bigint
+  ): { leaf: LinkedLeaf; index: bigint } | undefined {
+    return Object.values(this.leaves).find(
+      (storedLeaf) =>
+        storedLeaf.leaf.nextPath > path && storedLeaf.leaf.path < path
+    );
+  }
+}

package/src/trees/lmt/LinkedLeafStore.ts

@@ -0,0 +1,13 @@
+export type LinkedLeaf = { value: bigint; path: bigint; nextPath: bigint };
+
+export type StoredLeaf = { leaf: LinkedLeaf; index: bigint };
+
+export interface LinkedLeafStore {
+  setLeaf: (index: bigint, value: LinkedLeaf) => void;
+
+  getLeaf: (path: bigint) => StoredLeaf | undefined;
+
+  getPreviousLeaf: (path: bigint) => StoredLeaf | undefined;
+
+  getMaximumIndex: () => bigint | undefined;
+}