feat: implement proof generation and verification

fix: update tests
fix: store merkle proof/root as constant, remove use of RPC in proof gen/verification test

Author: adklempner

package-lock.json

@@ -24,4 +24,4 @@ if (process.env.CI) {
   console.log("Running tests serially. To enable parallel execution update mocha config");
 }
 
-module.exports = config;
+module.exports = config;

packages/rln/.mocharc.cjs

@@ -38,6 +38,14 @@ module.exports = function (config) {
         watched: false,
         type: "wasm",
         nocache: true
+      },
+      {
+        pattern: "../../node_modules/@waku/zerokit-rln-wasm-utils/*.wasm",
+        included: false,
+        served: true,
+        watched: false,
+        type: "wasm",
+        nocache: true
       }
     ],
 
@@ -82,6 +90,12 @@ module.exports = function (config) {
           __dirname,
           "../../node_modules/@waku/zerokit-rln-wasm/rln_wasm_bg.wasm"
         ),
+      "/base/rln_wasm_utils_bg.wasm":
+        "/absolute" +
+        path.resolve(
+          __dirname,
+          "../../node_modules/@waku/zerokit-rln-wasm-utils/rln_wasm_utils_bg.wasm"
+        ),
       "/base/rln.wasm":
         "/absolute" + path.resolve(__dirname, "src/resources/rln.wasm"),
       "/base/rln_final.zkey":

packages/rln/karma.conf.cjs

@@ -60,7 +60,6 @@
     "@types/sinon": "^17.0.3",
     "@wagmi/cli": "^2.7.0",
     "@waku/build-utils": "^1.0.0",
-    "@waku/interfaces": "0.0.34",
     "@waku/message-encryption": "^0.0.37",
     "deep-equal-in-any-order": "^2.0.6",
     "fast-check": "^3.23.2",
@@ -83,6 +82,7 @@
     "@waku/core": "^0.0.40",
     "@waku/utils": "^0.0.27",
     "@waku/zerokit-rln-wasm": "^0.2.1",
+    "@waku/zerokit-rln-wasm-utils": "^0.1.0",
     "chai": "^5.1.2",
     "chai-as-promised": "^8.0.1",
     "chai-spies": "^1.1.0",

packages/rln/package.json

@@ -160,7 +160,15 @@ export class Keystore {
   }
 
   public toString(): string {
-    return JSON.stringify(this.data);
+    // Custom replacer function to handle BigInt serialization
+    const bigIntReplacer = (_key: string, value: unknown): unknown => {
+      if (typeof value === "bigint") {
+        return value.toString();
+      }
+      return value;
+    };
+
+    return JSON.stringify(this.data, bigIntReplacer);
   }
 
   public toObject(): NwakuKeystore {
@@ -327,21 +335,32 @@ export class Keystore {
     const { IDCommitment, IDNullifier, IDSecretHash, IDTrapdoor } =
       options.identity;
 
+    // Custom replacer function to handle BigInt serialization
+    const bigIntReplacer = (_key: string, value: unknown): unknown => {
+      if (typeof value === "bigint") {
+        return value.toString();
+      }
+      return value;
+    };
+
     return utf8ToBytes(
-      JSON.stringify({
-        treeIndex: options.membership.treeIndex,
-        identityCredential: {
-          idCommitment: Array.from(IDCommitment),
-          idNullifier: Array.from(IDNullifier),
-          idSecretHash: Array.from(IDSecretHash),
-          idTrapdoor: Array.from(IDTrapdoor)
-        },
-        membershipContract: {
-          chainId: options.membership.chainId,
-          address: options.membership.address
+      JSON.stringify(
+        {
+          treeIndex: options.membership.treeIndex,
+          identityCredential: {
+            idCommitment: Array.from(IDCommitment),
+            idNullifier: Array.from(IDNullifier),
+            idSecretHash: Array.from(IDSecretHash),
+            idTrapdoor: Array.from(IDTrapdoor)
+          },
+          membershipContract: {
+            chainId: options.membership.chainId,
+            address: options.membership.address
+          },
+          userMessageLimit: options.membership.rateLimit
         },
-        userMessageLimit: options.membership.rateLimit
-      })
+        bigIntReplacer
+      )
     );
   }
 }

packages/rln/src/keystore/keystore.ts

@@ -0,0 +1,101 @@
+import { expect } from "chai";
+
+import { Keystore } from "./keystore/index.js";
+import { RLNInstance } from "./rln.js";
+import { BytesUtils } from "./utils/index.js";
+import {
+  calculateRateCommitment,
+  extractPathDirectionsFromProof,
+  MERKLE_TREE_DEPTH,
+  reconstructMerkleRoot
+} from "./utils/merkle.js";
+import { TEST_KEYSTORE_DATA } from "./utils/test_keystore.js";
+
+describe("RLN Proof Integration Tests", function () {
+  this.timeout(30000);
+
+  it("validate stored merkle proof data", function () {
+    // Convert stored merkle proof strings to bigints
+    const merkleProof = TEST_KEYSTORE_DATA.merkleProof.map((p) => BigInt(p));
+
+    expect(merkleProof).to.be.an("array");
+    expect(merkleProof).to.have.lengthOf(MERKLE_TREE_DEPTH); // RLN uses fixed depth merkle tree
+
+    merkleProof.forEach((element, i) => {
+      expect(element).to.be.a(
+        "bigint",
+        `Proof element ${i} should be a bigint`
+      );
+      expect(element).to.not.equal(0n, `Proof element ${i} should not be zero`);
+    });
+  });
+
+  it("should generate a valid RLN proof", async function () {
+    const rlnInstance = await RLNInstance.create();
+    // Load credential from test keystore
+    const keystore = Keystore.fromString(TEST_KEYSTORE_DATA.keystoreJson);
+    if (!keystore) {
+      throw new Error("Failed to load test keystore");
+    }
+    const credentialHash = TEST_KEYSTORE_DATA.credentialHash;
+    const password = TEST_KEYSTORE_DATA.password;
+    const credential = await keystore.readCredential(credentialHash, password);
+    if (!credential) {
+      throw new Error("Failed to unlock credential with provided password");
+    }
+
+    const idCommitment = credential.identity.IDCommitmentBigInt;
+
+    const merkleProof = TEST_KEYSTORE_DATA.merkleProof.map((p) => BigInt(p));
+    const merkleRoot = BigInt(TEST_KEYSTORE_DATA.merkleRoot);
+    const membershipIndex = BigInt(TEST_KEYSTORE_DATA.membershipIndex);
+    const rateLimit = BigInt(TEST_KEYSTORE_DATA.rateLimit);
+
+    const rateCommitment = calculateRateCommitment(idCommitment, rateLimit);
+
+    const proofElementIndexes = extractPathDirectionsFromProof(
+      merkleProof,
+      rateCommitment,
+      merkleRoot
+    );
+    if (!proofElementIndexes) {
+      throw new Error("Failed to extract proof element indexes");
+    }
+
+    expect(proofElementIndexes).to.have.lengthOf(MERKLE_TREE_DEPTH);
+
+    const reconstructedRoot = reconstructMerkleRoot(
+      merkleProof,
+      membershipIndex,
+      rateCommitment
+    );
+
+    expect(reconstructedRoot).to.equal(
+      merkleRoot,
+      "Reconstructed root should match stored root"
+    );
+
+    const testMessage = new TextEncoder().encode("test");
+
+    const proof = await rlnInstance.zerokit.generateRLNProof(
+      testMessage,
+      Number(membershipIndex),
+      new Date(),
+      credential.identity.IDSecretHash,
+      merkleProof.map((proof) => BytesUtils.fromBigInt(proof, 32, "little")),
+      proofElementIndexes.map((index) =>
+        BytesUtils.writeUIntLE(new Uint8Array(1), index, 0, 1)
+      ),
+      Number(rateLimit),
+      0
+    );
+
+    const isValid = rlnInstance.zerokit.verifyRLNProof(
+      BytesUtils.writeUIntLE(new Uint8Array(8), testMessage.length, 0, 8),
+      testMessage,
+      proof,
+      [BytesUtils.fromBigInt(merkleRoot, 32, "little")]
+    );
+    expect(isValid).to.be.true;
+  });
+});

packages/rln/src/proof.spec.ts

@@ -1,5 +1,6 @@
 import { Logger } from "@waku/utils";
 import init, * as zerokitRLN from "@waku/zerokit-rln-wasm";
+import initUtils from "@waku/zerokit-rln-wasm-utils";
 
 import { DEFAULT_RATE_LIMIT } from "./contract/constants.js";
 import { RLNCredentialsManager } from "./credentials_manager.js";
@@ -16,6 +17,7 @@ export class RLNInstance extends RLNCredentialsManager {
    */
   public static async create(): Promise<RLNInstance> {
     try {
+      await initUtils();
       await init();
       zerokitRLN.initPanicHook();