@waku/rln 0.1.6-10590da.0 → 0.1.6-27c1236.0

package/src/credentials_manager.ts

@@ -1,5 +1,5 @@
 import { hmac } from "@noble/hashes/hmac";
-import { sha256 } from "@noble/hashes/sha256";
+import { sha256 } from "@noble/hashes/sha2";
 import { Logger } from "@waku/utils";
 import { ethers } from "ethers";
 
@@ -14,7 +14,7 @@ import type {
 import { KeystoreEntity, Password } from "./keystore/types.js";
 import { RegisterMembershipOptions, StartRLNOptions } from "./types.js";
 import {
-  buildBigIntFromUint8Array,
+  buildBigIntFromUint8ArrayLE,
   extractMetaMaskSigner
 } from "./utils/index.js";
 import { Zerokit } from "./zerokit.js";
@@ -116,7 +116,9 @@ export class RLNCredentialsManager {
         );
       } else {
         log.info("Using local implementation to generate identity");
-        identity = this.generateSeededIdentityCredential(options.signature);
+        identity = await this.generateSeededIdentityCredential(
+          options.signature
+        );
       }
     }
 
@@ -249,7 +251,9 @@ export class RLNCredentialsManager {
    * @param seed A string seed to generate the identity from
    * @returns IdentityCredential
    */
-  private generateSeededIdentityCredential(seed: string): IdentityCredential {
+  private async generateSeededIdentityCredential(
+    seed: string
+  ): Promise<IdentityCredential> {
     log.info("Generating seeded identity credential");
     // Convert the seed to bytes
     const encoder = new TextEncoder();
@@ -260,21 +264,23 @@ export class RLNCredentialsManager {
     const idTrapdoor = hmac(sha256, seedBytes, encoder.encode("IDTrapdoor"));
     const idNullifier = hmac(sha256, seedBytes, encoder.encode("IDNullifier"));
 
-    // Generate IDSecretHash as a hash of IDTrapdoor and IDNullifier
     const combinedBytes = new Uint8Array([...idTrapdoor, ...idNullifier]);
     const idSecretHash = sha256(combinedBytes);
 
-    // Generate IDCommitment as a hash of IDSecretHash
     const idCommitment = sha256(idSecretHash);
 
-    // Convert IDCommitment to BigInt
-    let idCommitmentBigInt = buildBigIntFromUint8Array(idCommitment);
-    const Q = BigInt(
-      "21888242871839275222246405745257275088548364400416034343698204186575808495617"
-    );
-    if (idCommitmentBigInt >= Q) {
-      log.warn("IDCommitment is greater than Q, truncating");
-      idCommitmentBigInt = idCommitmentBigInt % Q;
+    let idCommitmentBigInt = buildBigIntFromUint8ArrayLE(idCommitment);
+    if (!this.contract) {
+      throw Error("RLN contract is not initialized");
+    }
+
+    const idCommitmentBigIntLimit = this.contract.idCommitmentBigIntLimit;
+
+    if (idCommitmentBigInt >= idCommitmentBigIntLimit) {
+      log.warn(
+        `ID commitment is greater than Q, reducing it by Q(idCommitmentBigIntLimit): ${idCommitmentBigInt} % ${idCommitmentBigIntLimit}`
+      );
+      idCommitmentBigInt = idCommitmentBigInt % idCommitmentBigIntLimit;
     }
 
     log.info("Successfully generated identity credential");

package/src/identity.ts

@@ -1,4 +1,4 @@
-import { buildBigIntFromUint8Array } from "./utils/index.js";
+import { buildBigIntFromUint8ArrayLE } from "./utils/index.js";
 
 export class IdentityCredential {
   public constructor(
@@ -18,7 +18,7 @@ export class IdentityCredential {
     const idNullifier = memKeys.subarray(32, 64);
     const idSecretHash = memKeys.subarray(64, 96);
     const idCommitment = memKeys.subarray(96, 128);
-    const idCommitmentBigInt = buildBigIntFromUint8Array(idCommitment);
+    const idCommitmentBigInt = buildBigIntFromUint8ArrayLE(idCommitment);
 
     return new IdentityCredential(
       idTrapdoor,

package/src/keystore/keystore.ts

@@ -14,7 +14,7 @@ import {
 import _ from "lodash";
 import { v4 as uuidV4 } from "uuid";
 
-import { buildBigIntFromUint8Array } from "../utils/bytes.js";
+import { buildBigIntFromUint8ArrayLE } from "../utils/bytes.js";
 
 import { decryptEipKeystore, keccak256Checksum } from "./cipher.js";
 import { isCredentialValid, isKeystoreValid } from "./schema_validator.js";
@@ -246,29 +246,37 @@ export class Keystore {
   private static fromBytesToIdentity(
     bytes: Uint8Array
   ): undefined | KeystoreEntity {
+    function fromLittleEndian(bytes: Uint8Array): Uint8Array {
+      return new Uint8Array(bytes).reverse();
+    }
     try {
       const str = bytesToUtf8(bytes);
       const obj = JSON.parse(str);
 
-      // TODO: add runtime validation of nwaku credentials
+      // Use little-endian bytes directly for BigInt conversion (matches storage and contract expectation)
+      const idCommitmentLE = Keystore.fromArraylikeToBytes(
+        _.get(obj, "identityCredential.idCommitment", [])
+      );
+
       return {
         identity: {
-          IDCommitment: Keystore.fromArraylikeToBytes(
-            _.get(obj, "identityCredential.idCommitment", [])
-          ),
-          IDTrapdoor: Keystore.fromArraylikeToBytes(
-            _.get(obj, "identityCredential.idTrapdoor", [])
-          ),
-          IDNullifier: Keystore.fromArraylikeToBytes(
-            _.get(obj, "identityCredential.idNullifier", [])
+          IDCommitment: fromLittleEndian(idCommitmentLE),
+          IDTrapdoor: fromLittleEndian(
+            Keystore.fromArraylikeToBytes(
+              _.get(obj, "identityCredential.idTrapdoor", [])
+            )
           ),
-          IDCommitmentBigInt: buildBigIntFromUint8Array(
+          IDNullifier: fromLittleEndian(
             Keystore.fromArraylikeToBytes(
-              _.get(obj, "identityCredential.idCommitment", [])
+              _.get(obj, "identityCredential.idNullifier", [])
             )
           ),
-          IDSecretHash: Keystore.fromArraylikeToBytes(
-            _.get(obj, "identityCredential.idSecretHash", [])
+          // Do NOT reverse for BigInt conversion; use little-endian as stored
+          IDCommitmentBigInt: buildBigIntFromUint8ArrayLE(idCommitmentLE),
+          IDSecretHash: fromLittleEndian(
+            Keystore.fromArraylikeToBytes(
+              _.get(obj, "identityCredential.idSecretHash", [])
+            )
           )
         },
         membership: {
@@ -321,14 +329,21 @@ export class Keystore {
   // follows nwaku implementation
   // https://github.com/waku-org/nwaku/blob/f05528d4be3d3c876a8b07f9bb7dfaae8aa8ec6e/waku/waku_keystore/protocol_types.nim#L98
   private static fromIdentityToBytes(options: KeystoreEntity): Uint8Array {
+    function toLittleEndian(bytes: Uint8Array): Uint8Array {
+      return new Uint8Array(bytes).reverse();
+    }
     return utf8ToBytes(
       JSON.stringify({
         treeIndex: options.membership.treeIndex,
         identityCredential: {
-          idCommitment: Array.from(options.identity.IDCommitment),
-          idNullifier: Array.from(options.identity.IDNullifier),
-          idSecretHash: Array.from(options.identity.IDSecretHash),
-          idTrapdoor: Array.from(options.identity.IDTrapdoor)
+          idCommitment: Array.from(
+            toLittleEndian(options.identity.IDCommitment)
+          ),
+          idNullifier: Array.from(toLittleEndian(options.identity.IDNullifier)),
+          idSecretHash: Array.from(
+            toLittleEndian(options.identity.IDSecretHash)
+          ),
+          idTrapdoor: Array.from(toLittleEndian(options.identity.IDTrapdoor))
         },
         membershipContract: {
           chainId: options.membership.chainId,

package/src/message.ts

@@ -1,7 +1,9 @@
+import { message } from "@waku/core";
 import type {
   IDecodedMessage,
   IMessage,
-  IRateLimitProof
+  IRateLimitProof,
+  IRlnMessage
 } from "@waku/interfaces";
 import * as utils from "@waku/utils/bytes";
 
@@ -13,12 +15,13 @@ export function toRLNSignal(contentTopic: string, msg: IMessage): Uint8Array {
   return new Uint8Array([...(msg.payload ?? []), ...contentTopicBytes]);
 }
 
-export class RlnMessage<T extends IDecodedMessage> implements IDecodedMessage {
+export class RlnMessage<T extends IDecodedMessage> implements IRlnMessage {
   public pubsubTopic = "";
+  public version = message.version_0.Version;
 
   public constructor(
-    public rlnInstance: RLNInstance,
-    public msg: T,
+    private rlnInstance: RLNInstance,
+    private msg: T,
     public rateLimitProof: IRateLimitProof | undefined
   ) {}
 

package/src/utils/bytes.ts

@@ -56,21 +56,11 @@ export function writeUIntLE(
   return buf;
 }
 
-/**
- * Transforms Uint8Array into BigInt
- * @param array: Uint8Array
- * @returns BigInt
- */
-export function buildBigIntFromUint8Array(
-  array: Uint8Array,
-  byteOffset: number = 0
-): bigint {
-  // Use all bytes from byteOffset to the end, big-endian
-  let hex = "";
-  for (let i = byteOffset; i < array.length; i++) {
-    hex += array[i].toString(16).padStart(2, "0");
-  }
-  return BigInt("0x" + hex);
+export function buildBigIntFromUint8ArrayLE(bytes: Uint8Array): bigint {
+  return bytes.reduce(
+    (acc, byte, i) => acc + BigInt(byte) * (1n << (8n * BigInt(i))),
+    0n
+  );
 }
 
 /**

package/src/utils/index.ts

@@ -2,7 +2,7 @@ export { extractMetaMaskSigner } from "./metamask.js";
 export {
   concatenate,
   writeUIntLE,
-  buildBigIntFromUint8Array,
+  buildBigIntFromUint8ArrayLE,
   zeroPadLE
 } from "./bytes.js";
 export { sha256, poseidonHash } from "./hash.js";