@waku/rln 0.0.2-c41b319.0 → 0.0.2-c8128d1.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";
@@ -8,7 +9,7 @@ import type { RLNInstance } from "../rln.js";
 import { MerkleRootTracker } from "../root_tracker.js";
 import { zeroPadLE } from "../utils/bytes.js";
 
-import { RLN_V2_ABI } from "./abi/rlnv2.js";
+import { RLN_ABI } from "./abi.js";
 import { DEFAULT_RATE_LIMIT, RATE_LIMIT_PARAMS } from "./constants.js";
 
 const log = new Logger("waku:rln:contract");
@@ -30,7 +31,7 @@ interface RLNContractInitOptions extends RLNContractOptions {
 
 export interface MembershipRegisteredEvent {
   idCommitment: string;
-  rateLimit: number;
+  membershipRateLimit: ethers.BigNumber;
   index: ethers.BigNumber;
 }
 
@@ -66,6 +67,7 @@ export class RLNContract {
   private _members: Map<number, Member> = new Map();
   private _membersFilter: ethers.EventFilter;
   private _membersRemovedFilter: ethers.EventFilter;
+  private _membersExpiredFilter: ethers.EventFilter;
 
   /**
    * Asynchronous initializer for RLNContract.
@@ -108,13 +110,13 @@ export class RLNContract {
     const initialRoot = rlnInstance.zerokit.getMerkleRoot();
 
     // Use the injected contract if provided; otherwise, instantiate a new one.
-    this.contract =
-      contract || new ethers.Contract(address, RLN_V2_ABI, signer);
+    this.contract = contract || new ethers.Contract(address, RLN_ABI, signer);
     this.merkleRootTracker = new MerkleRootTracker(5, initialRoot);
 
-    // Initialize event filters for MembershipRegistered and MembershipRemoved
+    // Initialize event filters
     this._membersFilter = this.contract.filters.MembershipRegistered();
-    this._membersRemovedFilter = this.contract.filters.MembershipRemoved();
+    this._membersRemovedFilter = this.contract.filters.MembershipErased();
+    this._membersExpiredFilter = this.contract.filters.MembershipExpired();
   }
 
   /**
@@ -124,6 +126,20 @@ export class RLNContract {
     return this.rateLimit;
   }
 
+  /**
+   * Gets the contract address
+   */
+  public get address(): string {
+    return this.contract.address;
+  }
+
+  /**
+   * Gets the contract provider
+   */
+  public get provider(): ethers.providers.Provider {
+    return this.contract.provider;
+  }
+
   /**
    * Gets the minimum allowed rate limit from the contract
    * @returns Promise<number> The minimum rate limit in messages per epoch
@@ -196,11 +212,18 @@ export class RLNContract {
 
   private get membersRemovedFilter(): ethers.EventFilter {
     if (!this._membersRemovedFilter) {
-      throw Error("MembersRemoved filter was not initialized.");
+      throw Error("MembersErased filter was not initialized.");
     }
     return this._membersRemovedFilter;
   }
 
+  private get membersExpiredFilter(): ethers.EventFilter {
+    if (!this._membersExpiredFilter) {
+      throw Error("MembersExpired filter was not initialized.");
+    }
+    return this._membersExpiredFilter;
+  }
+
   public async fetchMembers(
     rlnInstance: RLNInstance,
     options: FetchMembersOptions = {}
@@ -215,8 +238,17 @@ export class RLNContract {
       ...options,
       membersFilter: this.membersRemovedFilter
     });
+    const expiredMemberEvents = await queryFilter(this.contract, {
+      fromBlock: this.deployBlock,
+      ...options,
+      membersFilter: this.membersExpiredFilter
+    });
 
-    const events = [...registeredMemberEvents, ...removedMemberEvents];
+    const events = [
+      ...registeredMemberEvents,
+      ...removedMemberEvents,
+      ...expiredMemberEvents
+    ];
     this.processEvents(rlnInstance, events);
   }
 
@@ -229,8 +261,22 @@ export class RLNContract {
         return;
       }
 
-      if (evt.event === "MembershipRemoved") {
-        const index = evt.args.index as ethers.BigNumber;
+      if (
+        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);
+        }
+
         const toRemoveVal = toRemoveTable.get(evt.blockNumber);
         if (toRemoveVal != undefined) {
           toRemoveVal.push(index.toNumber());
@@ -262,16 +308,25 @@ export class RLNContract {
         if (!evt.args) return;
 
         const _idCommitment = evt.args.idCommitment as string;
-        const index = evt.args.index as ethers.BigNumber;
+        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);
+        }
+
         const idCommitment = zeroPadLE(hexToBytes(_idCommitment), 32);
         rlnInstance.zerokit.insertMember(idCommitment);
-        this._members.set(index.toNumber(), {
-          index,
+
+        // 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
           idCommitment: _idCommitment
         });
       });
@@ -303,7 +358,7 @@ export class RLNContract {
       this.membersFilter,
       (
         _idCommitment: string,
-        _rateLimit: number,
+        _membershipRateLimit: ethers.BigNumber,
         _index: ethers.BigNumber,
         event: ethers.Event
       ) => {
@@ -315,6 +370,19 @@ export class RLNContract {
       this.membersRemovedFilter,
       (
         _idCommitment: string,
+        _membershipRateLimit: ethers.BigNumber,
+        _index: ethers.BigNumber,
+        event: ethers.Event
+      ) => {
+        this.processEvents(rlnInstance, [event]);
+      }
+    );
+
+    this.contract.on(
+      this.membersExpiredFilter,
+      (
+        _idCommitment: string,
+        _membershipRateLimit: ethers.BigNumber,
         _index: ethers.BigNumber,
         event: ethers.Event
       ) => {
@@ -327,10 +395,43 @@ 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");
       const txRegisterResponse: ethers.ContractTransaction =
         await this.contract.register(
           identity.IDCommitmentBigInt,
@@ -338,35 +439,97 @@ export class RLNContract {
           [],
           { gasLimit: 300000 }
         );
+      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,
-        rateLimit: memberRegistered.args.rateLimit,
+        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.rateLimit}`
+          `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,
@@ -374,9 +537,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;
     }
   }
 
@@ -454,13 +649,13 @@ export class RLNContract {
 
       const decodedData: MembershipRegisteredEvent = {
         idCommitment: memberRegistered.args.idCommitment,
-        rateLimit: memberRegistered.args.rateLimit,
+        membershipRateLimit: memberRegistered.args.membershipRateLimit,
         index: memberRegistered.args.index
       };
 
       log.info(
         `Successfully registered membership with permit. Index: ${decodedData.index}, ` +
-          `Rate limit: ${decodedData.rateLimit}, Erased ${idCommitmentsToErase.length} commitments`
+          `Rate limit: ${decodedData.membershipRateLimit}, Erased ${idCommitmentsToErase.length} commitments`
       );
 
       const network = await this.contract.provider.getNetwork();
@@ -531,18 +726,20 @@ export class RLNContract {
 
   public async extendMembership(
     idCommitment: string
-  ): Promise<ethers.ContractTransaction> {
-    return this.contract.extendMemberships([idCommitment]);
+  ): Promise<ethers.ContractReceipt> {
+    const tx = await this.contract.extendMemberships([idCommitment]);
+    return await tx.wait();
   }
 
   public async eraseMembership(
     idCommitment: string,
     eraseFromMembershipSet: boolean = true
-  ): Promise<ethers.ContractTransaction> {
-    return this.contract.eraseMemberships(
+  ): Promise<ethers.ContractReceipt> {
+    const tx = await this.contract.eraseMemberships(
       [idCommitment],
       eraseFromMembershipSet
     );
+    return await tx.wait();
   }
 
   public async registerMembership(
@@ -557,7 +754,10 @@ export class RLNContract {
         `Rate limit must be between ${RATE_LIMIT_PARAMS.MIN_RATE} and ${RATE_LIMIT_PARAMS.MAX_RATE}`
       );
     }
-    return this.contract.register(idCommitment, rateLimit, []);
+    console.log("registering membership", idCommitment, rateLimit);
+    const txn = this.contract.register(idCommitment, rateLimit, []);
+    console.log("txn", txn);
+    return txn;
   }
 
   private async getMemberIndex(

package/src/identity.ts

@@ -1,8 +1,3 @@
-import { arrayify } from "@ethersproject/bytes";
-import { keccak256 } from "@ethersproject/keccak256";
-import { Poseidon } from "@iden3/js-crypto";
-import { streamXOR } from "@stablelib/chacha";
-
 import { buildBigIntFromUint8Array } from "./utils/index.js";
 
 export class IdentityCredential {
@@ -33,41 +28,4 @@ export class IdentityCredential {
       idCommitmentBigInt
     );
   }
-
-  public static generateSeeded(signature: Uint8Array): IdentityCredential {
-    // Generate deterministic seed from signature
-    const seed = arrayify(keccak256(signature));
-
-    // Use ChaCha for deterministic randomness (as in Rust code)
-    const nonce = new Uint8Array(12);
-    const idSecretHash = new Uint8Array(32);
-    streamXOR(seed, nonce, idSecretHash, idSecretHash);
-
-    // Convert to bigint for Poseidon
-    const secretBigInt = BigInt(
-      "0x" + Buffer.from(idSecretHash).toString("hex")
-    );
-
-    // Generate commitment using Poseidon
-    const idCommitmentBigInt = Poseidon.hash([secretBigInt]);
-
-    // Convert commitment back to Uint8Array
-    const idCommitment = arrayify(
-      "0x" + idCommitmentBigInt.toString(16).padStart(64, "0")
-    );
-
-    // Generate deterministic trapdoor and nullifier from the secret hash
-    const idTrapdoor = new Uint8Array(32);
-    const idNullifier = new Uint8Array(32);
-    streamXOR(idSecretHash, nonce, idTrapdoor, idTrapdoor);
-    streamXOR(idTrapdoor, nonce, idNullifier, idNullifier);
-
-    return new IdentityCredential(
-      idTrapdoor,
-      idNullifier,
-      idSecretHash,
-      idCommitment,
-      idCommitmentBigInt
-    );
-  }
 }

package/src/index.ts

@@ -1,5 +1,5 @@
 import { RLNDecoder, RLNEncoder } from "./codec.js";
-import { RLN_V2_ABI } from "./contract/abi/rlnv2.js";
+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";
@@ -21,5 +21,5 @@ export {
   RLNContract,
   SEPOLIA_CONTRACT,
   extractMetaMaskSigner,
-  RLN_V2_ABI
+  RLN_ABI
 };

package/src/rln.ts

@@ -15,6 +15,7 @@ import {
   type RLNDecoder,
   type RLNEncoder
 } from "./codec.js";
+import { DEFAULT_RATE_LIMIT } from "./contract/constants.js";
 import { RLNContract, SEPOLIA_CONTRACT } from "./contract/index.js";
 import { IdentityCredential } from "./identity.js";
 import { Keystore } from "./keystore/index.js";
@@ -32,15 +33,46 @@ import { Zerokit } from "./zerokit.js";
 const log = new Logger("waku:rln");
 
 async function loadWitnessCalculator(): Promise<WitnessCalculator> {
-  const url = new URL("./resources/rln.wasm", import.meta.url);
-  const response = await fetch(url);
-  return await wc.builder(new Uint8Array(await response.arrayBuffer()), false);
+  try {
+    const url = new URL("./resources/rln.wasm", import.meta.url);
+    const response = await fetch(url);
+
+    if (!response.ok) {
+      throw new Error(
+        `Failed to fetch witness calculator: ${response.status} ${response.statusText}`
+      );
+    }
+
+    return await wc.builder(
+      new Uint8Array(await response.arrayBuffer()),
+      false
+    );
+  } catch (error) {
+    log.error("Error loading witness calculator:", error);
+    throw new Error(
+      `Failed to load witness calculator: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
 }
 
 async function loadZkey(): Promise<Uint8Array> {
-  const url = new URL("./resources/rln_final.zkey", import.meta.url);
-  const response = await fetch(url);
-  return new Uint8Array(await response.arrayBuffer());
+  try {
+    const url = new URL("./resources/rln_final.zkey", import.meta.url);
+    const response = await fetch(url);
+
+    if (!response.ok) {
+      throw new Error(
+        `Failed to fetch zkey: ${response.status} ${response.statusText}`
+      );
+    }
+
+    return new Uint8Array(await response.arrayBuffer());
+  } catch (error) {
+    log.error("Error loading zkey:", error);
+    throw new Error(
+      `Failed to load zkey: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
 }
 
 /**
@@ -61,7 +93,7 @@ export async function create(): Promise<RLNInstance> {
 
     const DEPTH = 20;
     const zkRLN = zerokitRLN.newRLN(DEPTH, zkey, vkey);
-    const zerokit = new Zerokit(zkRLN, witnessCalculator);
+    const zerokit = new Zerokit(zkRLN, witnessCalculator, DEFAULT_RATE_LIMIT);
 
     return new RLNInstance(zerokit);
   } catch (error) {
@@ -142,7 +174,7 @@ export class RLNInstance {
       this._contract = await RLNContract.init(this, {
         address: address!,
         signer: signer!,
-        rateLimit: options.rateLimit
+        rateLimit: options.rateLimit ?? this.zerokit.getRateLimit
       });
       this.started = true;
     } finally {
@@ -214,15 +246,17 @@ export class RLNInstance {
       throw Error("RLN Contract is not initialized.");
     }
 
-    let identity: IdentityCredential | undefined =
-      "identity" in options ? options.identity : undefined;
+    let identity = "identity" in options && options.identity;
 
     if ("signature" in options) {
-      identity = IdentityCredential.generateSeeded(
-        ethers.utils.arrayify(options.signature)
+      identity = this.zerokit.generateSeededIdentityCredential(
+        options.signature
       );
     }
 
+    // eslint-disable-next-line no-console
+    console.log("registering membership", identity);
+
     if (!identity) {
       throw Error("Missing signature or identity to register membership.");
     }
@@ -272,7 +306,7 @@ export class RLNInstance {
     }
 
     const registryAddress = credentials.membership.address;
-    const currentRegistryAddress = this._contract.contract.address;
+    const currentRegistryAddress = this._contract.address;
     if (registryAddress !== currentRegistryAddress) {
       throw Error(
         `Failed to verify chain coordinates: credentials contract address=${registryAddress} is not equal to registryContract address=${currentRegistryAddress}`
@@ -280,7 +314,7 @@ export class RLNInstance {
     }
 
     const chainId = credentials.membership.chainId;
-    const network = await this._contract.contract.provider.getNetwork();
+    const network = await this._contract.provider.getNetwork();
     const currentChainId = network.chainId;
     if (chainId !== currentChainId) {
       throw Error(