@waku/rln 0.0.2-3ab8023.0 → 0.0.2-9094860.0

package/src/contract/rln_contract.ts

@@ -1,4 +1,3 @@
-/* eslint-disable no-console */
 import { Logger } from "@waku/utils";
 import { hexToBytes } from "@waku/utils/bytes";
 import { ethers } from "ethers";
@@ -66,7 +65,7 @@ export class RLNContract {
 
   private _members: Map<number, Member> = new Map();
   private _membersFilter: ethers.EventFilter;
-  private _membersRemovedFilter: ethers.EventFilter;
+  private _membershipErasedFilter: ethers.EventFilter;
   private _membersExpiredFilter: ethers.EventFilter;
 
   /**
@@ -115,7 +114,7 @@ export class RLNContract {
 
     // Initialize event filters
     this._membersFilter = this.contract.filters.MembershipRegistered();
-    this._membersRemovedFilter = this.contract.filters.MembershipErased();
+    this._membershipErasedFilter = this.contract.filters.MembershipErased();
     this._membersExpiredFilter = this.contract.filters.MembershipExpired();
   }
 
@@ -185,7 +184,7 @@ export class RLNContract {
       this.contract.maxTotalRateLimit(),
       this.contract.currentTotalRateLimit()
     ]);
-    return maxTotal.sub(currentTotal).toNumber();
+    return Number(maxTotal) - Number(currentTotal);
   }
 
   /**
@@ -210,11 +209,11 @@ export class RLNContract {
     return this._membersFilter;
   }
 
-  private get membersRemovedFilter(): ethers.EventFilter {
-    if (!this._membersRemovedFilter) {
-      throw Error("MembersErased filter was not initialized.");
+  private get membershipErasedFilter(): ethers.EventFilter {
+    if (!this._membershipErasedFilter) {
+      throw Error("MembershipErased filter was not initialized.");
     }
-    return this._membersRemovedFilter;
+    return this._membershipErasedFilter;
   }
 
   private get membersExpiredFilter(): ethers.EventFilter {
@@ -236,7 +235,7 @@ export class RLNContract {
     const removedMemberEvents = await queryFilter(this.contract, {
       fromBlock: this.deployBlock,
       ...options,
-      membersFilter: this.membersRemovedFilter
+      membersFilter: this.membershipErasedFilter
     });
     const expiredMemberEvents = await queryFilter(this.contract, {
       fromBlock: this.deployBlock,
@@ -265,14 +264,12 @@ export class RLNContract {
         evt.event === "MembershipErased" ||
         evt.event === "MembershipExpired"
       ) {
-        // Both MembershipErased and MembershipExpired events should remove members
         let index = evt.args.index;
 
         if (!index) {
           return;
         }
 
-        // Convert index to ethers.BigNumber if it's not already
         if (typeof index === "number" || typeof index === "string") {
           index = ethers.BigNumber.from(index);
         }
@@ -310,12 +307,10 @@ export class RLNContract {
         const _idCommitment = evt.args.idCommitment as string;
         let index = evt.args.index;
 
-        // Ensure index is an ethers.BigNumber
         if (!_idCommitment || !index) {
           return;
         }
 
-        // Convert index to ethers.BigNumber if it's not already
         if (typeof index === "number" || typeof index === "string") {
           index = ethers.BigNumber.from(index);
         }
@@ -323,10 +318,9 @@ export class RLNContract {
         const idCommitment = zeroPadLE(hexToBytes(_idCommitment), 32);
         rlnInstance.zerokit.insertMember(idCommitment);
 
-        // Always store the numeric index as the key, but the BigNumber as the value
         const numericIndex = index.toNumber();
         this._members.set(numericIndex, {
-          index, // This is always a BigNumber
+          index,
           idCommitment: _idCommitment
         });
       });
@@ -367,7 +361,7 @@ export class RLNContract {
     );
 
     this.contract.on(
-      this.membersRemovedFilter,
+      this.membershipErasedFilter,
       (
         _idCommitment: string,
         _membershipRateLimit: ethers.BigNumber,
@@ -395,14 +389,6 @@ export class RLNContract {
     identity: IdentityCredential
   ): Promise<DecryptedCredentials | undefined> {
     try {
-      console.log("registerWithIdentity - starting registration process");
-      console.log("registerWithIdentity - identity:", identity);
-      console.log(
-        "registerWithIdentity - IDCommitmentBigInt:",
-        identity.IDCommitmentBigInt.toString()
-      );
-      console.log("registerWithIdentity - rate limit:", this.rateLimit);
-
       log.info(
         `Registering identity with rate limit: ${this.rateLimit} messages/epoch`
       );
@@ -412,9 +398,6 @@ export class RLNContract {
         identity.IDCommitmentBigInt.toString()
       );
       if (existingIndex) {
-        console.error(
-          `ID commitment is already registered with index ${existingIndex}`
-        );
         throw new Error(
           `ID commitment is already registered with index ${existingIndex}`
         );
@@ -423,16 +406,11 @@ export class RLNContract {
       // Check if there's enough remaining rate limit
       const remainingRateLimit = await this.getRemainingTotalRateLimit();
       if (remainingRateLimit < this.rateLimit) {
-        console.error(
-          `Not enough remaining rate limit. Requested: ${this.rateLimit}, Available: ${remainingRateLimit}`
-        );
         throw new Error(
           `Not enough remaining rate limit. Requested: ${this.rateLimit}, Available: ${remainingRateLimit}`
         );
       }
 
-      console.log("registerWithIdentity - calling contract.register");
-      // Estimate gas for the transaction
       const estimatedGas = await this.contract.estimateGas.register(
         identity.IDCommitmentBigInt,
         this.rateLimit,
@@ -447,97 +425,40 @@ export class RLNContract {
           [],
           { gasLimit }
         );
-      console.log(
-        "registerWithIdentity - txRegisterResponse:",
-        txRegisterResponse
-      );
-      console.log("registerWithIdentity - hash:", txRegisterResponse.hash);
-      console.log(
-        "registerWithIdentity - waiting for transaction confirmation..."
-      );
 
       const txRegisterReceipt = await txRegisterResponse.wait();
-      console.log(
-        "registerWithIdentity - txRegisterReceipt:",
-        txRegisterReceipt
-      );
-      console.log(
-        "registerWithIdentity - transaction status:",
-        txRegisterReceipt.status
-      );
-      console.log(
-        "registerWithIdentity - block number:",
-        txRegisterReceipt.blockNumber
-      );
-      console.log(
-        "registerWithIdentity - gas used:",
-        txRegisterReceipt.gasUsed.toString()
-      );
 
-      // Check transaction status
       if (txRegisterReceipt.status === 0) {
-        console.error("Transaction failed on-chain");
         throw new Error("Transaction failed on-chain");
       }
 
       const memberRegistered = txRegisterReceipt.events?.find(
         (event) => event.event === "MembershipRegistered"
       );
-      console.log(
-        "registerWithIdentity - memberRegistered event:",
-        memberRegistered
-      );
 
       if (!memberRegistered || !memberRegistered.args) {
-        console.log(
-          "registerWithIdentity - ERROR: no memberRegistered event found"
-        );
-        console.log(
-          "registerWithIdentity - all events:",
-          txRegisterReceipt.events
-        );
-        console.error(
+        log.error(
           "Failed to register membership: No MembershipRegistered event found"
         );
         return undefined;
       }
 
-      console.log(
-        "registerWithIdentity - memberRegistered args:",
-        memberRegistered.args
-      );
       const decodedData: MembershipRegisteredEvent = {
         idCommitment: memberRegistered.args.idCommitment,
         membershipRateLimit: memberRegistered.args.membershipRateLimit,
         index: memberRegistered.args.index
       };
-      console.log("registerWithIdentity - decodedData:", decodedData);
-      console.log(
-        "registerWithIdentity - index:",
-        decodedData.index.toString()
-      );
-      console.log(
-        "registerWithIdentity - membershipRateLimit:",
-        decodedData.membershipRateLimit.toString()
-      );
 
       log.info(
         `Successfully registered membership with index ${decodedData.index} ` +
           `and rate limit ${decodedData.membershipRateLimit}`
       );
 
-      console.log("registerWithIdentity - getting network information");
       const network = await this.contract.provider.getNetwork();
-      console.log("registerWithIdentity - network:", network);
-      console.log("registerWithIdentity - chainId:", network.chainId);
-
       const address = this.contract.address;
-      console.log("registerWithIdentity - contract address:", address);
-
-      const membershipId = decodedData.index.toNumber();
-      console.log("registerWithIdentity - membershipId:", membershipId);
+      const membershipId = Number(decodedData.index);
 
-      const result = {
+      return {
         identity,
         membership: {
           address,
@@ -545,41 +466,33 @@ export class RLNContract {
           chainId: network.chainId
         }
       };
-      console.log("registerWithIdentity - returning result:", result);
-
-      return result;
     } catch (error) {
-      console.log("registerWithIdentity - ERROR:", error);
-
-      // Improved error handling to decode contract errors
       if (error instanceof Error) {
         const errorMessage = error.message;
-        console.log("registerWithIdentity - error message:", errorMessage);
-        console.log("registerWithIdentity - error stack:", error.stack);
+        log.error("registerWithIdentity - error message:", errorMessage);
+        log.error("registerWithIdentity - error stack:", error.stack);
 
         // Try to extract more specific error information
         if (errorMessage.includes("CannotExceedMaxTotalRateLimit")) {
-          console.error(
+          throw new Error(
             "Registration failed: Cannot exceed maximum total rate limit"
           );
         } else if (errorMessage.includes("InvalidIdCommitment")) {
-          console.error("Registration failed: Invalid ID commitment");
+          throw new Error("Registration failed: Invalid ID commitment");
         } else if (errorMessage.includes("InvalidMembershipRateLimit")) {
-          console.error("Registration failed: Invalid membership rate limit");
+          throw new Error("Registration failed: Invalid membership rate limit");
         } else if (errorMessage.includes("execution reverted")) {
-          // Generic revert
-          console.error(
+          throw new Error(
             "Contract execution reverted. Check contract requirements."
           );
         } else {
-          console.error(`Error in registerWithIdentity: ${errorMessage}`);
+          throw new Error(`Error in registerWithIdentity: ${errorMessage}`);
         }
       } else {
-        console.error("Unknown error in registerWithIdentity");
+        throw new Error("Unknown error in registerWithIdentity", {
+          cause: error
+        });
       }
-
-      // Re-throw the error to allow callers to handle it
-      throw error;
     }
   }
 
@@ -668,7 +581,7 @@ export class RLNContract {
 
       const network = await this.contract.provider.getNetwork();
       const address = this.contract.address;
-      const membershipId = decodedData.index.toNumber();
+      const membershipId = Number(decodedData.index);
 
       return {
         identity,
@@ -734,47 +647,33 @@ export class RLNContract {
 
   public async extendMembership(
     idCommitment: string
-  ): Promise<ethers.ContractReceipt> {
-    const tx = await this.contract.extendMemberships([idCommitment]);
-    return await tx.wait();
+  ): Promise<ethers.ContractTransaction> {
+    return this.contract.extendMemberships([idCommitment]);
   }
 
   public async eraseMembership(
     idCommitment: string,
     eraseFromMembershipSet: boolean = true
-  ): Promise<ethers.ContractReceipt> {
-    const tx = await this.contract.eraseMemberships(
+  ): Promise<ethers.ContractTransaction> {
+    return this.contract.eraseMemberships(
       [idCommitment],
       eraseFromMembershipSet
     );
-    return await tx.wait();
   }
 
   public async registerMembership(
     idCommitment: string,
     rateLimit: number = DEFAULT_RATE_LIMIT
   ): Promise<ethers.ContractTransaction> {
-    try {
-      if (
-        rateLimit < RATE_LIMIT_PARAMS.MIN_RATE ||
-        rateLimit > RATE_LIMIT_PARAMS.MAX_RATE
-      ) {
-        throw new Error(
-          `Rate limit must be between ${RATE_LIMIT_PARAMS.MIN_RATE} and ${RATE_LIMIT_PARAMS.MAX_RATE}`
-        );
-      }
-
-      // Try to register
-      return this.contract.register(idCommitment, rateLimit, []);
-    } catch (error) {
-      console.error("Error in registerMembership:", error);
-
-      // Run debug to help diagnose the issue
-      await this.debugRegistration(idCommitment, rateLimit);
-
-      // Re-throw the error
-      throw error;
+    if (
+      rateLimit < RATE_LIMIT_PARAMS.MIN_RATE ||
+      rateLimit > RATE_LIMIT_PARAMS.MAX_RATE
+    ) {
+      throw new Error(
+        `Rate limit must be between ${RATE_LIMIT_PARAMS.MIN_RATE} and ${RATE_LIMIT_PARAMS.MAX_RATE}`
+      );
     }
+    return this.contract.register(idCommitment, rateLimit, []);
   }
 
   private async getMemberIndex(
@@ -793,87 +692,6 @@ export class RLNContract {
       return undefined;
     }
   }
-
-  /**
-   * Debug function to check why a registration might fail
-   * @param idCommitment The ID commitment to check
-   * @param rateLimit The rate limit to check
-   */
-  public async debugRegistration(
-    idCommitment: string,
-    rateLimit: number
-  ): Promise<void> {
-    console.log("=== DEBUG REGISTRATION ===");
-    console.log(`ID Commitment: ${idCommitment}`);
-    console.log(`Rate Limit: ${rateLimit}`);
-
-    // Check if ID commitment is already registered
-    try {
-      const existingIndex = await this.getMemberIndex(idCommitment);
-      if (existingIndex) {
-        console.error(
-          `ERROR: ID commitment is already registered with index ${existingIndex}`
-        );
-      } else {
-        console.log("ID commitment is not yet registered ✓");
-      }
-    } catch (error) {
-      console.error("Error checking if ID commitment is registered:", error);
-    }
-
-    // Check rate limit constraints
-    try {
-      const minRateLimit = await this.getMinRateLimit();
-      const maxRateLimit = await this.getMaxRateLimit();
-      const maxTotalRateLimit = await this.getMaxTotalRateLimit();
-      const currentTotalRateLimit = await this.getCurrentTotalRateLimit();
-      const remainingRateLimit = await this.getRemainingTotalRateLimit();
-
-      console.log(`Min Rate Limit: ${minRateLimit}`);
-      console.log(`Max Rate Limit: ${maxRateLimit}`);
-      console.log(`Max Total Rate Limit: ${maxTotalRateLimit}`);
-      console.log(`Current Total Rate Limit: ${currentTotalRateLimit}`);
-      console.log(`Remaining Rate Limit: ${remainingRateLimit}`);
-
-      if (rateLimit < minRateLimit) {
-        console.error(
-          `ERROR: Rate limit ${rateLimit} is below minimum ${minRateLimit}`
-        );
-      }
-      if (rateLimit > maxRateLimit) {
-        console.error(
-          `ERROR: Rate limit ${rateLimit} exceeds maximum ${maxRateLimit}`
-        );
-      }
-      if (rateLimit > remainingRateLimit) {
-        console.error(
-          `ERROR: Rate limit ${rateLimit} exceeds remaining capacity ${remainingRateLimit}`
-        );
-      }
-    } catch (error) {
-      console.error("Error checking rate limit constraints:", error);
-    }
-
-    // Try to estimate gas for the transaction to see if it would revert
-    try {
-      await this.contract.estimateGas.register(idCommitment, rateLimit, []);
-      console.log("Transaction gas estimation succeeded ✓");
-    } catch (error) {
-      console.error("Transaction would revert with error:", error);
-
-      // Try to extract more specific error information
-      const errorMessage = (error as Error).message;
-      if (errorMessage.includes("CannotExceedMaxTotalRateLimit")) {
-        console.error("Cannot exceed maximum total rate limit");
-      } else if (errorMessage.includes("InvalidIdCommitment")) {
-        console.error("Invalid ID commitment format");
-      } else if (errorMessage.includes("InvalidMembershipRateLimit")) {
-        console.error("Invalid membership rate limit");
-      }
-    }
-
-    console.log("=== END DEBUG ===");
-  }
 }
 
 interface CustomQueryOptions extends FetchMembersOptions {

package/src/identity_generator.ts

@@ -0,0 +1,108 @@
+import { keccak256 } from "@ethersproject/keccak256";
+import { toUtf8Bytes } from "@ethersproject/strings";
+
+import { IdentityCredential } from "./identity.js";
+import { buildBigIntFromUint8Array } from "./utils/index.js";
+
+/**
+ * A standalone implementation of identity generation for RLN memberships
+ * without Zerokit dependency. Only supports identity creation and membership
+ * registration.
+ */
+export class IdentityGenerator {
+  /**
+   * Generate a new random identity credential
+   * @returns An IdentityCredential object
+   */
+  public generateIdentityCredentials(): IdentityCredential {
+    // Generate random values for IDTrapdoor and IDNullifier
+    const idTrapdoor = crypto.getRandomValues(new Uint8Array(32));
+    const idNullifier = crypto.getRandomValues(new Uint8Array(32));
+
+    // Generate IDSecretHash by concatenating and hashing
+    const combined = new Uint8Array(64);
+    combined.set(idTrapdoor, 0);
+    combined.set(idNullifier, 32);
+    const idSecretHash = new Uint8Array(
+      keccak256(combined)
+        .substring(2)
+        .match(/.{1,2}/g)!
+        .map((byte) => parseInt(byte, 16))
+    );
+
+    // Generate IDCommitment by hashing IDSecretHash
+    const idCommitment = new Uint8Array(
+      keccak256(idSecretHash)
+        .substring(2)
+        .match(/.{1,2}/g)!
+        .map((byte) => parseInt(byte, 16))
+    );
+
+    // Generate BigInt from IDCommitment
+    const idCommitmentBigInt = buildBigIntFromUint8Array(idCommitment, 32);
+
+    return new IdentityCredential(
+      idTrapdoor,
+      idNullifier,
+      idSecretHash,
+      idCommitment,
+      idCommitmentBigInt
+    );
+  }
+
+  /**
+   * Generate an identity credential from a seed
+   * @param seed A string seed to generate a deterministic identity
+   * @returns An IdentityCredential object
+   */
+  public generateSeededIdentityCredential(seed: string): IdentityCredential {
+    // Convert seed to bytes
+    const seedBytes = toUtf8Bytes(seed);
+
+    // Use the seed to derive IDTrapdoor and IDNullifier deterministically
+    const seedHash = keccak256(seedBytes);
+    const seedHashBytes = new Uint8Array(
+      seedHash
+        .substring(2)
+        .match(/.{1,2}/g)!
+        .map((byte) => parseInt(byte, 16))
+    );
+
+    // Use first half for IDTrapdoor, second half for IDNullifier
+    const idTrapdoor = seedHashBytes.slice(0, 32);
+    const idNullifier = keccak256(seedHashBytes).substring(2);
+    const idNullifierBytes = new Uint8Array(
+      idNullifier.match(/.{1,2}/g)!.map((byte) => parseInt(byte, 16))
+    ).slice(0, 32);
+
+    // Generate IDSecretHash by concatenating and hashing
+    const combined = new Uint8Array(64);
+    combined.set(idTrapdoor, 0);
+    combined.set(idNullifierBytes, 32);
+    const idSecretHash = new Uint8Array(
+      keccak256(combined)
+        .substring(2)
+        .match(/.{1,2}/g)!
+        .map((byte) => parseInt(byte, 16))
+    );
+
+    // Generate IDCommitment by hashing IDSecretHash
+    const idCommitment = new Uint8Array(
+      keccak256(idSecretHash)
+        .substring(2)
+        .match(/.{1,2}/g)!
+        .map((byte) => parseInt(byte, 16))
+    );
+
+    // Generate BigInt from IDCommitment
+    const idCommitmentBigInt = buildBigIntFromUint8Array(idCommitment, 32);
+
+    return new IdentityCredential(
+      idTrapdoor,
+      idNullifierBytes,
+      idSecretHash,
+      idCommitment,
+      idCommitmentBigInt
+    );
+  }
+}

package/src/index.ts

@@ -3,9 +3,11 @@ import { RLN_ABI } from "./contract/abi.js";
 import { RLNContract, SEPOLIA_CONTRACT } from "./contract/index.js";
 import { createRLN } from "./create.js";
 import { IdentityCredential } from "./identity.js";
+import { IdentityGenerator } from "./identity_generator.js";
 import { Keystore } from "./keystore/index.js";
 import { Proof } from "./proof.js";
 import { RLNInstance } from "./rln.js";
+import { RLNLight } from "./rln_light.js";
 import { MerkleRootTracker } from "./root_tracker.js";
 import { extractMetaMaskSigner } from "./utils/index.js";
 
@@ -13,6 +15,8 @@ export {
   createRLN,
   Keystore,
   RLNInstance,
+  RLNLight,
+  IdentityGenerator,
   IdentityCredential,
   Proof,
   RLNEncoder,
@@ -23,3 +27,14 @@ export {
   extractMetaMaskSigner,
   RLN_ABI
 };
+
+export type {
+  DecryptedCredentials,
+  EncryptedCredentials,
+  Keccak256Hash,
+  KeystoreEntity,
+  MembershipHash,
+  MembershipInfo,
+  Password,
+  Sha256Hash
+} from "./keystore/types.js";

package/src/rln.ts

@@ -254,9 +254,6 @@ export class RLNInstance {
       );
     }
 
-    // eslint-disable-next-line no-console
-    console.log("registering membership", identity);
-
     if (!identity) {
       throw Error("Missing signature or identity to register membership.");
     }