@proto-kit/common 0.1.1-develop.340 → 0.1.1-develop.456

package/src/trees/RollupMerkleTree.ts

@@ -0,0 +1,354 @@
+/* eslint-disable id-length */
+/* eslint-disable line-comment-position */
+/* eslint-disable no-inline-comments */
+/* eslint-disable @typescript-eslint/no-magic-numbers */
+/* eslint-disable @typescript-eslint/method-signature-style */
+import { Bool, Field, Poseidon, Provable, Struct } from "o1js";
+
+import { range } from "../utils";
+import { TypedClass } from "../types";
+
+import { MerkleTreeStore } from "./MerkleTreeStore";
+import { InMemoryMerkleTreeStorage } from "./InMemoryMerkleTreeStorage";
+
+class StructTemplate extends Struct({
+  path: Provable.Array(Field, 0),
+  isLeft: Provable.Array(Bool, 0),
+}) {}
+
+export interface AbstractMerkleWitness extends StructTemplate {
+  height(): number;
+
+  /**
+   * Calculates a root depending on the leaf value.
+   * @param leaf Value of the leaf node that belongs to this Witness.
+   * @returns The calculated root.
+   */
+  calculateRoot(hash: Field): Field;
+
+  /**
+   * Calculates the index of the leaf node that belongs to this Witness.
+   * @returns Index of the leaf.
+   */
+  calculateIndex(): Field;
+
+  checkMembership(root: Field, key: Field, value: Field): Bool;
+
+  checkMembershipGetRoots(
+    root: Field,
+    key: Field,
+    value: Field
+  ): [Bool, Field, Field];
+
+  toShortenedEntries(): string[];
+}
+
+export interface AbstractMerkleTree {
+  store: MerkleTreeStore;
+  readonly leafCount: bigint;
+
+  assertIndexRange(index: bigint): void;
+
+  /**
+   * Returns a node which lives at a given index and level.
+   * @param level Level of the node.
+   * @param index Index of the node.
+   * @returns The data of the node.
+   */
+  getNode(level: number, index: bigint): Field;
+
+  /**
+   * 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 index Position of the leaf node.
+   * @param leaf New value.
+   */
+  setLeaf(index: bigint, leaf: Field): void;
+
+  /**
+   * Returns the witness (also known as
+   * [Merkle Proof or Merkle Witness](https://computersciencewiki.org/index.php/Merkle_proof))
+   * for the leaf at the given index.
+   * @param index Position of the leaf node.
+   * @returns The witness that belongs to the leaf.
+   */
+  getWitness(index: bigint): AbstractMerkleWitness;
+
+  /**
+   * Fills all leaves of the tree.
+   * @param leaves Values to fill the leaves with.
+   */
+  fill(leaves: Field[]): void;
+}
+
+export interface AbstractMerkleTreeClass {
+  new (...args: any[]): AbstractMerkleTree;
+
+  WITNESS: TypedClass<AbstractMerkleWitness> & typeof StructTemplate;
+
+  HEIGHT: number;
+
+  EMPTY_ROOT: bigint;
+
+  get leafCount(): bigint;
+}
+
+/**
+ * A [Merkle Tree](https://en.wikipedia.org/wiki/Merkle_tree) is a binary tree in
+ * which every leaf is the cryptography hash of a piece of data,
+ * and every node is the hash of the concatenation of its two child nodes.
+ *
+ * A Merkle Tree allows developers to easily and securely verify
+ * the integrity of large amounts of data.
+ *
+ * Take a look at our [documentation](https://docs.minaprotocol.com/en/zkapps)
+ * on how to use Merkle Trees in combination with zkApps and
+ * zero knowledge programming!
+ *
+ * Levels are indexed from leaves (level 0) to root (level N - 1).
+ *
+ * This function takes a height as argument and returns a class
+ * that implements a merkletree with that specified height.
+ *
+ * It also holds the Witness class under tree.WITNESS
+ */
+export function createMerkleTree(height: number): AbstractMerkleTreeClass {
+  /**
+   * The {@link BaseMerkleWitness} class defines a circuit-compatible base class
+   * for [Merkle Witness'](https://computersciencewiki.org/index.php/Merkle_proof).
+   */
+  class RollupMerkleWitness
+    extends Struct({
+      path: Provable.Array(Field, height - 1),
+      isLeft: Provable.Array(Bool, height - 1),
+    })
+    implements AbstractMerkleWitness
+  {
+    public static height = height;
+
+    public height(): number {
+      return RollupMerkleWitness.height;
+    }
+
+    /**
+     * Calculates a root depending on the leaf value.
+     * @param leaf Value of the leaf node that belongs to this Witness.
+     * @returns The calculated root.
+     */
+    public calculateRoot(hash: Field): Field {
+      const n = this.height();
+
+      for (let index = 1; index < n; ++index) {
+        const isLeft = this.isLeft[index - 1];
+        // eslint-disable-next-line @typescript-eslint/no-use-before-define
+        const [left, right] = maybeSwap(isLeft, hash, this.path[index - 1]);
+        hash = Poseidon.hash([left, right]);
+      }
+
+      return hash;
+    }
+
+    /**
+     * Calculates the index of the leaf node that belongs to this Witness.
+     * @returns Index of the leaf.
+     */
+    public calculateIndex(): Field {
+      let powerOfTwo = Field(1);
+      let index = Field(0);
+      const n = this.height();
+
+      // eslint-disable-next-line no-underscore-dangle
+      for (let index_ = 1; index_ < n; ++index_) {
+        index = Provable.if(
+          this.isLeft[index_ - 1],
+          index,
+          index.add(powerOfTwo)
+        );
+        powerOfTwo = powerOfTwo.mul(2);
+      }
+
+      return index;
+    }
+
+    public checkMembership(root: Field, key: Field, value: Field): Bool {
+      const calculatedRoot = this.calculateRoot(value);
+      const calculatedKey = this.calculateIndex();
+      // We don't have to range-check the key, because if it would be greater
+      // than leafCount, it would not match the computedKey
+      key.assertEquals(calculatedKey, "Keys of MerkleWitness does not match");
+      return root.equals(calculatedRoot);
+    }
+
+    public checkMembershipGetRoots(
+      root: Field,
+      key: Field,
+      value: Field
+    ): [Bool, Field, Field] {
+      const calculatedRoot = this.calculateRoot(value);
+      const calculatedKey = this.calculateIndex();
+      key.assertEquals(calculatedKey, "Keys of MerkleWitness does not match");
+      return [root.equals(calculatedRoot), root, calculatedRoot];
+    }
+
+    public toShortenedEntries() {
+      return range(0, 5)
+        .concat(range(this.height() - 4, this.height()))
+        .map((index) =>
+          [
+            this.path[index].toString(),
+            this.isLeft[index].toString(),
+          ].toString()
+        );
+    }
+  }
+
+  return class AbstractRollupMerkleTree implements AbstractMerkleTree {
+    public static HEIGHT = height;
+
+    public static EMPTY_ROOT = new AbstractRollupMerkleTree(
+      new InMemoryMerkleTreeStorage()
+    )
+      .getRoot()
+      .toBigInt();
+
+    public static get leafCount(): bigint {
+      return 2n ** BigInt(AbstractRollupMerkleTree.HEIGHT - 1);
+    }
+
+    public static WITNESS = RollupMerkleWitness;
+
+    // private in interface
+    readonly zeroes: bigint[];
+
+    readonly store: MerkleTreeStore;
+
+    public constructor(store: MerkleTreeStore) {
+      this.store = store;
+      this.zeroes = [0n];
+      for (let index = 1; index < AbstractRollupMerkleTree.HEIGHT; index += 1) {
+        const previousLevel = Field(this.zeroes[index - 1]);
+        this.zeroes.push(
+          Poseidon.hash([previousLevel, previousLevel]).toBigInt()
+        );
+      }
+    }
+
+    public assertIndexRange(index: bigint) {
+      if (index > this.leafCount) {
+        throw new Error("Index greater than maximum leaf number");
+      }
+    }
+
+    /**
+     * Returns a node which lives at a given index and level.
+     * @param level Level of the node.
+     * @param index Index of the node.
+     * @returns The data of the node.
+     */
+    public getNode(level: number, index: bigint): Field {
+      this.assertIndexRange(index);
+      return Field(this.store.getNode(index, level) ?? this.zeroes[level]);
+    }
+
+    /**
+     * Returns the root of the [Merkle Tree](https://en.wikipedia.org/wiki/Merkle_tree).
+     * @returns The root of the Merkle Tree.
+     */
+    public getRoot(): Field {
+      return this.getNode(AbstractRollupMerkleTree.HEIGHT - 1, 0n);
+    }
+
+    // private in interface
+    private setNode(level: number, index: bigint, value: Field) {
+      this.store.setNode(index, level, value.toBigInt());
+    }
+
+    /**
+     * Sets the value of a leaf node at a given index to a given value.
+     * @param index Position of the leaf node.
+     * @param leaf New value.
+     */
+    public setLeaf(index: bigint, leaf: Field) {
+      this.assertIndexRange(index);
+
+      this.setNode(0, index, leaf);
+      let currentIndex = index;
+      for (let level = 1; level < AbstractRollupMerkleTree.HEIGHT; level += 1) {
+        currentIndex /= 2n;
+
+        const left = this.getNode(level - 1, currentIndex * 2n);
+        const right = this.getNode(level - 1, currentIndex * 2n + 1n);
+
+        this.setNode(level, currentIndex, Poseidon.hash([left, right]));
+      }
+    }
+
+    /**
+     * Returns the witness (also known as
+     * [Merkle Proof or Merkle Witness](https://computersciencewiki.org/index.php/Merkle_proof))
+     * for the leaf at the given index.
+     * @param index Position of the leaf node.
+     * @returns The witness that belongs to the leaf.
+     */
+    public getWitness(index: bigint): RollupMerkleWitness {
+      this.assertIndexRange(index);
+
+      const path = [];
+      const isLefts = [];
+      for (
+        let level = 0;
+        level < AbstractRollupMerkleTree.HEIGHT - 1;
+        level += 1
+      ) {
+        const isLeft = index % 2n === 0n;
+        const sibling = this.getNode(level, isLeft ? index + 1n : index - 1n);
+        isLefts.push(Bool(isLeft));
+        path.push(sibling);
+        index /= 2n;
+      }
+      return new RollupMerkleWitness({
+        isLeft: isLefts,
+        path,
+      });
+    }
+
+    // eslint-disable-next-line no-warning-comments, max-len
+    // TODO: should this take an optional offset? should it fail if the array is too long?
+    /**
+     * Fills all leaves of the tree.
+     * @param leaves Values to fill the leaves with.
+     */
+    public fill(leaves: Field[]) {
+      leaves.forEach((value, index) => {
+        this.setLeaf(BigInt(index), value);
+      });
+    }
+
+    /**
+     * Returns the amount of leaf nodes.
+     * @returns Amount of leaf nodes.
+     */
+    public get leafCount(): bigint {
+      return AbstractRollupMerkleTree.leafCount;
+    }
+  };
+}
+
+export class RollupMerkleTree extends createMerkleTree(256) {}
+export class RollupMerkleTreeWitness extends RollupMerkleTree.WITNESS {}
+
+/**
+ * More efficient version of `maybeSwapBad` which
+ * reuses an intermediate variable
+ */
+function maybeSwap(b: Bool, x: Field, y: Field): [Field, Field] {
+  const m = b.toField().mul(x.sub(y)); // b*(x - y)
+  const x1 = y.add(m); // y + b*(x - y)
+  const y2 = x.sub(m); // x - b*(x - y) = x + b*(y - x)
+  return [x1, y2];
+}

package/src/trees/VirtualMerkleTreeStore.ts

@@ -0,0 +1,21 @@
+import { MerkleTreeStore } from "./MerkleTreeStore";
+import { InMemoryMerkleTreeStorage } from "./InMemoryMerkleTreeStorage";
+
+/**
+ * A MemoryMerkleTreeStore that, if falls back to a parent store if it
+ * has no data
+ */
+export class VirtualMerkleTreeStore extends InMemoryMerkleTreeStorage {
+  public constructor(private readonly parent: MerkleTreeStore) {
+    super()
+  }
+
+  public getNode(key: bigint, level: number): bigint | undefined {
+    return super.getNode(key, level) ?? this.parent.getNode(key, level);
+  }
+
+  public setNode(key: bigint, level: number, value: bigint): void {
+    super.setNode(key, level, value);
+  }
+
+}

package/src/types.ts

@@ -17,3 +17,15 @@ export type StringKeyOf<Target extends object> = Extract<keyof Target, string> &
 export type ArrayElement<ArrayType extends readonly unknown[]> =
   // eslint-disable-next-line putout/putout
   ArrayType extends readonly (infer ElementType)[] ? ElementType : never;
+
+/**
+ * Transforms X | Y => X & Y
+ */
+export type UnionToIntersection<Union> = (
+  Union extends any ? (x: Union) => void : never
+) extends (x: infer Intersection) => void
+  ? Intersection
+  : never;
+
+export type MergeObjects<Input extends Record<string, unknown>> =
+  UnionToIntersection<Input[keyof Input]>;

package/src/zkProgrammable/ZkProgrammable.ts

@@ -1,7 +1,7 @@
 import { Experimental, FlexibleProvablePure, Proof } from "o1js";
 import { Memoize } from "typescript-memoize";
 
-import { mockProof } from "./provableMethod";
+import { MOCK_PROOF } from "./provableMethod";
 
 const errors = {
   appChainNotSet: (name: string) =>
@@ -67,11 +67,12 @@ export function verifyToMockable<PublicInput, PublicOutput>(
       return verified;
     }
 
-    return proof.proof === mockProof;
+    return proof.proof === MOCK_PROOF;
   };
 }
 
-export const mockVerificationKey = "mock-verification-key";
+export const MOCK_VERIFICATION_KEY = "mock-verification-key";
+
 export function compileToMockable(
   compile: Compile,
   { areProofsEnabled }: AreProofsEnabled
@@ -82,7 +83,7 @@ export function compileToMockable(
     }
 
     return {
-      verificationKey: mockVerificationKey,
+      verificationKey: MOCK_VERIFICATION_KEY,
     };
   };
 }

package/src/zkProgrammable/provableMethod.ts

@@ -11,7 +11,7 @@ export type ArgumentTypes = O1JSPrimitive[] | Proof<unknown, unknown>[];
 // eslint-disable-next-line etc/prefer-interface
 export type DecoratedMethod = (...args: ArgumentTypes) => unknown;
 
-export const mockProof = "mock-proof";
+export const MOCK_PROOF = "mock-proof";
 
 export function toProver(
   methodName: string,
@@ -31,7 +31,7 @@ export function toProver(
     const publicOutput = Reflect.apply(simulatedMethod, this, args);
 
     return new this.zkProgram.Proof({
-      proof: mockProof,
+      proof: MOCK_PROOF,
 
       // eslint-disable-next-line no-warning-comments
       // TODO: provide undefined if public input is not used

package/test/config/ContainerEvents.test.ts

@@ -0,0 +1,86 @@
+import "reflect-metadata";
+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
+> extends ModuleContainer<Modules> {}
+
+interface TestEvents extends EventsRecord {
+  test: [string];
+}
+
+@injectable()
+class TestModule
+  extends ConfigurableModule<{}>
+  implements BaseModuleInstanceType, EventEmittingComponent<TestEvents>
+{
+  events = new EventEmitter<TestEvents>();
+}
+
+interface TestEvents2 extends EventsRecord {
+  test2: [number];
+}
+
+class TestModule2
+  extends ConfigurableModule<{}>
+  implements BaseModuleInstanceType, EventEmittingComponent<TestEvents2>
+{
+  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);
+
+    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);
+  });
+});

package/test/config/ModuleContainer.test.ts

@@ -1,11 +1,18 @@
 /* eslint-disable max-classes-per-file */
-import { ConfigurableModule } from "../../src/config/ConfigurableModule";
+import "reflect-metadata";
+import { container as tsyringeContainer, inject, injectable } from "tsyringe";
+
+import {
+  ConfigurableModule,
+  NoConfig,
+} from "../../src/config/ConfigurableModule";
 import {
-  ModuleContainerErrors,
   ModuleContainer,
   ModulesRecord,
+  DependenciesFromModules,
 } from "../../src/config/ModuleContainer";
 import { TypedClass } from "../../src/types";
+import { ChildContainerProvider, DependencyFactory, DependencyRecord } from "../../src";
 
 // module container will accept modules that extend this type
 class BaseTestModule<Config> extends ConfigurableModule<Config> {}
@@ -14,15 +21,43 @@ type TestModulesRecord = ModulesRecord<TypedClass<BaseTestModule<unknown>>>;
 
 interface TestModuleConfig {
   testConfigProperty: number;
+  testConfigProperty2?: number;
+  testConfigProperty3?: number;
+}
+
+@injectable()
+class ChildModule extends BaseTestModule<NoConfig> {
+  public constructor(@inject("TestModule") public readonly testModule: any) {
+    super();
+  }
+
+  x() {
+    return "dependency factory works";
+  }
 }
 
-class TestModule extends BaseTestModule<TestModuleConfig> {}
+class TestModule
+  extends BaseTestModule<TestModuleConfig>
+  implements DependencyFactory
+{
+  public dependencies() {
+    return {
+      dependencyModule1: {
+        useClass: ChildModule,
+      },
+    };
+  }
+}
 
 interface OtherTestModuleConfig {
   otherTestConfigProperty: number;
 }
 
-class OtherTestModule extends BaseTestModule<OtherTestModuleConfig> {}
+class OtherTestModule extends BaseTestModule<OtherTestModuleConfig> {
+  public x() {
+    return "";
+  }
+}
 
 /**
  * Showcases a wrongly typed/defined module as
@@ -34,7 +69,21 @@ class WrongTestModule {}
 
 class TestModuleContainer<
   Modules extends TestModulesRecord
-> extends ModuleContainer<Modules> {}
+> 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: ""
+// }
 
 describe("moduleContainer", () => {
   let container: TestModuleContainer<{
@@ -54,12 +103,33 @@ describe("moduleContainer", () => {
     });
   });
 
+  it.only("should resolve dependency factory dependencies correctly", () => {
+    container.configure({
+      TestModule: {
+        testConfigProperty,
+      },
+
+      OtherTestModule: {
+        otherTestConfigProperty: testConfigProperty,
+      },
+    });
+
+    container.create(() => tsyringeContainer.createChildContainer());
+
+    const dm = container.resolve("dependencyModule1");
+
+    expect(dm.x()).toBe("dependency factory works");
+    expect(dm.testModule).toBeDefined();
+  });
+
   it("should throw on resolution, if config was not provided", () => {
     expect.assertions(1);
 
+    container.create(() => tsyringeContainer.createChildContainer());
+
     expect(() => {
       container.resolve("TestModule");
-    }).toThrow(ModuleContainerErrors.configNotSetInContainer("TestModule"));
+    }).toThrow();
   });
 
   it("should resolve the registered module with the provided config", () => {
@@ -74,9 +144,44 @@ describe("moduleContainer", () => {
         otherTestConfigProperty: testConfigProperty,
       },
     });
+    container.create(() => tsyringeContainer.createChildContainer());
 
     const testModule = container.resolve("TestModule");
 
     expect(testModule.config.testConfigProperty).toBe(testConfigProperty);
+
+    const dependency = container.resolve("dependencyModule1");
+    dependency.x();
+  });
+
+  it("should stack configurations correctly", () => {
+    container.configure({
+      TestModule: {
+        testConfigProperty: 1,
+      },
+      OtherTestModule: {
+        otherTestConfigProperty: 4,
+      },
+    });
+
+    container.configurePartial({
+      TestModule: {
+        testConfigProperty2: 2,
+      },
+    });
+
+    container.configurePartial({
+      TestModule: {
+        testConfigProperty: 3,
+      },
+    });
+
+    container.create(() => tsyringeContainer.createChildContainer());
+
+    const config = container.resolve("TestModule").config;
+
+    expect(config.testConfigProperty).toBe(3);
+    expect(config.testConfigProperty2).toBe(2);
+    expect(config.testConfigProperty3).toBe(undefined);
   });
 });