@waku/rln 0.1.5-ea6daae.0 → 0.1.5-f39d215.0

package/src/contract/test-setup.ts

@@ -0,0 +1,86 @@
+import { hexToBytes } from "@waku/utils/bytes";
+import { ethers } from "ethers";
+import sinon from "sinon";
+
+import { createRLN } from "../create.js";
+import type { IdentityCredential } from "../identity.js";
+
+import { DEFAULT_RATE_LIMIT, LINEA_CONTRACT } from "./constants.js";
+import { RLNContract } from "./rln_contract.js";
+
+export interface TestRLNInstance {
+  rlnInstance: any;
+  identity: IdentityCredential;
+  insertMemberSpy: sinon.SinonStub;
+}
+
+/**
+ * Creates a test RLN instance with basic setup
+ */
+export async function createTestRLNInstance(): Promise<TestRLNInstance> {
+  const rlnInstance = await createRLN();
+  const insertMemberSpy = sinon.stub();
+  rlnInstance.zerokit.insertMember = insertMemberSpy;
+
+  const mockSignature =
+    "0xdeb8a6b00a8e404deb1f52d3aa72ed7f60a2ff4484c737eedaef18a0aacb2dfb4d5d74ac39bb71fa358cf2eb390565a35b026cc6272f2010d4351e17670311c21c";
+  const identity =
+    rlnInstance.zerokit.generateSeededIdentityCredential(mockSignature);
+
+  return {
+    rlnInstance,
+    identity,
+    insertMemberSpy
+  };
+}
+
+/**
+ * Initializes an RLN contract with the given registry contract
+ */
+export async function initializeRLNContract(
+  rlnInstance: any,
+  mockedRegistryContract: ethers.Contract
+): Promise<RLNContract> {
+  const provider = new ethers.providers.JsonRpcProvider();
+  const voidSigner = new ethers.VoidSigner(LINEA_CONTRACT.address, provider);
+
+  const originalRegister = mockedRegistryContract.register;
+  (mockedRegistryContract as any).register = function (...args: any[]) {
+    const result = originalRegister.apply(this, args);
+
+    if (args[0] && rlnInstance.zerokit) {
+      const idCommitmentBigInt = args[0];
+      const idCommitmentHex =
+        "0x" + idCommitmentBigInt.toString(16).padStart(64, "0");
+      const idCommitment = ethers.utils.zeroPad(
+        hexToBytes(idCommitmentHex),
+        32
+      );
+      rlnInstance.zerokit.insertMember(idCommitment);
+    }
+
+    return result;
+  };
+
+  const contract = await RLNContract.init(rlnInstance, {
+    address: LINEA_CONTRACT.address,
+    signer: voidSigner,
+    rateLimit: DEFAULT_RATE_LIMIT,
+    contract: mockedRegistryContract
+  });
+
+  return contract;
+}
+
+/**
+ * Common test message data
+ */
+export const TEST_DATA = {
+  contentTopic: "/test/1/waku-message/utf8",
+  emptyPubsubTopic: "",
+  testMessage: Uint8Array.from(
+    "Hello World".split("").map((x) => x.charCodeAt(0))
+  ),
+  mockSignature:
+    "0xdeb8a6b00a8e404deb1f52d3aa72ed7f60a2ff4484c737eedaef18a0aacb2dfb4d5d74ac39bb71fa358cf2eb390565a35b026cc6272f2010d4351e17670311c21c"
+} as const;

package/src/contract/test-utils.ts

@@ -0,0 +1,179 @@
+import { hexToBytes } from "@waku/utils/bytes";
+import { expect } from "chai";
+import * as ethers from "ethers";
+import sinon from "sinon";
+
+import type { IdentityCredential } from "../identity.js";
+
+import { DEFAULT_RATE_LIMIT, LINEA_CONTRACT } from "./constants.js";
+
+export const mockRateLimits = {
+  minRate: 20,
+  maxRate: 600,
+  maxTotalRate: 1200,
+  currentTotalRate: 500
+};
+
+type MockProvider = {
+  getLogs: () => never[];
+  getBlockNumber: () => Promise<number>;
+  getNetwork: () => Promise<{ chainId: number }>;
+};
+
+type MockFilters = {
+  MembershipRegistered: () => { address: string };
+  MembershipErased: () => { address: string };
+  MembershipExpired: () => { address: string };
+};
+
+export function createMockProvider(): MockProvider {
+  return {
+    getLogs: () => [],
+    getBlockNumber: () => Promise.resolve(1000),
+    getNetwork: () => Promise.resolve({ chainId: 11155111 })
+  };
+}
+
+export function createMockFilters(): MockFilters {
+  return {
+    MembershipRegistered: () => ({ address: LINEA_CONTRACT.address }),
+    MembershipErased: () => ({ address: LINEA_CONTRACT.address }),
+    MembershipExpired: () => ({ address: LINEA_CONTRACT.address })
+  };
+}
+
+type ContractOverrides = Partial<{
+  filters: Record<string, unknown>;
+  [key: string]: unknown;
+}>;
+
+export function createMockRegistryContract(
+  overrides: ContractOverrides = {}
+): ethers.Contract {
+  const filters = {
+    MembershipRegistered: () => ({ address: LINEA_CONTRACT.address }),
+    MembershipErased: () => ({ address: LINEA_CONTRACT.address }),
+    MembershipExpired: () => ({ address: LINEA_CONTRACT.address })
+  };
+
+  const baseContract = {
+    minMembershipRateLimit: () =>
+      Promise.resolve(ethers.BigNumber.from(mockRateLimits.minRate)),
+    maxMembershipRateLimit: () =>
+      Promise.resolve(ethers.BigNumber.from(mockRateLimits.maxRate)),
+    maxTotalRateLimit: () =>
+      Promise.resolve(ethers.BigNumber.from(mockRateLimits.maxTotalRate)),
+    currentTotalRateLimit: () =>
+      Promise.resolve(ethers.BigNumber.from(mockRateLimits.currentTotalRate)),
+    queryFilter: () => [],
+    provider: createMockProvider(),
+    filters,
+    on: () => ({}),
+    removeAllListeners: () => ({}),
+    register: () => ({
+      wait: () =>
+        Promise.resolve({
+          events: [mockRLNRegisteredEvent()]
+        })
+    }),
+    estimateGas: {
+      register: () => Promise.resolve(ethers.BigNumber.from(100000))
+    },
+    functions: {
+      register: () => Promise.resolve()
+    },
+    getMemberIndex: () => Promise.resolve(null),
+    interface: {
+      getEvent: (eventName: string) => ({
+        name: eventName,
+        format: () => {}
+      })
+    },
+    address: LINEA_CONTRACT.address
+  };
+
+  // Merge overrides while preserving filters
+  const merged = {
+    ...baseContract,
+    ...overrides,
+    filters: { ...filters, ...(overrides.filters || {}) }
+  };
+
+  return merged as unknown as ethers.Contract;
+}
+
+export function mockRLNRegisteredEvent(idCommitment?: string): ethers.Event {
+  return {
+    args: {
+      idCommitment:
+        idCommitment ||
+        "0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef",
+      membershipRateLimit: ethers.BigNumber.from(DEFAULT_RATE_LIMIT),
+      index: ethers.BigNumber.from(1)
+    },
+    event: "MembershipRegistered"
+  } as unknown as ethers.Event;
+}
+
+export function formatIdCommitment(idCommitmentBigInt: bigint): string {
+  return "0x" + idCommitmentBigInt.toString(16).padStart(64, "0");
+}
+
+export function createRegisterStub(
+  identity: IdentityCredential
+): sinon.SinonStub {
+  return sinon.stub().callsFake(() => ({
+    wait: () =>
+      Promise.resolve({
+        events: [
+          {
+            event: "MembershipRegistered",
+            args: {
+              idCommitment: formatIdCommitment(identity.IDCommitmentBigInt),
+              membershipRateLimit: ethers.BigNumber.from(DEFAULT_RATE_LIMIT),
+              index: ethers.BigNumber.from(1)
+            }
+          }
+        ]
+      })
+  }));
+}
+
+export function verifyRegistration(
+  decryptedCredentials: any,
+  identity: IdentityCredential,
+  registerStub: sinon.SinonStub,
+  insertMemberSpy: sinon.SinonStub
+): void {
+  if (!decryptedCredentials) {
+    throw new Error("Decrypted credentials should not be undefined");
+  }
+
+  // Verify registration call
+  expect(
+    registerStub.calledWith(
+      sinon.match.same(identity.IDCommitmentBigInt),
+      sinon.match.same(DEFAULT_RATE_LIMIT),
+      sinon.match.array,
+      sinon.match.object
+    )
+  ).to.be.true;
+
+  // Verify credential properties
+  expect(decryptedCredentials).to.have.property("identity");
+  expect(decryptedCredentials).to.have.property("membership");
+  expect(decryptedCredentials.membership).to.include({
+    address: LINEA_CONTRACT.address,
+    treeIndex: 1
+  });
+
+  // Verify member insertion
+  const expectedIdCommitment = ethers.utils.zeroPad(
+    hexToBytes(formatIdCommitment(identity.IDCommitmentBigInt)),
+    32
+  );
+  expect(insertMemberSpy.callCount).to.equal(1);
+  expect(insertMemberSpy.getCall(0).args[0]).to.deep.equal(
+    expectedIdCommitment
+  );
+}

package/src/identity.ts

@@ -28,4 +28,14 @@ export class IdentityCredential {
       idCommitmentBigInt
     );
   }
+
+  public toJSON(): Record<string, number[] | string> {
+    return {
+      idTrapdoor: Array.from(this.IDTrapdoor),
+      idNullifier: Array.from(this.IDNullifier),
+      idSecretHash: Array.from(this.IDSecretHash),
+      idCommitment: Array.from(this.IDCommitment),
+      idCommitmentBigInt: this.IDCommitmentBigInt.toString()
+    };
+  }
 }

package/src/index.ts

@@ -1,15 +1,19 @@
 import { RLNDecoder, RLNEncoder } from "./codec.js";
 import { RLN_ABI } from "./contract/abi.js";
-import { RLNContract, SEPOLIA_CONTRACT } from "./contract/index.js";
+import { LINEA_CONTRACT, RLNContract } from "./contract/index.js";
+import { RLNLightContract } from "./contract/rln_light_contract.js";
 import { createRLN } from "./create.js";
 import { IdentityCredential } from "./identity.js";
 import { Keystore } from "./keystore/index.js";
 import { Proof } from "./proof.js";
 import { RLNInstance } from "./rln.js";
+import { RLNLightInstance } from "./rln_light.js";
 import { MerkleRootTracker } from "./root_tracker.js";
 import { extractMetaMaskSigner } from "./utils/index.js";
 
 export {
+  RLNLightInstance,
+  RLNLightContract,
   createRLN,
   Keystore,
   RLNInstance,
@@ -19,7 +23,18 @@ export {
   RLNDecoder,
   MerkleRootTracker,
   RLNContract,
-  SEPOLIA_CONTRACT,
+  LINEA_CONTRACT,
   extractMetaMaskSigner,
   RLN_ABI
 };
+
+export type {
+  DecryptedCredentials,
+  EncryptedCredentials,
+  Keccak256Hash,
+  KeystoreEntity,
+  MembershipHash,
+  MembershipInfo,
+  Password,
+  Sha256Hash
+} from "./keystore/types.js";

package/src/keystore/keystore.ts

@@ -14,6 +14,7 @@ import {
 import _ from "lodash";
 import { v4 as uuidV4 } from "uuid";
 
+import { IdentityCredential } from "../identity.js";
 import { buildBigIntFromUint8Array } from "../utils/bytes.js";
 
 import { decryptEipKeystore, keccak256Checksum } from "./cipher.js";
@@ -250,31 +251,32 @@ export class Keystore {
       const str = bytesToUtf8(bytes);
       const obj = JSON.parse(str);
 
-      // TODO: add runtime validation of nwaku credentials
+      // Get identity fields from named object
+      const { idTrapdoor, idNullifier, idSecretHash, idCommitment } = _.get(
+        obj,
+        "identityCredential",
+        {}
+      );
+
+      const idTrapdoorArray = new Uint8Array(idTrapdoor || []);
+      const idNullifierArray = new Uint8Array(idNullifier || []);
+      const idSecretHashArray = new Uint8Array(idSecretHash || []);
+      const idCommitmentArray = new Uint8Array(idCommitment || []);
+      const idCommitmentBigInt = buildBigIntFromUint8Array(idCommitmentArray);
+
       return {
-        identity: {
-          IDCommitment: Keystore.fromArraylikeToBytes(
-            _.get(obj, "identityCredential.idCommitment", [])
-          ),
-          IDTrapdoor: Keystore.fromArraylikeToBytes(
-            _.get(obj, "identityCredential.idTrapdoor", [])
-          ),
-          IDNullifier: Keystore.fromArraylikeToBytes(
-            _.get(obj, "identityCredential.idNullifier", [])
-          ),
-          IDCommitmentBigInt: buildBigIntFromUint8Array(
-            Keystore.fromArraylikeToBytes(
-              _.get(obj, "identityCredential.idCommitment", [])
-            )
-          ),
-          IDSecretHash: Keystore.fromArraylikeToBytes(
-            _.get(obj, "identityCredential.idSecretHash", [])
-          )
-        },
+        identity: new IdentityCredential(
+          idTrapdoorArray,
+          idNullifierArray,
+          idSecretHashArray,
+          idCommitmentArray,
+          idCommitmentBigInt
+        ),
         membership: {
           treeIndex: _.get(obj, "treeIndex"),
           chainId: _.get(obj, "membershipContract.chainId"),
-          address: _.get(obj, "membershipContract.address")
+          address: _.get(obj, "membershipContract.address"),
+          rateLimit: _.get(obj, "membershipContract.rateLimit")
         }
       };
     } catch (err) {
@@ -283,23 +285,6 @@ export class Keystore {
     }
   }
 
-  private static fromArraylikeToBytes(obj: {
-    [key: number]: number;
-  }): Uint8Array {
-    const bytes = [];
-
-    let index = 0;
-    let lastElement = obj[index];
-
-    while (lastElement !== undefined) {
-      bytes.push(lastElement);
-      index += 1;
-      lastElement = obj[index];
-    }
-
-    return new Uint8Array(bytes);
-  }
-
   // follows nwaku implementation
   // https://github.com/waku-org/nwaku/blob/f05528d4be3d3c876a8b07f9bb7dfaae8aa8ec6e/waku/waku_keystore/protocol_types.nim#L111
   private static computeMembershipHash(info: MembershipInfo): MembershipHash {
@@ -315,10 +300,10 @@ export class Keystore {
       JSON.stringify({
         treeIndex: options.membership.treeIndex,
         identityCredential: {
-          idCommitment: options.identity.IDCommitment,
-          idNullifier: options.identity.IDNullifier,
-          idSecretHash: options.identity.IDSecretHash,
-          idTrapdoor: options.identity.IDTrapdoor
+          idTrapdoor: Array.from(options.identity.IDTrapdoor),
+          idNullifier: Array.from(options.identity.IDNullifier),
+          idSecretHash: Array.from(options.identity.IDSecretHash),
+          idCommitment: Array.from(options.identity.IDCommitment)
         },
         membershipContract: {
           chainId: options.membership.chainId,

package/src/keystore/types.ts

@@ -8,9 +8,10 @@ export type Password = string | Uint8Array;
 // see reference
 // https://github.com/waku-org/nwaku/blob/f05528d4be3d3c876a8b07f9bb7dfaae8aa8ec6e/waku/waku_keystore/protocol_types.nim#L111
 export type MembershipInfo = {
-  chainId: number;
+  chainId: string;
   address: string;
   treeIndex: number;
+  rateLimit: number;
 };
 
 export type KeystoreEntity = {

package/src/rln.ts

@@ -16,7 +16,7 @@ import {
   type RLNEncoder
 } from "./codec.js";
 import { DEFAULT_RATE_LIMIT } from "./contract/constants.js";
-import { RLNContract, SEPOLIA_CONTRACT } from "./contract/index.js";
+import { LINEA_CONTRACT, RLNContract } from "./contract/index.js";
 import { IdentityCredential } from "./identity.js";
 import { Keystore } from "./keystore/index.js";
 import type {
@@ -108,7 +108,7 @@ type StartRLNOptions = {
    */
   signer?: ethers.Signer;
   /**
-   * If not set - will use default SEPOLIA_CONTRACT address.
+   * If not set - will use default LINEA_CONTRACT address.
    */
   address?: string;
   /**
@@ -160,7 +160,7 @@ export class RLNInstance {
     try {
       const { credentials, keystore } =
         await RLNInstance.decryptCredentialsIfNeeded(options.credentials);
-      const { signer, address } = await this.determineStartOptions(
+      const { signer, address, rateLimit } = await this.determineStartOptions(
         options,
         credentials
       );
@@ -174,7 +174,7 @@ export class RLNInstance {
       this._contract = await RLNContract.init(this, {
         address: address!,
         signer: signer!,
-        rateLimit: options.rateLimit ?? this.zerokit.getRateLimit
+        rateLimit: rateLimit ?? this.zerokit.getRateLimit
       });
       this.started = true;
     } finally {
@@ -190,14 +190,14 @@ export class RLNInstance {
     const address =
       credentials?.membership.address ||
       options.address ||
-      SEPOLIA_CONTRACT.address;
+      LINEA_CONTRACT.address;
 
-    if (address === SEPOLIA_CONTRACT.address) {
-      chainId = SEPOLIA_CONTRACT.chainId;
+    if (address === LINEA_CONTRACT.address) {
+      chainId = LINEA_CONTRACT.chainId;
     }
 
     const signer = options.signer || (await extractMetaMaskSigner());
-    const currentChainId = await signer.getChainId();
+    const currentChainId = (await signer.getChainId()).toString();
 
     if (chainId && chainId !== currentChainId) {
       throw Error(
@@ -312,7 +312,7 @@ export class RLNInstance {
 
     const chainId = credentials.membership.chainId;
     const network = await this._contract.provider.getNetwork();
-    const currentChainId = network.chainId;
+    const currentChainId = network.chainId.toString();
     if (chainId !== currentChainId) {
       throw Error(
         `Failed to verify chain coordinates: credentials chainID=${chainId} is not equal to registryContract chainID=${currentChainId}`