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

package/test/config/ContainerEvents.test.ts

@@ -0,0 +1,65 @@
+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({
+      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,17 @@
-/* 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,
 } from "../../src/config/ModuleContainer";
 import { TypedClass } from "../../src/types";
+import { DependencyFactory, expectDefined } from "../../src";
+import { injectAlias } from "../../src/config/injectAlias";
 
 // module container will accept modules that extend this type
 class BaseTestModule<Config> extends ConfigurableModule<Config> {}
@@ -14,27 +20,60 @@ type TestModulesRecord = ModulesRecord<TypedClass<BaseTestModule<unknown>>>;
 
 interface TestModuleConfig {
   testConfigProperty: number;
+  testConfigProperty2?: number;
+  testConfigProperty3?: number;
+}
+
+@injectable()
+@injectAlias(["child-alias", "multi-alias"])
+class ChildModule extends BaseTestModule<NoConfig> {
+  public constructor(@inject("TestModule") public readonly testModule: any) {
+    super();
+  }
+
+  x() {
+    return "dependency factory works";
+  }
 }
 
-class TestModule extends BaseTestModule<TestModuleConfig> {}
+@injectAlias(["base-alias", "multi-alias"])
+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
  * 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> {}
+  Modules extends TestModulesRecord,
+> extends ModuleContainer<Modules> {
+  public get dependencyContainer() {
+    return this.container;
+  }
+}
 
 describe("moduleContainer", () => {
   let container: TestModuleContainer<{
@@ -45,21 +84,42 @@ describe("moduleContainer", () => {
 
   beforeEach(() => {
     container = new TestModuleContainer({
-      modules: {
-        TestModule,
-        OtherTestModule,
-        // this module would not be assignable to TestModuleContainer
-        // WrongTestModule,
+      TestModule,
+      OtherTestModule,
+      // this module would not be assignable to TestModuleContainer
+      // WrongTestModule,
+    });
+  });
+
+  it("should resolve dependency factory dependencies correctly", () => {
+    container.configure({
+      TestModule: {
+        testConfigProperty,
+      },
+
+      OtherTestModule: {
+        otherTestConfigProperty: testConfigProperty,
       },
     });
+
+    container.create(() => tsyringeContainer.createChildContainer());
+
+    // 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();
   });
 
   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 +134,80 @@ 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");
+
+    expect(config.testConfigProperty).toBe(3);
+    expect(config.testConfigProperty2).toBe(2);
+    expect(config.testConfigProperty3).toBe(undefined);
+  });
+
+  it("should resolve dependencies correctly via alias", () => {
+    container.configure({
+      TestModule: {
+        testConfigProperty,
+      },
+
+      OtherTestModule: {
+        otherTestConfigProperty: testConfigProperty,
+      },
+    });
+
+    container.create(() => tsyringeContainer.createChildContainer());
+
+    // Unfortunately we still need this so that the dependencies are registered
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+    const m1 = container.resolve("base-alias" as any);
+    const m2 = container.resolve("TestModule");
+
+    expectDefined(m1);
+    // Check if its the same reference
+    expect(m1).toBe(m2);
+
+    const dm1 = container.resolve("child-alias" as any) as ChildModule;
+    const dm2 = container.resolve("DependencyModule1");
+
+    expect(dm1.x()).toBe("dependency factory works");
+    expect(dm1.testModule).toBeDefined();
+    expect(dm1).toBe(dm2);
+
+    const multi =
+      container.dependencyContainer.resolveAll<BaseTestModule<unknown>>(
+        "multi-alias"
+      );
+    expect(multi).toHaveLength(2);
   });
 });

package/test/config/injectAlias.test.ts

@@ -0,0 +1,28 @@
+import "reflect-metadata";
+import { getInjectAliases, injectAlias } from "../../src/config/injectAlias";
+
+@injectAlias(["foo", "bar"])
+class TestClass {}
+
+@injectAlias(["ayy"])
+class TestClass2 extends TestClass {}
+
+describe("injectAlias metadata", () => {
+  it("set and retrieve", () => {
+    expect.assertions(2);
+
+    const aliases = getInjectAliases(TestClass);
+
+    expect(aliases).toHaveLength(2);
+    expect(aliases).toStrictEqual(["foo", "bar"]);
+  });
+
+  it("recursive", () => {
+    expect.assertions(2);
+
+    const aliases = getInjectAliases(TestClass2);
+
+    expect(aliases).toHaveLength(3);
+    expect(aliases).toStrictEqual(["ayy", "foo", "bar"]);
+  });
+});

package/test/trees/LinkedMerkleTree.test.ts

@@ -0,0 +1,124 @@
+import { beforeEach } from "@jest/globals";
+import { Field, Poseidon } from "o1js";
+
+import {
+  createLinkedMerkleTree,
+  InMemoryLinkedLeafStore,
+  InMemoryMerkleTreeStorage,
+  log,
+} from "../../src";
+import { expectDefined } from "../../dist/utils";
+
+describe.each([4, 16, 254])("cachedMerkleTree - %s", (height) => {
+  class LinkedMerkleTree extends createLinkedMerkleTree(height) {}
+
+  let leafStore: InMemoryLinkedLeafStore;
+  let merkleStore: InMemoryMerkleTreeStorage;
+  let tree: LinkedMerkleTree;
+
+  beforeEach(() => {
+    log.setLevel("INFO");
+
+    leafStore = new InMemoryLinkedLeafStore();
+    merkleStore = new InMemoryMerkleTreeStorage();
+    tree = new LinkedMerkleTree(merkleStore, leafStore);
+  });
+
+  it("should have the same root when empty", () => {
+    expect.assertions(2);
+
+    expect(tree.getRoot().toString()).toStrictEqual(
+      LinkedMerkleTree.EMPTY_ROOT.toString()
+    );
+    expectDefined(tree.getLeaf(0n));
+  });
+
+  it("should have a different root when not empty", () => {
+    expect.assertions(1);
+
+    tree.setLeaf(1n, 1n);
+
+    expect(tree.getRoot().toString()).not.toStrictEqual(
+      LinkedMerkleTree.EMPTY_ROOT.toString()
+    );
+  });
+
+  it("should provide correct witnesses", () => {
+    expect.assertions(2);
+
+    tree.setLeaf(1n, 1n);
+    tree.setLeaf(5n, 5n);
+
+    const witness = tree.getReadWitness(5n);
+
+    expect(witness.leaf.value.toString()).toStrictEqual("5");
+    expect(
+      witness.merkleWitness.calculateRoot(witness.leaf.hash()).toString()
+    ).toStrictEqual(tree.getRoot().toString());
+  });
+
+  it("should have invalid witnesses with wrong values", () => {
+    expect.assertions(1);
+
+    tree.setLeaf(1n, 1n);
+    tree.setLeaf(5n, 5n);
+
+    const witness = tree.getReadWitness(5n);
+
+    expect(
+      witness.merkleWitness.calculateRoot(Field(6)).toString()
+    ).not.toStrictEqual(tree.getRoot().toString());
+  });
+
+  it("should have valid witnesses with changed value on the same leafs", () => {
+    expect.assertions(1);
+
+    tree.setLeaf(1n, 1n);
+    tree.setLeaf(5n, 5n);
+
+    const witness = tree.getReadWitness(5n);
+
+    tree.setLeaf(5n, 10n);
+
+    expect(
+      witness.merkleWitness
+        .calculateRoot(
+          Poseidon.hash([Field(10), witness.leaf.path, witness.leaf.nextPath])
+        )
+        .toString()
+    ).toStrictEqual(tree.getRoot().toString());
+  });
+
+  it("should return zeroNode", () => {
+    expect.assertions(4);
+    const MAX_FIELD_VALUE: bigint = Field.ORDER - 1n;
+    const zeroLeaf = tree.getLeaf(0n);
+    expectDefined(zeroLeaf);
+    expect(zeroLeaf.value.toString()).toStrictEqual("0");
+    expect(zeroLeaf.path.toString()).toStrictEqual("0");
+    expect(zeroLeaf.nextPath.toString()).toStrictEqual(
+      MAX_FIELD_VALUE.toString()
+    );
+  });
+});
+
+// Separate describe here since we only want small trees for this test.
+describe("Error check", () => {
+  class LinkedMerkleTree extends createLinkedMerkleTree(4) {}
+  let leafStore: InMemoryLinkedLeafStore;
+  let merkleStore: InMemoryMerkleTreeStorage;
+  let tree: LinkedMerkleTree;
+
+  it("throw for invalid index", () => {
+    log.setLevel("INFO");
+
+    leafStore = new InMemoryLinkedLeafStore();
+    merkleStore = new InMemoryMerkleTreeStorage();
+    tree = new LinkedMerkleTree(merkleStore, leafStore);
+    expect(() => {
+      for (let i = 0; i < 2n ** BigInt(4) + 1n; i++) {
+        tree.setLeaf(BigInt(i), 2n);
+      }
+    }).toThrow("Index greater than maximum leaf number");
+  });
+});

package/test/trees/LinkedMerkleTreeCircuitOps.test.ts

@@ -0,0 +1,147 @@
+import { Field, Provable } from "o1js";
+
+import {
+  InMemoryLinkedLeafStore,
+  InMemoryMerkleTreeStorage,
+  LinkedMerkleTree,
+  LinkedMerkleTreeCircuitOps,
+  LinkedMerkleTreeWitness,
+} from "../../src";
+
+describe("LinkedMerkleTree - Circuit Ops", () => {
+  function setupTree() {
+    const leafStore = new InMemoryLinkedLeafStore();
+    const store = new InMemoryMerkleTreeStorage();
+    return new LinkedMerkleTree(store, leafStore);
+  }
+
+  let tree: LinkedMerkleTree;
+
+  beforeEach(() => {
+    tree = setupTree();
+  });
+
+  it("should correctly verify insert witness", () => {
+    try {
+      const root = tree.getRoot();
+      const insertWitness = tree.setLeaf(5n, 1000n);
+
+      const globalState = LinkedMerkleTreeCircuitOps.applyTreeWrite(
+        root,
+        insertWitness,
+        {
+          path: Field(5),
+          from: Field(0),
+          to: Field(1000),
+        },
+        0
+      );
+
+      expect(globalState.toString()).toStrictEqual(tree.getRoot().toString());
+    } catch (e) {
+      console.error(e);
+      throw e;
+    }
+  });
+
+  it("should correctly verify update witness", () => {
+    try {
+      tree.setLeaf(5n, 1000n);
+      tree.setLeaf(10n, 1500n);
+
+      const root = tree.getRoot();
+
+      const updateWitness = tree.setLeaf(10n, 500n);
+
+      const globalState = LinkedMerkleTreeCircuitOps.applyTreeWrite(
+        root,
+        updateWitness,
+        {
+          path: Field(10),
+          from: Field(1500),
+          to: Field(500),
+        },
+        0
+      );
+
+      expect(globalState.toString()).toStrictEqual(tree.getRoot().toString());
+    } catch (e) {
+      console.error(e);
+      throw e;
+    }
+  });
+
+  it("should not update root when only reading", () => {
+    tree.setLeaf(5n, 1000n);
+    tree.setLeaf(10n, 1500n);
+
+    const root = tree.getRoot();
+
+    const updateWitness = tree.getReadWitness(10n);
+
+    const globalState = LinkedMerkleTreeCircuitOps.applyTreeWrite(
+      root,
+      LinkedMerkleTreeWitness.fromReadWitness(updateWitness),
+      {
+        path: Field(10),
+        from: Field(1500),
+        to: Field(1500),
+      },
+      0
+    );
+
+    expect(globalState.toString()).toStrictEqual(root.toString());
+    expect(globalState.toString()).toStrictEqual(tree.getRoot().toString());
+  });
+
+  it("should noop when used with a dummy witness", () => {
+    tree.setLeaf(5n, 1000n);
+    tree.setLeaf(10n, 1500n);
+
+    const root = tree.getRoot();
+
+    const globalState = LinkedMerkleTreeCircuitOps.applyTreeWrite(
+      root,
+      LinkedMerkleTree.dummyWitness(),
+      {
+        path: Field(0),
+        from: Field(0),
+        to: Field(0),
+      },
+      0
+    );
+
+    expect(globalState.toString()).toStrictEqual(root.toString());
+    expect(globalState.toString()).toStrictEqual(tree.getRoot().toString());
+  });
+
+  it("Circuit size", async () => {
+    const root = tree.getRoot();
+
+    const updateWitness = tree.setLeaf(10n, 500n);
+
+    const cs = await Provable.constraintSystem(() => {
+      const rootWitness = Provable.witness(Field, () => root);
+      const updateWitnessWitness = Provable.witness(
+        LinkedMerkleTreeWitness,
+        () => updateWitness
+      );
+      const treeWrite = {
+        path: Provable.witness(Field, () => 1),
+        from: Provable.witness(Field, () => 1),
+        to: Provable.witness(Field, () => 1),
+      };
+
+      LinkedMerkleTreeCircuitOps.applyTreeWrite(
+        rootWitness,
+        updateWitnessWitness,
+        treeWrite,
+        0
+      );
+    });
+
+    console.log(cs.rows);
+
+    expect(cs.rows).toBeLessThan(2500);
+  });
+});