@proto-kit/common 0.1.1-develop.651 → 0.1.1-develop.833

package/src/utils.ts

@@ -1,4 +1,10 @@
-import { Field, FlexibleProvablePure, Poseidon } from "o1js";
+import {
+  Field,
+  FlexibleProvablePure,
+  Poseidon,
+  DynamicProof,
+  Proof,
+} from "o1js";
 
 export function requireTrue(
   condition: boolean,
@@ -11,17 +17,50 @@ export function requireTrue(
   }
 }
 
-export function range(startOrEnd: number, end: number | undefined): number[] {
+export function range(
+  startOrEnd: number,
+  endOrNothing: number | undefined
+): number[] {
+  let end = endOrNothing;
+  let start = startOrEnd;
   if (end === undefined) {
     end = startOrEnd;
-    startOrEnd = 0;
+    start = 0;
   }
-  return Array.from(
-    { length: end - startOrEnd },
-    (ignored, index) => index + startOrEnd
+  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.
  *
@@ -38,7 +77,6 @@ export function dummyValue<Value>(
   return valueType.fromFields(fields) as Value;
 }
 
-// eslint-disable-next-line @typescript-eslint/no-empty-function
 export function noop(): void {}
 
 export interface ToFieldable {
@@ -53,14 +91,19 @@ export interface ToJSONableStatic {
   toJSON: (value: unknown) => any;
 }
 
-export interface ProofTypes {
-  publicOutputType?: ToFieldableStatic;
-  publicInputType?: ToFieldableStatic;
-}
+// export interface ProofTypes {
+//   publicOutputType?: ToFieldableStatic;
+//   publicInputType?: ToFieldableStatic;
+// }
+
+export type ProofTypes =
+  | typeof Proof<unknown, unknown>
+  | typeof DynamicProof<unknown, unknown>;
 
 export async function sleep(ms: number) {
-  // eslint-disable-next-line promise/avoid-new,no-promise-executor-return
-  await new Promise((resolve) => setTimeout(resolve, ms));
+  await new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
 }
 
 export function filterNonNull<Type>(value: Type | null): value is Type {
@@ -73,19 +116,34 @@ export function filterNonUndefined<Type>(
   return value !== undefined;
 }
 
-let encoder = new TextEncoder();
+const encoder = new TextEncoder();
 
 // Copied from o1js binable.ts:317
 export function prefixToField(prefix: string): Field {
-  let fieldSize = Field.sizeInBytes();
+  const fieldSize = Field.sizeInBytes;
   if (prefix.length >= fieldSize) throw Error("prefix too long");
-  let stringBytes = [...encoder.encode(prefix)];
+  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)])
-  return Poseidon.update(salt as [Field, Field, Field], input)[0]
-}
+  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

@@ -1,4 +1,4 @@
-import type { FlexibleProvable, Proof } from "o1js";
+import type { Proof } from "o1js";
 import { singleton } from "tsyringe";
 import uniqueId from "lodash/uniqueId";
 
@@ -23,8 +23,7 @@ export class ProvableMethodExecutionResult {
   public prover?: () => Promise<Proof<unknown, unknown>>;
 
   public async prove<
-    // eslint-disable-next-line etc/no-misused-generics
-    ProofType extends Proof<unknown, unknown>
+    ProofType extends Proof<unknown, unknown>,
   >(): Promise<ProofType> {
     if (!this.prover) {
       // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
@@ -54,7 +53,6 @@ export class ProvableMethodExecutionContext {
   public result: ProvableMethodExecutionResult =
     new ProvableMethodExecutionResult();
 
-  // eslint-disable-next-line no-warning-comments,max-len
   // 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,

package/src/zkProgrammable/ZkProgrammable.ts

@@ -1,6 +1,8 @@
-import { Experimental, FlexibleProvablePure, Proof } from "o1js";
+import { ZkProgram, FlexibleProvablePure, Proof, Field, Provable } from "o1js";
 import { Memoize } from "typescript-memoize";
 
+import { log } from "../log";
+
 import { MOCK_PROOF } from "./provableMethod";
 
 const errors = {
@@ -9,7 +11,10 @@ const errors = {
 };
 
 export interface CompileArtifact {
-  verificationKey: string;
+  verificationKey: {
+    data: string;
+    hash: Field;
+  };
 }
 
 export interface AreProofsEnabled {
@@ -29,24 +34,22 @@ export interface PlainZkProgram<PublicInput = undefined, PublicOutput = void> {
   compile: Compile;
   verify: Verify<PublicInput, PublicOutput>;
   Proof: ReturnType<
-    typeof Experimental.ZkProgram.Proof<
+    typeof ZkProgram.Proof<
       FlexibleProvablePure<PublicInput>,
       FlexibleProvablePure<PublicOutput>
     >
   >;
   methods: Record<
     string,
-    | ((
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        ...args: any
-      ) => Promise<Proof<PublicInput, PublicOutput>>)
+    | ((...args: any) => Promise<Proof<PublicInput, PublicOutput>>)
     | ((
         publicInput: PublicInput,
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         ...args: any
       ) => Promise<Proof<PublicInput, PublicOutput>>)
   >;
-  analyzeMethods: ReturnType<typeof Experimental.ZkProgram>["analyzeMethods"];
+  analyzeMethods: () => Promise<
+    Record<string, Awaited<ReturnType<typeof Provable.constraintSystem>>>
+  >;
 }
 
 export function verifyToMockable<PublicInput, PublicOutput>(
@@ -61,7 +64,7 @@ export function verifyToMockable<PublicInput, PublicOutput>(
         verified = await verify(proof);
       } catch (error: unknown) {
         // silently fail verification
-        console.error(error);
+        log.error(error);
         verified = false;
       }
 
@@ -72,7 +75,10 @@ export function verifyToMockable<PublicInput, PublicOutput>(
   };
 }
 
-export const MOCK_VERIFICATION_KEY = "mock-verification-key";
+export const MOCK_VERIFICATION_KEY = {
+  data: "mock-verification-key",
+  hash: Field(0),
+};
 
 export function compileToMockable(
   compile: Compile,
@@ -91,7 +97,7 @@ export function compileToMockable(
 
 export abstract class ZkProgrammable<
   PublicInput = undefined,
-  PublicOutput = void
+  PublicOutput = void,
 > {
   public abstract get appChain(): AreProofsEnabled | undefined;
 
@@ -115,7 +121,7 @@ export abstract class ZkProgrammable<
 
 export interface WithZkProgrammable<
   PublicInput = undefined,
-  PublicOutput = void
+  PublicOutput = void,
 > {
   zkProgrammable: ZkProgrammable<PublicInput, PublicOutput>;
 }

package/src/zkProgrammable/provableMethod.ts

@@ -1,16 +1,18 @@
-import { FlexibleProvable, InferProvable, Proof, ProvableExtended } from "o1js";
+import { Proof, DynamicProof } from "o1js";
 import { container } from "tsyringe";
 
 import { ProvableMethodExecutionContext } from "./ProvableMethodExecutionContext";
 import type { WithZkProgrammable, ZkProgrammable } from "./ZkProgrammable";
-import { ToFieldable } from "../utils";
 
-export type O1JSPrimitive = InferProvable<ProvableExtended<unknown>> &
-  ToFieldable;
-export type ArgumentTypes = (O1JSPrimitive | Proof<unknown, unknown>)[];
+// 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>
+)[];
 
-// eslint-disable-next-line etc/prefer-interface
-export type DecoratedMethod = (...args: ArgumentTypes) => unknown;
+export type DecoratedMethod = (...args: ArgumentTypes) => Promise<unknown>;
 
 export const MOCK_PROOF = "mock-proof";
 
@@ -20,7 +22,6 @@ export function toProver(
   isFirstParameterPublicInput: boolean,
   ...args: ArgumentTypes
 ) {
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
   return async function prover(this: ZkProgrammable<any, any>) {
     const areProofsEnabled = this.appChain?.areProofsEnabled;
     if (areProofsEnabled ?? false) {
@@ -29,12 +30,11 @@ export function toProver(
     }
 
     // create a mock proof by simulating method execution in JS
-    const publicOutput = Reflect.apply(simulatedMethod, this, args);
+    const publicOutput = await Reflect.apply(simulatedMethod, this, args);
 
     return new this.zkProgram.Proof({
       proof: MOCK_PROOF,
 
-      // eslint-disable-next-line no-warning-comments
       // TODO: provide undefined if public input is not used
       publicInput: isFirstParameterPublicInput ? args[0] : undefined,
       publicOutput,
@@ -64,17 +64,16 @@ export function provableMethod(
   )
 ) {
   return <
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    Target extends WithZkProgrammable<any, any> | ZkProgrammable<any, any>
+    Target extends WithZkProgrammable<any, any> | ZkProgrammable<any, any>,
   >(
     target: Target,
     methodName: string,
-    descriptor: PropertyDescriptor
+    descriptor: TypedPropertyDescriptor<(...args: any[]) => Promise<any> | any>
   ) => {
     // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
     const simulatedMethod = descriptor.value as DecoratedMethod;
 
-    descriptor.value = function value(
+    descriptor.value = async function value(
       this: ZkProgrammable<unknown, unknown>,
       ...args: ArgumentTypes
     ) {
@@ -100,7 +99,6 @@ export function provableMethod(
        * or not, execute its simulated (Javascript) version and
        * return the result.
        */
-      // eslint-disable-next-line @typescript-eslint/init-declarations
       let result: unknown;
       try {
         result = Reflect.apply(simulatedMethod, this, args);

package/test/config/ContainerEvents.test.ts

@@ -1,30 +1,22 @@
 import "reflect-metadata";
+import { injectable, container as tsyringeContainer } from "tsyringe";
+
 import {
   BaseModuleInstanceType,
-  BaseModuleType,
   ConfigurableModule,
   EventEmitter,
   EventEmittingComponent,
-  EventsRecord,
   ModuleContainer,
   ModulesRecord,
-  TypedClass,
 } from "../../src";
-import { injectable, container as tsyringeContainer } from "tsyringe";
-import {
-  CastToEventsRecord,
-  ContainerEvents,
-  FlattenedContainerEvents,
-  FlattenObject,
-} from "../../src/events/EventEmitterProxy";
 
 class TestContainer<
-  Modules extends ModulesRecord
+  Modules extends ModulesRecord,
 > extends ModuleContainer<Modules> {}
 
 type TestEvents = {
   test: [string];
-}
+};
 
 @injectable()
 class TestModule
@@ -36,7 +28,7 @@ class TestModule
 
 type TestEvents2 = {
   test2: [number];
-}
+};
 
 class TestModule2
   extends ConfigurableModule<{}>
@@ -45,17 +37,6 @@ class TestModule2
   events = new EventEmitter<TestEvents2>();
 }
 
-type X = {
-  test: TypedClass<TestModule>;
-  test2: TypedClass<TestModule2>;
-};
-type Y = FlattenObject<ContainerEvents<X>>;
-type Z = CastToEventsRecord<FlattenedContainerEvents<X>>;
-// const y: Y = {
-//   test: ["asd"],
-//   // test2: [2]
-// }
-
 describe("test event propagation", () => {
   it("should propagate events up", () => {
     expect.assertions(1);
@@ -69,7 +50,7 @@ describe("test event propagation", () => {
 
     container.configure({
       test: {},
-      test2: {}
+      test2: {},
     });
 
     container.create(() => tsyringeContainer.createChildContainer());

package/test/config/ModuleContainer.test.ts

@@ -1,4 +1,3 @@
-/* eslint-disable max-classes-per-file */
 import "reflect-metadata";
 import { container as tsyringeContainer, inject, injectable } from "tsyringe";
 
@@ -9,10 +8,9 @@ import {
 import {
   ModuleContainer,
   ModulesRecord,
-  DependenciesFromModules,
 } from "../../src/config/ModuleContainer";
 import { TypedClass } from "../../src/types";
-import { ChildContainerProvider, DependencyFactory, DependencyRecord } from "../../src";
+import { DependencyFactory } from "../../src";
 
 // module container will accept modules that extend this type
 class BaseTestModule<Config> extends ConfigurableModule<Config> {}
@@ -63,27 +61,12 @@ class OtherTestModule extends BaseTestModule<OtherTestModuleConfig> {
  * Showcases a wrongly typed/defined module as
  * per the TestModuleContainer requirements
  */
-// eslint-disable-next-line max-len
-// eslint-disable-next-line @typescript-eslint/no-extraneous-class, @typescript-eslint/no-unused-vars
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
 class WrongTestModule {}
 
 class TestModuleContainer<
-  Modules extends TestModulesRecord
-> extends ModuleContainer<Modules> {
-  public create(childContainerProvider: ChildContainerProvider) {
-    super.create(childContainerProvider);
-    this.registerDependencyFactories(["TestModule" as any]);
-  }
-}
-
-type inferred = DependenciesFromModules<{
-  TestModule: typeof TestModule;
-  OtherTestModule: typeof OtherTestModule;
-}>;
-
-// const merged2T: merged2 = {
-//   dependencyModule1: ""
-// }
+  Modules extends TestModulesRecord,
+> extends ModuleContainer<Modules> {}
 
 describe("moduleContainer", () => {
   let container: TestModuleContainer<{
@@ -103,7 +86,7 @@ describe("moduleContainer", () => {
     });
   });
 
-  it.only("should resolve dependency factory dependencies correctly", () => {
+  it("should resolve dependency factory dependencies correctly", () => {
     container.configure({
       TestModule: {
         testConfigProperty,
@@ -116,7 +99,9 @@ describe("moduleContainer", () => {
 
     container.create(() => tsyringeContainer.createChildContainer());
 
-    const dm = container.resolve("dependencyModule1");
+    // Unfortunately we still need this so that the dependencies are registered
+    container.resolve("TestModule");
+    const dm = container.resolve("DependencyModule1");
 
     expect(dm.x()).toBe("dependency factory works");
     expect(dm.testModule).toBeDefined();
@@ -150,7 +135,7 @@ describe("moduleContainer", () => {
 
     expect(testModule.config.testConfigProperty).toBe(testConfigProperty);
 
-    const dependency = container.resolve("dependencyModule1");
+    const dependency = container.resolve("DependencyModule1");
     dependency.x();
   });
 
@@ -178,7 +163,7 @@ describe("moduleContainer", () => {
 
     container.create(() => tsyringeContainer.createChildContainer());
 
-    const config = container.resolve("TestModule").config;
+    const { config } = container.resolve("TestModule");
 
     expect(config.testConfigProperty).toBe(3);
     expect(config.testConfigProperty2).toBe(2);

package/test/trees/MerkleTree.test.ts

@@ -1,17 +1,18 @@
 import { beforeEach } from "@jest/globals";
-import { Field, Poseidon } from "o1js";
+import { Field } from "o1js";
 
 import { createMerkleTree, InMemoryMerkleTreeStorage, log } from "../../src";
 
 describe.each([4, 16, 256])("cachedMerkleTree - %s", (height) => {
   class RollupMerkleTree extends createMerkleTree(height) {}
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
   class RollupMerkleTreeWitness extends RollupMerkleTree.WITNESS {}
 
   let store: InMemoryMerkleTreeStorage;
   let tree: RollupMerkleTree;
 
   beforeEach(() => {
-    log.setLevel("DEBUG");
+    log.setLevel("INFO");
 
     store = new InMemoryMerkleTreeStorage();
     tree = new RollupMerkleTree(store);

package/test/tsconfig.json

@@ -1,4 +1,7 @@
 {
-  "extends": "./../tsconfig.json",
-  "include": ["./**/*.ts", "./*.ts", "./../src/**/*.ts"]
+  "extends": "./../../../tsconfig.json",
+  "compilerOptions": {
+    "experimentalDecorators": true
+  },
+  "include": ["./**/*.ts", "./*.ts"]
 }