@proto-kit/module 0.1.1-develop.161 → 0.1.1-develop.163

package/dist/method/assert.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"assert.d.ts","sourceRoot":"","sources":["../../src/method/assert.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAY,MAAM,UAAU,CAAC;AAM1C;;;;;;;;GAQG;AACH,wBAAgB,MAAM,CAAC,SAAS,EAAE,IAAI,EAAE,OAAO,CAAC,EAAE,MAAM,QAYvD"}
+{"version":3,"file":"assert.d.ts","sourceRoot":"","sources":["../../src/method/assert.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAY,MAAM,UAAU,CAAC;AAM1C;;;;;;;;GAQG;AACH,wBAAgB,MAAM,CAAC,SAAS,EAAE,IAAI,EAAE,OAAO,CAAC,EAAE,MAAM,QAWvD"}

package/dist/method/assert.js

@@ -15,10 +15,9 @@ export function assert(condition, message) {
     const executionContext = container.resolve(RuntimeMethodExecutionContext);
     const previousStatus = executionContext.current().result.status;
     const status = Provable.if(previousStatus, Bool, condition, previousStatus);
-    if (!status.toBoolean()) {
+    if (!condition.toBoolean()) {
         log.debug("Assertion failed: ", message);
+        executionContext.setStatusMessage(message);
     }
-    // const status = previousStatus.and(condition);
     executionContext.setStatus(status);
-    executionContext.setStatusMessage(message);
 }

package/package.json

@@ -2,7 +2,7 @@
   "name": "@proto-kit/module",
   "license": "MIT",
   "private": false,
-  "version": "0.1.1-develop.161+923a146",
+  "version": "0.1.1-develop.163+1656fd6",
   "type": "module",
   "scripts": {
     "build": "tsc -p tsconfig.json",
@@ -17,8 +17,8 @@
     "access": "public"
   },
   "dependencies": {
-    "@proto-kit/common": "0.1.1-develop.161+923a146",
-    "@proto-kit/protocol": "0.1.1-develop.161+923a146",
+    "@proto-kit/common": "0.1.1-develop.163+1656fd6",
+    "@proto-kit/protocol": "0.1.1-develop.163+1656fd6",
     "lodash": "^4.17.21",
     "loglevel": "^1.8.1",
     "reflect-metadata": "^0.1.13",
@@ -32,5 +32,5 @@
     "snarkyjs": "0.11.0",
     "tsyringe": "^4.7.0"
   },
-  "gitHead": "923a1466aac4dd2e2d2206845eadcc6c0f413849"
+  "gitHead": "1656fd6c13ef14f1bea45cd2629a569f1da02236"
 }

package/src/method/assert.ts

@@ -18,11 +18,10 @@ export function assert(condition: Bool, message?: string) {
   const previousStatus = executionContext.current().result.status;
   const status = Provable.if(previousStatus, Bool, condition, previousStatus);
 
-  if (!status.toBoolean()) {
+  if (!condition.toBoolean()) {
     log.debug("Assertion failed: ", message);
+    executionContext.setStatusMessage(message);
   }
 
-  // const status = previousStatus.and(condition);
   executionContext.setStatus(status);
-  executionContext.setStatusMessage(message);
 }

package/test/state/MerkleTree.test.ts

@@ -0,0 +1,95 @@
+import {
+  CachedMerkleTreeStore,
+  InMemoryMerkleTreeStorage,
+  RollupMerkleTree,
+} from "@proto-kit/protocol";
+import { MockAsyncMerkleTreeStore } from "./MockAsyncMerkleStore";
+import { beforeEach } from "@jest/globals";
+import { Field, Poseidon } from "snarkyjs";
+import { log } from "@proto-kit/common";
+
+describe("cachedMerkleTree", () => {
+  let store: MockAsyncMerkleTreeStore;
+  let syncStore: InMemoryMerkleTreeStorage;
+  let tree: RollupMerkleTree;
+
+  let cached: CachedMerkleTreeStore;
+  let cachedTree: RollupMerkleTree;
+
+  beforeEach(async () => {
+    log.setLevel("DEBUG");
+
+    store = new MockAsyncMerkleTreeStore();
+    syncStore = store.store;
+    tree = new RollupMerkleTree(syncStore);
+
+    tree.setLeaf(1n, Field(10));
+    tree.setLeaf(3n, Field(30));
+    tree.setLeaf(5n, Field(50));
+
+    cached = new CachedMerkleTreeStore(store);
+    await cached.preloadKey(1n);
+    await cached.preloadKey(3n);
+    await cached.preloadKey(5n);
+    cachedTree = new RollupMerkleTree(cached);
+  });
+
+  it("should have the same root", async () => {
+    expect(cached.getNode(1n, 0)).toBe(10n);
+    expect(cached.getNode(3n, 0)).toBe(30n);
+    expect(cached.getNode(5n, 0)).toBe(50n);
+    expect(syncStore.getNode(5n, 0)).toBe(50n);
+
+    expect(cached.getNode(0n, 1)).toBe(
+      Poseidon.hash([Field(0), Field(10)]).toBigInt()
+    );
+
+    expect(cached.getNode(0n, 254)).toBe(await store.getNode(0n, 254));
+    expect(cached.getNode(0n, 254)).toBe(syncStore.getNode(0n, 254));
+
+    expect(cachedTree.getRoot().toBigInt()).toBe(tree.getRoot().toBigInt());
+  });
+
+  it("should load the correct root when only loading a subset of keys", async () => {
+    await cached.preloadKey(3n);
+
+    const correctRoot = tree.getRoot();
+    expect(cachedTree.getRoot().toBigInt()).toBe(correctRoot.toBigInt());
+  });
+
+  it("should generate correct witnesses when only loading a subset of keys", async () => {
+    await cached.preloadKey(5n);
+
+    const correctRoot = tree.getRoot();
+    const witness = tree.getWitness(5n);
+    expect(witness.calculateRoot(Field(50)).toBigInt()).toBe(
+      correctRoot.toBigInt()
+    );
+  });
+
+  it("should generate correct witnesses after merging", async () => {
+    expect(cachedTree.getRoot().toBigInt()).toBe(tree.getRoot().toBigInt());
+
+    await cached.preloadKey(5n);
+    cachedTree.setLeaf(5n, Field(100));
+
+    const correctRoot = cachedTree.getRoot();
+
+    await cached.mergeIntoParent();
+
+    const cached2 = new CachedMerkleTreeStore(store);
+    await cached2.preloadKey(1n);
+    await cached2.preloadKey(3n);
+    await cached2.preloadKey(5n);
+    expect(cached2.getNode(1n, 0)).toBe(10n);
+    expect(cached2.getNode(3n, 0)).toBe(30n);
+    expect(cached2.getNode(5n, 0)).toBe(100n);
+    const tree2 = new RollupMerkleTree(cached2);
+
+    const witness = tree2.getWitness(3n);
+
+    expect(witness.calculateRoot(Field(30)).toBigInt()).toBe(
+      correctRoot.toBigInt()
+    );
+  });
+});

package/test/state/MockAsyncMerkleStore.ts

@@ -0,0 +1,28 @@
+import { AsyncMerkleTreeStore, InMemoryMerkleTreeStorage, noop } from "@proto-kit/protocol";
+
+export class MockAsyncMerkleTreeStore implements AsyncMerkleTreeStore {
+  public readonly store = new InMemoryMerkleTreeStorage();
+
+  public commit(): void {
+    noop();
+  }
+
+  public openTransaction(): void {
+    noop();
+  }
+
+  public async getNode(
+    key: bigint,
+    level: number
+  ): Promise<bigint | undefined> {
+    return this.store.getNode(key, level);
+  }
+
+  public async setNode(
+    key: bigint,
+    level: number,
+    value: bigint
+  ): Promise<void> {
+    this.store.setNode(key, level, value);
+  }
+}