@proto-kit/common 0.1.1-develop.165 → 0.1.1-develop.1665

package/test/trees/MerkleTree.test.ts

@@ -0,0 +1,220 @@
+import { beforeEach } from "@jest/globals";
+import { Field } from "o1js";
+
+import {
+  createMerkleTree,
+  InMemoryMerkleTreeStorage,
+  log,
+  RollupMerkleTree,
+  range,
+} from "../../src";
+
+describe("batch setLeaf", () => {
+  function generateBatch(
+    size: number,
+    height: number,
+    generator = () => Field.random().toBigInt()
+  ) {
+    const max = 2n ** BigInt(height - 1);
+    return range(0, size).map(() => ({
+      index: generator() % max,
+      leaf: Field.random(),
+    }));
+  }
+
+  function generateBatchAdjacent(size: number, height: number) {
+    let start = 0n;
+    return generateBatch(size, height, () => {
+      start += 1n;
+      return start - 1n;
+    });
+  }
+
+  function captureTime<R>(f: () => R): [number, R] {
+    const start = Date.now();
+    const ret = f();
+    return [Date.now() - start, ret];
+  }
+  const height = 10;
+  const maxIndex = 2n ** BigInt(height - 1) - 1n;
+
+  it.each([
+    [
+      { index: 1n, leaf: Field(5) },
+      { index: maxIndex, leaf: Field(7) },
+    ],
+    [
+      { index: maxIndex, leaf: Field(7) },
+      { index: maxIndex - 1n, leaf: Field(7) },
+      { index: 50n, leaf: Field(7) },
+      { index: 1n, leaf: Field(5) },
+    ],
+    generateBatch(5, height),
+    generateBatch(10, height),
+    generateBatch(50, height),
+    generateBatch(300, height),
+  ])("correctness", (...writes) => {
+    const Tree = createMerkleTree(height);
+    const tree1 = new Tree(new InMemoryMerkleTreeStorage());
+    const tree2 = new Tree(new InMemoryMerkleTreeStorage());
+
+    writes.forEach(({ index, leaf }) => {
+      tree1.setLeaf(index, leaf);
+    });
+
+    tree2.setLeaves(writes);
+
+    expect(tree1.getRoot().toString()).toStrictEqual(
+      tree2.getRoot().toString()
+    );
+  });
+
+  it.each([
+    // This tests the correct retrieval of previously-set siblings (vs. above
+    // where always fetch zero-siblings)
+    [[{ index: 1n, leaf: Field(5) }], [{ index: 4n, leaf: Field(1) }]],
+    [[{ index: 4n, leaf: Field(5) }], [{ index: 1n, leaf: Field(1) }]],
+  ])("correctness - batches", (...writes) => {
+    expect.assertions(writes.length);
+
+    const Tree = createMerkleTree(height);
+    const tree1 = new Tree(new InMemoryMerkleTreeStorage());
+    const tree2 = new Tree(new InMemoryMerkleTreeStorage());
+
+    writes.forEach((writes2) => {
+      writes2.forEach(({ index, leaf }) => {
+        tree1.setLeaf(index, leaf);
+      });
+
+      tree2.setLeaves(writes2);
+
+      expect(tree1.getRoot().toString()).toStrictEqual(
+        tree2.getRoot().toString()
+      );
+    });
+  });
+
+  it.each([
+    ["random", 10, generateBatch],
+    ["random", 100, generateBatch],
+    ["adjacent", 100, generateBatchAdjacent],
+    ["adjacent", 10, generateBatchAdjacent],
+  ])("test speedup: %s (%i leaves)", (label, batchSize, generateFunction) => {
+    const tree1 = new RollupMerkleTree(new InMemoryMerkleTreeStorage());
+    const tree2 = new RollupMerkleTree(new InMemoryMerkleTreeStorage());
+
+    const batch = generateFunction(batchSize, RollupMerkleTree.HEIGHT);
+
+    const slice = batch.slice();
+    const [time1] = captureTime(() => tree1.setLeaves(slice));
+    const [time2] = captureTime(() =>
+      batch.forEach(({ index, leaf }) => tree2.setLeaf(index, leaf))
+    );
+
+    console.log(`Speedup for batch size ${batchSize}, mode ${label}`);
+    console.log(time1);
+    console.log(time2);
+
+    expect(tree1.getRoot().toString()).toStrictEqual(
+      tree2.getRoot().toString()
+    );
+  });
+});
+
+describe.each([4, 16, 256])("cachedMerkleTree - %s", (height) => {
+  class MerkleTree extends createMerkleTree(height) {}
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  class MerkleTreeWitness extends MerkleTree.WITNESS {}
+
+  let store: InMemoryMerkleTreeStorage;
+  let tree: MerkleTree;
+
+  beforeEach(() => {
+    log.setLevel("INFO");
+
+    store = new InMemoryMerkleTreeStorage();
+    tree = new MerkleTree(store);
+  });
+
+  it("should have the same root when empty", () => {
+    expect.assertions(1);
+
+    expect(tree.getRoot().toBigInt()).toStrictEqual(MerkleTree.EMPTY_ROOT);
+  });
+
+  it("should have a different root when not empty", () => {
+    expect.assertions(1);
+
+    tree.setLeaf(1n, Field(1));
+
+    expect(tree.getRoot().toBigInt()).not.toStrictEqual(MerkleTree.EMPTY_ROOT);
+  });
+
+  it("should have the same root after adding and removing item", () => {
+    expect.assertions(1);
+
+    tree.setLeaf(1n, Field(1));
+
+    const root = tree.getRoot();
+
+    tree.setLeaf(5n, Field(5));
+    tree.setLeaf(5n, Field(0));
+
+    expect(tree.getRoot().toBigInt()).toStrictEqual(root.toBigInt());
+  });
+
+  it("should provide correct witnesses", () => {
+    expect.assertions(1);
+
+    tree.setLeaf(1n, Field(1));
+    tree.setLeaf(5n, Field(5));
+
+    const witness = tree.getWitness(5n);
+
+    expect(witness.calculateRoot(Field(5)).toBigInt()).toStrictEqual(
+      tree.getRoot().toBigInt()
+    );
+  });
+
+  it("should have invalid witnesses with wrong values", () => {
+    expect.assertions(1);
+
+    tree.setLeaf(1n, Field(1));
+    tree.setLeaf(5n, Field(5));
+
+    const witness = tree.getWitness(5n);
+
+    expect(witness.calculateRoot(Field(6)).toBigInt()).not.toStrictEqual(
+      tree.getRoot().toBigInt()
+    );
+  });
+
+  it("should have valid witnesses with changed value on the same leafs", () => {
+    expect.assertions(1);
+
+    tree.setLeaf(1n, Field(1));
+    tree.setLeaf(5n, Field(5));
+
+    const witness = tree.getWitness(5n);
+
+    tree.setLeaf(5n, Field(10));
+
+    expect(witness.calculateRoot(Field(10)).toBigInt()).toStrictEqual(
+      tree.getRoot().toBigInt()
+    );
+  });
+
+  it("should throw for invalid index", () => {
+    expect.assertions(2);
+
+    const index = 2n ** BigInt(height) + 1n;
+
+    expect(() => {
+      tree.setLeaf(index, Field(1));
+    }).toThrow("Index greater than maximum leaf number");
+
+    expect(() => {
+      tree.getNode(0, index);
+    }).toThrow("Index greater than maximum leaf number");
+  });
+});

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"]
 }

package/test/zkProgrammable/ZkProgrammable.test.ts

@@ -1,23 +1,17 @@
-/* eslint-disable max-classes-per-file */
 import "reflect-metadata";
-// eslint-disable-next-line @typescript-eslint/no-shadow
 import { jest } from "@jest/globals";
 import { container } from "tsyringe";
-import { Experimental, Field, Struct, Proof } from "snarkyjs";
+import { Field, Struct, Proof, ZkProgram } from "o1js";
 
 import {
-  mockProof,
+  MOCK_PROOF,
   provableMethod,
-} from "../../src/zkProgrammable/provableMethod";
-import {
   AreProofsEnabled,
   CompileArtifact,
-  mockVerificationKey,
-  PlainZkProgram,
+  MOCK_VERIFICATION_KEY,
   ZkProgrammable,
-} from "../../src/zkProgrammable/ZkProgrammable";
-import { ProvableMethodExecutionContext } from "../../src/zkProgrammable/ProvableMethodExecutionContext";
-import { Pickles } from "snarkyjs/dist/node/snarky";
+  ProvableMethodExecutionContext,
+} from "../../src";
 
 const appChainMock: AreProofsEnabled = {
   areProofsEnabled: false,
@@ -37,14 +31,16 @@ class TestPublicOutput extends Struct({
 
 const failErrorMessage = "test failure";
 
+type Balance = Field;
+
 class TestProgrammable extends ZkProgrammable<
   TestPublicInput,
   TestPublicOutput
 > {
-  public appChain: AreProofsEnabled = appChainMock;
+  public areProofsEnabled: AreProofsEnabled = appChainMock;
 
   @provableMethod()
-  public foo(publicInput: TestPublicInput, bar: Field) {
+  public async foo(publicInput: TestPublicInput, bar: Balance) {
     // expose the private input as public output again for testing purposes
     return new TestPublicOutput({
       bar,
@@ -52,7 +48,7 @@ class TestProgrammable extends ZkProgrammable<
   }
 
   @provableMethod()
-  public fail(publicInput: TestPublicInput) {
+  public async fail(publicInput: TestPublicInput) {
     publicInput.foo.assertEquals(1, failErrorMessage);
 
     return new TestPublicOutput({
@@ -61,7 +57,8 @@ class TestProgrammable extends ZkProgrammable<
   }
 
   public zkProgramFactory() {
-    const program = Experimental.ZkProgram({
+    const program = ZkProgram({
+      name: "testprogram",
       publicInput: TestPublicInput,
       publicOutput: TestPublicOutput,
 
@@ -78,43 +75,46 @@ class TestProgrammable extends ZkProgrammable<
       },
     });
 
-    const SelfProof = Experimental.ZkProgram.Proof(program);
+    const SelfProof = ZkProgram.Proof(program);
 
     const methods = {
       foo: program.foo.bind(program),
       fail: program.fail.bind(program),
     };
 
-    return {
-      compile: program.compile.bind(program),
-      verify: program.verify.bind(program),
-      Proof: SelfProof,
-      methods,
-    };
+    return [
+      {
+        name: program.name,
+        compile: program.compile.bind(program),
+        verify: program.verify.bind(program),
+        analyzeMethods: program.analyzeMethods.bind(program),
+        Proof: SelfProof,
+        methods,
+      },
+    ];
   }
 }
 
-class OtherTestProgrammable extends ZkProgrammable {
-  public appChain: AreProofsEnabled = appChainMock;
+class OtherTestProgrammable extends ZkProgrammable<undefined, void> {
+  public areProofsEnabled: AreProofsEnabled = appChainMock;
 
   public constructor(public testProgrammable: TestProgrammable) {
     super();
   }
 
+  proofType = this.testProgrammable.zkProgram[0].Proof;
+
   @provableMethod()
-  public bar(
-    testProgrammableProof: InstanceType<
-      typeof this.testProgrammable.zkProgram.Proof
-    >
-  ) {
+  public async bar(testProgrammableProof: InstanceType<typeof this.proofType>) {
     testProgrammableProof.verify();
   }
 
-  public zkProgramFactory(): PlainZkProgram {
-    const program = Experimental.ZkProgram({
+  public zkProgramFactory() {
+    const program = ZkProgram({
+      name: "testprogram2",
       methods: {
         bar: {
-          privateInputs: [this.testProgrammable.zkProgram.Proof],
+          privateInputs: [this.testProgrammable.zkProgram[0].Proof],
           method: this.bar.bind(this),
         },
       },
@@ -124,47 +124,68 @@ class OtherTestProgrammable extends ZkProgrammable {
       bar: program.bar.bind(program),
     };
 
-    const SelfProof = Experimental.ZkProgram.Proof(program);
+    const SelfProof = ZkProgram.Proof(program);
 
-    return {
-      compile: program.compile.bind(program),
-      verify: program.verify.bind(program),
-      Proof: SelfProof,
-      methods,
-    };
+    return [
+      {
+        name: program.name,
+        compile: program.compile.bind(program),
+        verify: program.verify.bind(program),
+        analyzeMethods: program.analyzeMethods.bind(program),
+        Proof: SelfProof,
+        methods,
+      },
+    ];
   }
 }
 
+const testWithProofs = false;
+
 describe("zkProgrammable", () => {
   let testProgrammable: TestProgrammable;
   let artifact: CompileArtifact;
   let zkProgramFactorySpy: ReturnType<typeof jest.spyOn>;
 
-  describe.each([
+  const testCases: [
+    boolean,
+    {
+      verificationKey: CompileArtifact["verificationKey"];
+      shouldVerifyMockProofs: boolean;
+    },
+  ][] = [
     [
       false,
       {
-        verificationKey: mockVerificationKey,
+        verificationKey: MOCK_VERIFICATION_KEY,
         shouldVerifyMockProofs: true,
       },
     ],
-    [
-      true,
-      {
-        verificationKey:
-          "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",
+  ];
+
+  // We want to disable testing with proofs enabled for the CI and other stuff,
+  // as it is quite expensive. But we should find a better pattern than this
+  if (testWithProofs) {
+    // TODO Migrate to new o1js compile artifact format
+    // testCases.push([
+    //   true,
+    //   {
+    //     verificationKey:
+    // eslint-disable-next-line max-len
+    //       "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",
+    //
+    //     shouldVerifyMockProofs: false,
+    //   },
+    // ]);
+  }
 
-        shouldVerifyMockProofs: false,
-      },
-    ],
-  ])(
+  describe.each(testCases)(
     "areProofsEnabled",
     (areProofsEnabled, { verificationKey, shouldVerifyMockProofs }) => {
       beforeAll(async () => {
         testProgrammable = new TestProgrammable();
-        testProgrammable.appChain.setProofsEnabled(areProofsEnabled);
+        testProgrammable.areProofsEnabled.setProofsEnabled(areProofsEnabled);
         zkProgramFactorySpy = jest.spyOn(testProgrammable, "zkProgramFactory");
-        artifact = await testProgrammable.zkProgram.compile();
+        artifact = await testProgrammable.zkProgram[0].compile();
       }, 500_000);
 
       describe("zkProgramFactory", () => {
@@ -191,8 +212,8 @@ describe("zkProgrammable", () => {
       it("if proofs are disabled, it should successfully verify mock proofs", async () => {
         expect.assertions(1);
 
-        const proof = new testProgrammable.zkProgram.Proof({
-          proof: mockProof,
+        const proof = new testProgrammable.zkProgram[0].Proof({
+          proof: MOCK_PROOF,
 
           publicInput: new TestPublicInput({
             foo: Field(0),
@@ -205,7 +226,7 @@ describe("zkProgrammable", () => {
           maxProofsVerified: 0,
         });
 
-        const verified = await testProgrammable.zkProgram.verify(proof);
+        const verified = await testProgrammable.zkProgram[0].verify(proof);
 
         expect(verified).toBe(shouldVerifyMockProofs);
 
@@ -213,71 +234,71 @@ describe("zkProgrammable", () => {
         // const json = proof.toJSON();
         // expect(json).toBeDefined();
       });
-    }
-  );
 
-  describe("provableMethod", () => {
-    const executionContext = container.resolve<ProvableMethodExecutionContext>(
-      ProvableMethodExecutionContext
-    );
+      describe("provableMethod", () => {
+        const executionContext =
+          container.resolve<ProvableMethodExecutionContext>(
+            ProvableMethodExecutionContext
+          );
 
-    let otherTestProgrammable: OtherTestProgrammable;
+        let otherTestProgrammable: OtherTestProgrammable;
 
-    const testPublicInput = new TestPublicInput({
-      foo: Field(0),
-    });
-
-    describe("zkProgram interoperability", () => {
-      beforeAll(async () => {
-        otherTestProgrammable = new OtherTestProgrammable(testProgrammable);
-        await otherTestProgrammable.zkProgram.compile();
-      }, 500_000);
-
-      it("should successfully pass proof of one zkProgram as input to another zkProgram", async () => {
-        expect.assertions(3);
-
-        // execute foo
-        testProgrammable.foo(testPublicInput, Field(0));
-
-        // prove foo
-        const testProof = await executionContext
-          .current()
-          .result.prove<Proof<TestPublicInput, TestPublicOutput>>();
-        const testProofVerified = await testProgrammable.zkProgram.verify(
-          testProof
-        );
-
-        // execute bar
-        otherTestProgrammable.bar(testProof);
-
-        // proof bar
-        const otherTestProof = await executionContext
-          .current()
-          .result.prove<Proof<undefined, void>>();
-        const otherTestProofVerified =
-          await otherTestProgrammable.zkProgram.verify(otherTestProof);
-
-        expect(testProof.publicOutput.bar.toString()).toBe(
-          testPublicInput.foo.toString()
-        );
+        const testPublicInput = new TestPublicInput({
+          foo: Field(0),
+        });
 
-        expect(testProofVerified).toBe(true);
-        expect(otherTestProofVerified).toBe(true);
-      }, 500_000);
-    });
+        describe("zkProgram interoperability", () => {
+          beforeAll(async () => {
+            otherTestProgrammable = new OtherTestProgrammable(testProgrammable);
+            await otherTestProgrammable.zkProgram[0].compile();
+          }, 500_000);
+
+          it("should successfully pass proof of one zkProgram as input to another zkProgram", async () => {
+            expect.assertions(3);
+
+            // execute foo
+            await testProgrammable.foo(testPublicInput, Field(0));
+
+            // prove foo
+            const testProof = await executionContext
+              .current()
+              .result.prove<Proof<TestPublicInput, TestPublicOutput>>();
+            const testProofVerified =
+              await testProgrammable.zkProgram[0].verify(testProof);
+
+            // execute bar
+            await otherTestProgrammable.bar(testProof);
+
+            // proof bar
+            const otherTestProof = await executionContext
+              .current()
+              .result.prove<Proof<undefined, void>>();
+            const otherTestProofVerified =
+              await otherTestProgrammable.zkProgram[0].verify(otherTestProof);
+
+            expect(testProof.publicOutput.bar.toString()).toBe(
+              testPublicInput.foo.toString()
+            );
+
+            expect(testProofVerified).toBe(true);
+            expect(otherTestProofVerified).toBe(true);
+          }, 500_000);
+        });
 
-    describe("failed method execution", () => {
-      it("if the method fails, it should fail to execute and prove", async () => {
-        expect.assertions(2);
+        describe("failed method execution", () => {
+          it("if the method fails, it should fail to execute and prove", async () => {
+            expect.assertions(2);
 
-        expect(() => {
-          testProgrammable.fail(testPublicInput);
-        }).toThrow(failErrorMessage);
+            await expect(
+              testProgrammable.fail(testPublicInput)
+            ).rejects.toThrow(failErrorMessage);
 
-        await expect(async () => {
-          await executionContext.current().result.prove();
-        }).rejects.toThrow(failErrorMessage);
+            await expect(async () => {
+              await executionContext.current().result.prove();
+            }).rejects.toThrow(failErrorMessage);
+          });
+        });
       });
-    });
-  });
+    }
+  );
 });

package/tsconfig.json

@@ -3,6 +3,6 @@
   "compilerOptions": {
     "outDir": "./dist"
   },
-  "include": ["./src/index.ts", "./src/**/*.test.ts"],
+  "include": ["./src/**/*.ts", "./src/*.ts"],
   "exclude": ["./dist/**/*.ts"]
 }

package/dist/Constants.d.ts

@@ -1,4 +0,0 @@
-export declare const constants: {
-    stateTransitionProverBatchSize: number;
-};
-//# sourceMappingURL=Constants.d.ts.map

package/dist/Constants.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Constants.d.ts","sourceRoot":"","sources":["../src/Constants.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,SAAS;;CAErB,CAAC"}

package/dist/Constants.js

@@ -1,3 +0,0 @@
-export const constants = {
-    stateTransitionProverBatchSize: 8,
-};

package/dist/config/ConfigurationAggregator.d.ts

@@ -1,10 +0,0 @@
-import { ComponentConfig, Components, RemoveUndefinedKeys, UninitializedComponentConfig } from "./types";
-/**
- * In this context, a "Component" is just a way of generalizing Modules,
- * because they don't have to be modules, they can be any configurable unit
- */
-export declare abstract class ConfigurationAggregator<Comps extends Components> {
-    protected applyConfig(modules: Comps, currentConfig: UninitializedComponentConfig<ComponentConfig<Comps>>, config: RemoveUndefinedKeys<ComponentConfig<Comps>>): ComponentConfig<Comps>;
-    abstract configure(config: RemoveUndefinedKeys<ComponentConfig<Comps>>): void;
-}
-//# sourceMappingURL=ConfigurationAggregator.d.ts.map

package/dist/config/ConfigurationAggregator.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ConfigurationAggregator.d.ts","sourceRoot":"","sources":["../../src/config/ConfigurationAggregator.ts"],"names":[],"mappings":"AAGA,OAAO,EACL,eAAe,EACf,UAAU,EACV,mBAAmB,EACnB,4BAA4B,EAC7B,MAAM,SAAS,CAAC;AAEjB;;;GAGG;AACH,8BAAsB,uBAAuB,CAAC,KAAK,SAAS,UAAU;IACpE,SAAS,CAAC,WAAW,CACnB,OAAO,EAAE,KAAK,EACd,aAAa,EAAE,4BAA4B,CAAC,eAAe,CAAC,KAAK,CAAC,CAAC,EACnE,MAAM,EAAE,mBAAmB,CAAC,eAAe,CAAC,KAAK,CAAC,CAAC,GAClD,eAAe,CAAC,KAAK,CAAC;aAgCT,SAAS,CACvB,MAAM,EAAE,mBAAmB,CAAC,eAAe,CAAC,KAAK,CAAC,CAAC,GAClD,IAAI;CACR"}

package/dist/config/ConfigurationAggregator.js

@@ -1,35 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any,guard-for-in,@typescript-eslint/no-unsafe-member-access,max-len,@typescript-eslint/no-unsafe-assignment,@typescript-eslint/consistent-type-assertions */
-import merge from "lodash/merge";
-/**
- * In this context, a "Component" is just a way of generalizing Modules,
- * because they don't have to be modules, they can be any configurable unit
- */
-export class ConfigurationAggregator {
-    applyConfig(modules, currentConfig, config) {
-        const nextConfig = {};
-        for (const key in config) {
-            // Set config to module
-            if (currentConfig[key] === undefined) {
-                // Initialize config with merge between config and defaultConfig
-                // eslint-disable-next-line prefer-destructuring,putout/putout
-                const defaultConfig = modules[key].defaultConfig;
-                const newConfig = config[key];
-                for (const configKey in newConfig) {
-                    defaultConfig[configKey] = newConfig[configKey];
-                }
-                // The result of that is always a valid Required<Config> since FlipOptional<Config> requires the exact opposite of Config
-                modules[key].config = defaultConfig;
-                nextConfig[key] = defaultConfig;
-            }
-            else {
-                // Append/overwrite to existing config
-                const newConfig = config[key];
-                const moduleConfig = currentConfig[key];
-                merge(moduleConfig, newConfig);
-                modules[key].config = moduleConfig;
-                nextConfig[key] = moduleConfig;
-            }
-        }
-        return nextConfig;
-    }
-}