@proto-kit/common 0.1.1-develop.211 → 0.1.1-develop.2137

package/src/dependencyFactory/DependencyFactory.ts

@@ -1,24 +1,23 @@
-import { DependencyContainer, injectable, Lifecycle } from "tsyringe";
+import {
+  ClassProvider,
+  FactoryProvider,
+  TokenProvider,
+  ValueProvider,
+} from "tsyringe";
 
 import { TypedClass } from "../types";
+import type { BaseModuleInstanceType } from "../config/ModuleContainer";
 
-const errors = {
-  descriptorUndefined: () =>
-    new Error("Descriptor of that dependency is undefined!"),
+export type DependencyDeclaration<Dependency> =
+  | ClassProvider<Dependency>
+  | FactoryProvider<Dependency>
+  | TokenProvider<Dependency>
+  | ValueProvider<Dependency>;
 
-  dependencyFactoryCalledDirectly: () =>
-    new Error(
-      "You cannot access the depdendency method directly, use container.resolve"
-    ),
-};
-
-const globalFactoryDependencies = new Map<
+export type DependencyRecord = Record<
   string,
-  | {
-      [key: string]: () => unknown;
-    }
-  | undefined
->();
+  DependencyDeclaration<unknown> & { forceOverwrite?: boolean }
+>;
 
 /**
  * This is an abstract class for creating DependencyFactories, a pattern
@@ -31,102 +30,28 @@ const globalFactoryDependencies = new Map<
  *
  * DependencyFactories are designed to only be used statically for sets of
  * deps that are necessary for the sequencer to work.
- *
- * Every Factory need the @dependencyFactory annotation (which basically
- * proxies @injectable()) and every method that returns a dependency has to be
- * of the format `() => Dependency` and be annotated with @dependency.
  */
-export abstract class DependencyFactory {
-  public initDependencies(container: DependencyContainer) {
-    const dependencies =
-      globalFactoryDependencies.get(this.constructor.name) ?? {};
-    globalFactoryDependencies.delete(this.constructor.name);
-
-    for (const [key, useFactory] of Object.entries(dependencies)) {
-      container.register(`${key}_singleton-prototype`, {
-        useFactory: useFactory.bind(this),
-      });
-
-      const upperCaseKey = key.charAt(0).toUpperCase() + key.slice(1);
-
-      container.register(
-        upperCaseKey,
-        {
-          useToken: `${key}_singleton-prototype`,
-        },
-        { lifecycle: Lifecycle.ContainerScoped }
-      );
-    }
-  }
+export interface DependencyFactory {
+  dependencies: () => DependencyRecord;
 }
 
-// type DTypes = { [key: string]: TypedClass<unknown> }
-// type Factories<T extends DTypes> = {
-//   [key in keyof T]: T[key] extends TypedClass<infer R> ? () => R : never
-// }
-//
-// export abstract class DF2<Types extends DTypes> {
-//   public constructor(private factories: Factories<Types>) {
-//
-//   }
-//   generateDependencies(): Types {
-//     let x = this.factories;
-//     return {} as Types;
-//   }
-// }
+export type TypeFromDependencyDeclaration<
+  Declaration extends DependencyDeclaration<unknown>,
+> =
+  Declaration extends DependencyDeclaration<infer Dependency>
+    ? Dependency
+    : never;
 
-// export function DF2C<T extends Types>(object: Factories<T>): T {
-//   const c = class C extends DF2<T>{
-//     generateDependencies(): T {
-//       return undefined;
-//     }
-//   }
-//   return new c();
-// }
+export type CapitalizeAny<Key extends string | number | symbol> =
+  Key extends string ? Capitalize<Key> : Key;
 
-// class DF2I extends DF2<{x: typeof ConfigurableModule}> {
-//   constructor() {
-//     super({
-//       x: this.x
-//     });
-//   }
-//
-//   x(): ConfigurableModule<any> {
-//     return {} as ConfigurableModule<any>;
-//   }
-//
-// }
-
-export function dependency() {
-  return function decorator<Target extends DependencyFactory, Dependency>(
-    target: Target,
-    key: string,
-    descriptor: TypedPropertyDescriptor<() => Dependency>
-  ) {
-    if (descriptor.value !== undefined) {
-      const className = target.constructor.name;
-      if (!globalFactoryDependencies.has(className)) {
-        globalFactoryDependencies.set(className, {});
-      }
-
-      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-      globalFactoryDependencies.get(target.constructor.name)![key] =
-        descriptor.value;
-
-      descriptor.value = () => {
-        throw errors.dependencyFactoryCalledDirectly();
-      };
-    } else {
-      throw errors.descriptorUndefined();
-    }
-    return descriptor;
-  };
-}
+export type MapDependencyRecordToTypes<Record extends DependencyRecord> = {
+  [Key in keyof Record as CapitalizeAny<Key>]: TypedClass<
+    TypeFromDependencyDeclaration<Record[Key]>
+  >;
+};
 
-export function dependencyFactory() {
-  return function decorator<Target extends DependencyFactory>(
-    target: TypedClass<Target>
-  ) {
-    injectable()(target);
-  };
-}
+export type InferDependencies<Class extends BaseModuleInstanceType> =
+  Class extends DependencyFactory
+    ? MapDependencyRecordToTypes<ReturnType<Class["dependencies"]>>
+    : never;

package/src/dummyVerificationKey.ts

@@ -0,0 +1,10 @@
+import { Field, VerificationKey } from "o1js";
+
+export function dummyVerificationKey() {
+  return new VerificationKey({
+    hash: Field(
+      "3392518251768960475377392625298437850623664973002200885669375116181514017494"
+    ),
+    data: "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",
+  });
+}

package/src/events/EventEmitter.ts

@@ -0,0 +1,61 @@
+import { EventsRecord } from "./EventEmittingComponent";
+
+type ListenersHolder<Events extends EventsRecord> = {
+  [key in keyof Events]?: ((...args: Events[key]) => void)[];
+};
+
+export class EventEmitter<Events extends EventsRecord> {
+  protected readonly listeners: ListenersHolder<Events> = {};
+
+  protected readonly wildcardListeners: ((
+    event: keyof Events,
+    args: Events[keyof Events]
+  ) => void)[] = [];
+
+  public emit<Key extends keyof Events>(
+    event: Key,
+    ...parameters: Events[Key]
+  ) {
+    const listeners = this.listeners[event];
+    if (listeners !== undefined) {
+      listeners.forEach((listener) => {
+        listener(...parameters);
+      });
+    }
+    this.wildcardListeners.forEach((wildcardListener) => {
+      wildcardListener(event, parameters);
+    });
+  }
+
+  public onAll(listener: (event: keyof Events, args: unknown[]) => void): void {
+    this.wildcardListeners.push(listener);
+  }
+
+  public on<Key extends keyof Events>(
+    event: Key,
+    listener: (...args: Events[Key]) => void
+  ) {
+    (this.listeners[event] ??= []).push(listener);
+  }
+
+  /**
+   * Primitive .off() with identity comparison for now.
+   * Could be replaced by returning an id in .on() and using that.
+   */
+  public off<Key extends keyof Events>(
+    event: Key,
+    listener: (...args: Events[Key]) => void
+  ) {
+    const events = this.listeners[event];
+    if (events !== undefined) {
+      this.listeners[event] = events.filter(
+        (candidate) => candidate !== listener
+      );
+    }
+  }
+}
+
+export type EventListenable<Events extends EventsRecord> = Pick<
+  EventEmitter<Events>,
+  "on" | "onAll" | "off"
+>;

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,10 +1,35 @@
 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";
 export * from "./dependencyFactory/DependencyFactory";
-// eslint-disable-next-line import/no-unused-modules
-export { default as log } from "loglevel";
+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";
+export * from "./cache/RemoteCache";
+export * from "./cache/RemoteCacheCompiler";
+export * from "./cache/CacheManifest";
+export * from "./cache/ProxyCache";

package/src/log.ts

@@ -0,0 +1,145 @@
+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");
+} else {
+  loglevel.setLevel("INFO");
+}
+
+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;
+}