@waku/rln 0.0.2-2eccb11.0 → 0.0.2-3ab8023.0

package/src/contract/rln_contract.ts

@@ -1,3 +1,4 @@
+/* eslint-disable no-console */
 import { Logger } from "@waku/utils";
 import { hexToBytes } from "@waku/utils/bytes";
 import { ethers } from "ethers";
@@ -112,7 +113,7 @@ export class RLNContract {
     this.contract = contract || new ethers.Contract(address, RLN_ABI, signer);
     this.merkleRootTracker = new MerkleRootTracker(5, initialRoot);
 
-    // Initialize event filters for all relevant events
+    // Initialize event filters
     this._membersFilter = this.contract.filters.MembershipRegistered();
     this._membersRemovedFilter = this.contract.filters.MembershipErased();
     this._membersExpiredFilter = this.contract.filters.MembershipExpired();
@@ -267,7 +268,6 @@ export class RLNContract {
         // Both MembershipErased and MembershipExpired events should remove members
         let index = evt.args.index;
 
-        // Ensure index is an ethers.BigNumber
         if (!index) {
           return;
         }
@@ -293,7 +293,6 @@ export class RLNContract {
         eventsPerBlock.push(evt);
         toInsertTable.set(evt.blockNumber, eventsPerBlock);
       }
-      // MembershipExtended events don't change the membership set, so we don't need to handle them here
     });
 
     this.removeMembers(rlnInstance, toRemoveTable);
@@ -396,46 +395,149 @@ 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`
       );
 
+      // Check if the ID commitment is already registered
+      const existingIndex = await this.getMemberIndex(
+        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}`
+        );
+      }
+
+      // 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,
+        []
+      );
+      const gasLimit = estimatedGas.add(10000);
+
       const txRegisterResponse: ethers.ContractTransaction =
         await this.contract.register(
           identity.IDCommitmentBigInt,
           this.rateLimit,
           [],
-          { gasLimit: 300000 }
+          { 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) {
-        log.error(
+        console.log(
+          "registerWithIdentity - ERROR: no memberRegistered event found"
+        );
+        console.log(
+          "registerWithIdentity - all events:",
+          txRegisterReceipt.events
+        );
+        console.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);
 
-      return {
+      const result = {
         identity,
         membership: {
           address,
@@ -443,9 +545,41 @@ export class RLNContract {
           chainId: network.chainId
         }
       };
+      console.log("registerWithIdentity - returning result:", result);
+
+      return result;
     } catch (error) {
-      log.error(`Error in registerWithIdentity: ${(error as Error).message}`);
-      return undefined;
+      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);
+
+        // Try to extract more specific error information
+        if (errorMessage.includes("CannotExceedMaxTotalRateLimit")) {
+          console.error(
+            "Registration failed: Cannot exceed maximum total rate limit"
+          );
+        } else if (errorMessage.includes("InvalidIdCommitment")) {
+          console.error("Registration failed: Invalid ID commitment");
+        } else if (errorMessage.includes("InvalidMembershipRateLimit")) {
+          console.error("Registration failed: Invalid membership rate limit");
+        } else if (errorMessage.includes("execution reverted")) {
+          // Generic revert
+          console.error(
+            "Contract execution reverted. Check contract requirements."
+          );
+        } else {
+          console.error(`Error in registerWithIdentity: ${errorMessage}`);
+        }
+      } else {
+        console.error("Unknown error in registerWithIdentity");
+      }
+
+      // Re-throw the error to allow callers to handle it
+      throw error;
     }
   }
 
@@ -619,17 +753,28 @@ export class RLNContract {
   public async registerMembership(
     idCommitment: string,
     rateLimit: number = DEFAULT_RATE_LIMIT
-  ): Promise<ethers.ContractReceipt> {
-    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}`
-      );
+  ): 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;
     }
-    const tx = await this.contract.register(idCommitment, rateLimit, []);
-    return await tx.wait();
   }
 
   private async getMemberIndex(
@@ -648,6 +793,87 @@ 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/rln.ts

@@ -151,8 +151,6 @@ export class RLNInstance {
   }
 
   public async start(options: StartRLNOptions = {}): Promise<void> {
-    // eslint-disable-next-line no-console
-    console.log("starting", options);
     if (this.started || this.starting) {
       return;
     }
@@ -198,13 +196,6 @@ export class RLNInstance {
       chainId = SEPOLIA_CONTRACT.chainId;
     }
 
-    // eslint-disable-next-line no-console
-    console.log({
-      chainId,
-      address,
-      SEPOLIA_CONTRACT
-    });
-
     const signer = options.signer || (await extractMetaMaskSigner());
     const currentChainId = await signer.getChainId();
 
@@ -263,6 +254,9 @@ 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.");
     }