@proto-kit/common 0.1.1-develop.1086

package/src/utils.ts

@@ -0,0 +1,149 @@
+import {
+  Field,
+  FlexibleProvablePure,
+  Poseidon,
+  DynamicProof,
+  Proof,
+} from "o1js";
+
+export function requireTrue(
+  condition: boolean,
+  errorOrFunction: Error | (() => Error)
+): void {
+  if (!condition) {
+    throw typeof errorOrFunction === "function"
+      ? errorOrFunction()
+      : errorOrFunction;
+  }
+}
+
+export function range(
+  startOrEnd: number,
+  endOrNothing?: number | undefined
+): number[] {
+  let end = endOrNothing;
+  let start = startOrEnd;
+  if (end === undefined) {
+    end = startOrEnd;
+    start = 0;
+  }
+  return Array.from({ length: end - start }, (ignored, index) => index + start);
+}
+
+export function reduceSequential<T, U>(
+  array: T[],
+  callbackfn: (
+    previousValue: U,
+    currentValue: T,
+    currentIndex: number,
+    array: T[]
+  ) => Promise<U>,
+  initialValue: U
+) {
+  return array.reduce<Promise<U>>(
+    async (previousPromise, current, index, arr) => {
+      const previous = await previousPromise;
+      return await callbackfn(previous, current, index, arr);
+    },
+    Promise.resolve(initialValue)
+  );
+}
+
+export function mapSequential<T, R>(
+  array: T[],
+  f: (element: T, index: number, array: T[]) => Promise<R>
+) {
+  return array.reduce<Promise<R[]>>(async (r, element, index, a) => {
+    const ret = await r;
+    const next = await f(element, index, a);
+    ret.push(next);
+    return ret;
+  }, Promise.resolve([]));
+}
+
+/**
+ * Computes a dummy value for the given value type.
+ *
+ * @param valueType - Value type to generate the dummy value for
+ * @returns Dummy value for the given value type
+ */
+export function dummyValue<Value>(
+  valueType: FlexibleProvablePure<Value>
+): Value {
+  const length = valueType.sizeInFields();
+  const fields = Array.from({ length }, () => Field(0));
+
+  // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+  return valueType.fromFields(fields) as Value;
+}
+
+export function noop(): void {}
+
+export interface ToFieldable {
+  toFields: () => Field[];
+}
+
+export interface ToFieldableStatic {
+  toFields: (value: unknown) => Field[];
+}
+
+export interface ToJSONableStatic {
+  toJSON: (value: unknown) => any;
+}
+
+// export interface ProofTypes {
+//   publicOutputType?: ToFieldableStatic;
+//   publicInputType?: ToFieldableStatic;
+// }
+
+export type ProofTypes =
+  | typeof Proof<unknown, unknown>
+  | typeof DynamicProof<unknown, unknown>;
+
+export async function sleep(ms: number) {
+  await new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+}
+
+export function filterNonNull<Type>(value: Type | null): value is Type {
+  return value !== null;
+}
+
+export function filterNonUndefined<Type>(
+  value: Type | undefined
+): value is Type {
+  return value !== undefined;
+}
+
+const encoder = new TextEncoder();
+
+// Copied from o1js binable.ts:317
+export function prefixToField(prefix: string): Field {
+  const fieldSize = Field.sizeInBytes;
+  if (prefix.length >= fieldSize) throw Error("prefix too long");
+  const stringBytes = [...encoder.encode(prefix)];
+  return Field.fromBytes(
+    stringBytes.concat(Array(fieldSize - stringBytes.length).fill(0))
+  );
+}
+
+export function hashWithPrefix(prefix: string, input: Field[]) {
+  const salt = Poseidon.update(
+    [Field(0), Field(0), Field(0)],
+    [prefixToField(prefix)]
+  );
+  // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+  return Poseidon.update(salt as [Field, Field, Field], input)[0];
+}
+
+// end copy
+
+export function expectDefined<T>(value: T | undefined): asserts value is T {
+  expect(value).toBeDefined();
+}
+
+type NonMethodKeys<Type> = {
+  [Key in keyof Type]: Type[Key] extends Function ? never : Key;
+}[keyof Type];
+export type NonMethods<Type> = Pick<Type, NonMethodKeys<Type>>;

package/src/zkProgrammable/ProvableMethodExecutionContext.ts

@@ -0,0 +1,122 @@
+import type { Proof } from "o1js";
+import { singleton } from "tsyringe";
+import uniqueId from "lodash/uniqueId";
+
+import type { ArgumentTypes } from "./provableMethod";
+
+const errors = {
+  moduleOrMethodNameNotSet: () => new Error("Module or method name not set"),
+
+  proverNotSet: (moduleName: string, methodName: string) =>
+    new Error(
+      `Prover not set for '${moduleName}.${methodName}', did you forget to decorate your method?`
+    ),
+};
+
+export class ProvableMethodExecutionResult {
+  public moduleName?: string;
+
+  public methodName?: string;
+
+  public args?: ArgumentTypes;
+
+  public prover?: () => Promise<Proof<unknown, unknown>>;
+
+  public async prove<
+    ProofType extends Proof<unknown, unknown>,
+  >(): Promise<ProofType> {
+    if (!this.prover) {
+      // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
+      if (!this.moduleName || !this.methodName) {
+        throw errors.moduleOrMethodNameNotSet();
+      }
+      throw errors.proverNotSet(this.moduleName, this.methodName);
+    }
+
+    // turn the prover result into the desired proof type
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    return (await this.prover()) as ProofType;
+  }
+}
+
+/**
+ * Execution context used to wrap runtime module methods,
+ * allowing them to post relevant information (such as execution status)
+ * into the context without any unnecessary 'prop drilling'.
+ */
+@singleton()
+export class ProvableMethodExecutionContext {
+  public id = uniqueId();
+
+  public methods: string[] = [];
+
+  public result: ProvableMethodExecutionResult =
+    new ProvableMethodExecutionResult();
+
+  // TODO See if we should make this class generic, bc I think we can persist the type
+  /**
+   * Adds a method prover to the current execution context,
+   * which can be collected and ran asynchronously at a later point in time.
+   *
+   * @param prove - Prover function to be ran later,
+   * when the method execution needs to be proven
+   */
+  public setProver(prover: () => Promise<Proof<unknown, unknown>>) {
+    this.result.prover = prover;
+  }
+
+  /**
+   * Adds a method to the method execution stack, reseting the execution context
+   * in a case a new top-level (non nested) method call is made.
+   *
+   * @param methodName - Name of the method being captured in the context
+   */
+  public beforeMethod(
+    moduleName: string,
+    methodName: string,
+    args: ArgumentTypes
+  ) {
+    if (this.isFinished) {
+      this.clear();
+      this.result.moduleName = moduleName;
+      this.result.methodName = methodName;
+      this.result.args = args;
+    }
+
+    this.methods.push(methodName);
+  }
+
+  /**
+   * Removes the latest method from the execution context stack,
+   * keeping track of the amount of 'unfinished' methods. Allowing
+   * for the context to distinguish between top-level and nested method calls.
+   */
+  public afterMethod() {
+    this.methods.pop();
+  }
+
+  public get isTopLevel() {
+    return this.methods.length === 1;
+  }
+
+  public get isFinished() {
+    return this.methods.length === 0;
+  }
+
+  /**
+   * @returns - Current execution context state
+   */
+  public current() {
+    return {
+      isFinished: this.isFinished,
+      result: this.result,
+    };
+  }
+
+  /**
+   * Manually clears/resets the execution context
+   */
+  public clear() {
+    this.result = new ProvableMethodExecutionResult();
+  }
+}

package/src/zkProgrammable/ZkProgrammable.ts

@@ -0,0 +1,131 @@
+import { ZkProgram, FlexibleProvablePure, Proof, Field, Provable } from "o1js";
+import { Memoize } from "typescript-memoize";
+
+import { log } from "../log";
+
+import { MOCK_PROOF } from "./provableMethod";
+
+const errors = {
+  appChainNotSet: (name: string) =>
+    new Error(`Appchain was not injected for: ${name}`),
+};
+
+export interface CompileArtifact {
+  verificationKey: {
+    data: string;
+    hash: Field;
+  };
+}
+
+export interface AreProofsEnabled {
+  areProofsEnabled: boolean;
+  setProofsEnabled: (areProofsEnabled: boolean) => void;
+}
+
+export interface Verify<PublicInput, PublicOutput> {
+  (proof: Proof<PublicInput, PublicOutput>): Promise<boolean>;
+}
+
+export interface Compile {
+  (): Promise<CompileArtifact>;
+}
+
+export interface PlainZkProgram<PublicInput = undefined, PublicOutput = void> {
+  compile: Compile;
+  verify: Verify<PublicInput, PublicOutput>;
+  Proof: ReturnType<
+    typeof ZkProgram.Proof<
+      FlexibleProvablePure<PublicInput>,
+      FlexibleProvablePure<PublicOutput>
+    >
+  >;
+  methods: Record<
+    string,
+    | ((...args: any) => Promise<Proof<PublicInput, PublicOutput>>)
+    | ((
+        publicInput: PublicInput,
+        ...args: any
+      ) => Promise<Proof<PublicInput, PublicOutput>>)
+  >;
+  analyzeMethods: () => Promise<
+    Record<string, Awaited<ReturnType<typeof Provable.constraintSystem>>>
+  >;
+}
+
+export function verifyToMockable<PublicInput, PublicOutput>(
+  verify: Verify<PublicInput, PublicOutput>,
+  { areProofsEnabled }: AreProofsEnabled
+) {
+  return async (proof: Proof<PublicInput, PublicOutput>) => {
+    if (areProofsEnabled) {
+      let verified = false;
+
+      try {
+        verified = await verify(proof);
+      } catch (error: unknown) {
+        // silently fail verification
+        log.error(error);
+        verified = false;
+      }
+
+      return verified;
+    }
+
+    return proof.proof === MOCK_PROOF;
+  };
+}
+
+export const MOCK_VERIFICATION_KEY = {
+  data: "mock-verification-key",
+  hash: Field(0),
+};
+
+export function compileToMockable(
+  compile: Compile,
+  { areProofsEnabled }: AreProofsEnabled
+): () => Promise<CompileArtifact> {
+  return async () => {
+    if (areProofsEnabled) {
+      return await compile();
+    }
+
+    return {
+      verificationKey: MOCK_VERIFICATION_KEY,
+    };
+  };
+}
+
+export abstract class ZkProgrammable<
+  PublicInput = undefined,
+  PublicOutput = void,
+> {
+  public abstract get appChain(): AreProofsEnabled | undefined;
+
+  public abstract zkProgramFactory(): PlainZkProgram<
+    PublicInput,
+    PublicOutput
+  >[];
+
+  @Memoize()
+  public get zkProgram(): PlainZkProgram<PublicInput, PublicOutput>[] {
+    const zkProgram = this.zkProgramFactory();
+
+    return zkProgram.map((bucket) => {
+      if (!this.appChain) {
+        throw errors.appChainNotSet(this.constructor.name);
+      }
+      return {
+        ...bucket,
+        verify: verifyToMockable(bucket.verify, this.appChain),
+        compile: compileToMockable(bucket.compile, this.appChain),
+      };
+    });
+  }
+}
+
+export interface WithZkProgrammable<
+  PublicInput = undefined,
+  PublicOutput = void,
+> {
+  zkProgrammable: ZkProgrammable<PublicInput, PublicOutput>;
+}

package/src/zkProgrammable/provableMethod.ts

@@ -0,0 +1,123 @@
+import { Proof, DynamicProof } from "o1js";
+import { container } from "tsyringe";
+
+import { ProvableMethodExecutionContext } from "./ProvableMethodExecutionContext";
+import type { WithZkProgrammable, ZkProgrammable } from "./ZkProgrammable";
+
+// Now, in o1js provable types are normal js objects, therefore any
+export type O1JSPrimitive = object | string | boolean | number;
+export type ArgumentTypes = (
+  | O1JSPrimitive
+  | Proof<unknown, unknown>
+  | DynamicProof<unknown, unknown>
+)[];
+
+export type DecoratedMethod = (...args: ArgumentTypes) => Promise<unknown>;
+
+export const MOCK_PROOF = "mock-proof";
+
+export function toProver(
+  methodName: string,
+  simulatedMethod: DecoratedMethod,
+  isFirstParameterPublicInput: boolean,
+  ...args: ArgumentTypes
+) {
+  return async function prover(this: ZkProgrammable<any, any>) {
+    const areProofsEnabled = this.appChain?.areProofsEnabled;
+    if (areProofsEnabled ?? false) {
+      for (const prog of this.zkProgram) {
+        if (Object.keys(prog.methods).includes(methodName)) {
+          const programProvableMethod = prog.methods[methodName];
+          // eslint-disable-next-line no-await-in-loop
+          return await Reflect.apply(programProvableMethod, this, args);
+        }
+      }
+    }
+
+    // create a mock proof by simulating method execution in JS
+    const publicOutput = await Reflect.apply(simulatedMethod, this, args);
+    const zkProgram =
+      this.zkProgram.find((prog) => {
+        return Object.keys(prog.methods).includes(methodName);
+      }) ?? this.zkProgram[0];
+
+    return new zkProgram.Proof({
+      proof: MOCK_PROOF,
+
+      // TODO: provide undefined if public input is not used
+      publicInput: isFirstParameterPublicInput ? args[0] : undefined,
+      publicOutput,
+
+      /**
+       * We set this to the max possible number, to avoid having
+       * to manually count in-circuit proof verifications
+       */
+      maxProofsVerified: 2,
+    });
+  };
+}
+
+/**
+ * Decorates a provable method on a 'prover class', depending on
+ * if proofs are enabled or not, either runs the respective zkProgram prover,
+ * or simulates the method execution and issues a mock proof.
+ *
+ * @param isFirstParameterPublicInput
+ * @param executionContext
+ * @returns
+ */
+export function provableMethod(
+  isFirstParameterPublicInput = true,
+  executionContext: ProvableMethodExecutionContext = container.resolve<ProvableMethodExecutionContext>(
+    ProvableMethodExecutionContext
+  )
+) {
+  return <
+    Target extends WithZkProgrammable<any, any> | ZkProgrammable<any, any>,
+  >(
+    target: Target,
+    methodName: string,
+    descriptor: TypedPropertyDescriptor<(...args: any[]) => Promise<any> | any>
+  ) => {
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    const simulatedMethod = descriptor.value as DecoratedMethod;
+
+    descriptor.value = async function value(
+      this: ZkProgrammable<unknown, unknown>,
+      ...args: ArgumentTypes
+    ) {
+      const prover = toProver(
+        methodName,
+        simulatedMethod,
+        isFirstParameterPublicInput,
+        ...args
+      );
+
+      executionContext.beforeMethod(this.constructor.name, methodName, args);
+
+      /**
+       * Check if the method is called at the top level,
+       * if yes then create a prover.
+       */
+      if (executionContext.isTopLevel) {
+        executionContext.setProver(prover.bind(this));
+      }
+
+      /**
+       * Regardless of if the method is called from the top level
+       * or not, execute its simulated (Javascript) version and
+       * return the result.
+       */
+      let result: unknown;
+      try {
+        result = Reflect.apply(simulatedMethod, this, args);
+      } finally {
+        executionContext.afterMethod();
+      }
+
+      return result;
+    };
+
+    return descriptor;
+  };
+}

package/test/config/ContainerEvents.test.ts

@@ -0,0 +1,67 @@
+import "reflect-metadata";
+import { injectable, container as tsyringeContainer } from "tsyringe";
+
+import {
+  BaseModuleInstanceType,
+  ConfigurableModule,
+  EventEmitter,
+  EventEmittingComponent,
+  ModuleContainer,
+  ModulesRecord,
+} from "../../src";
+
+class TestContainer<
+  Modules extends ModulesRecord,
+> extends ModuleContainer<Modules> {}
+
+type TestEvents = {
+  test: [string];
+};
+
+@injectable()
+class TestModule
+  extends ConfigurableModule<{}>
+  implements BaseModuleInstanceType, EventEmittingComponent<TestEvents>
+{
+  events = new EventEmitter<TestEvents>();
+}
+
+type TestEvents2 = {
+  test2: [number];
+};
+
+class TestModule2
+  extends ConfigurableModule<{}>
+  implements BaseModuleInstanceType, EventEmittingComponent<TestEvents2>
+{
+  events = new EventEmitter<TestEvents2>();
+}
+
+describe("test event propagation", () => {
+  it("should propagate events up", () => {
+    expect.assertions(1);
+
+    const container = new TestContainer({
+      modules: {
+        test: TestModule,
+        test2: TestModule2,
+      },
+    });
+
+    container.configure({
+      test: {},
+      test2: {},
+    });
+
+    container.create(() => tsyringeContainer.createChildContainer());
+
+    const testvalue = "testString123";
+
+    container.events.on("test", (value: string) => {
+      expect(value).toStrictEqual(testvalue);
+    });
+
+    const module = container.resolve("test");
+    module.events.emit("test", testvalue);
+  });
+});