@waku/rln 0.1.6-006cd41.0 → 0.1.6-0877e51.0

package/src/contract/rln_base_contract.ts

@@ -22,6 +22,8 @@ export class RLNBaseContract {
   public contract: ethers.Contract;
   private deployBlock: undefined | number;
   private rateLimit: number;
+  private minRateLimit?: number;
+  private maxRateLimit?: number;
 
   protected _members: Map<number, Member> = new Map();
   private _membersFilter: ethers.EventFilter;
@@ -29,19 +31,9 @@ export class RLNBaseContract {
   private _membersExpiredFilter: ethers.EventFilter;
 
   /**
-   * Constructor for RLNBaseContract.
-   * Allows injecting a mocked contract for testing purposes.
+   * Private constructor for RLNBaseContract. Use static create() instead.
    */
-  public constructor(options: RLNContractInitOptions) {
-    // Initialize members and subscriptions
-    this.fetchMembers()
-      .then(() => {
-        this.subscribeToMembers();
-      })
-      .catch((error) => {
-        log.error("Failed to initialize members", { error });
-      });
-
+  protected constructor(options: RLNContractInitOptions) {
     const {
       address,
       signer,
@@ -49,15 +41,52 @@ export class RLNBaseContract {
       contract
     } = options;
 
-    this.validateRateLimit(rateLimit);
+    log.info("Initializing RLNBaseContract", { address, rateLimit });
 
     this.contract = contract || new ethers.Contract(address, RLN_ABI, signer);
     this.rateLimit = rateLimit;
 
-    // Initialize event filters
-    this._membersFilter = this.contract.filters.MembershipRegistered();
-    this._membershipErasedFilter = this.contract.filters.MembershipErased();
-    this._membersExpiredFilter = this.contract.filters.MembershipExpired();
+    try {
+      log.info("Setting up event filters");
+      // Initialize event filters
+      this._membersFilter = this.contract.filters.MembershipRegistered();
+      this._membershipErasedFilter = this.contract.filters.MembershipErased();
+      this._membersExpiredFilter = this.contract.filters.MembershipExpired();
+      log.info("Event filters initialized successfully");
+    } catch (error) {
+      log.error("Failed to initialize event filters", { error });
+      throw new Error(
+        "Failed to initialize event filters: " + (error as Error).message
+      );
+    }
+
+    // Initialize members and subscriptions
+    this.fetchMembers()
+      .then(() => {
+        this.subscribeToMembers();
+      })
+      .catch((error) => {
+        log.error("Failed to initialize members", { error });
+      });
+  }
+
+  /**
+   * Static async factory to create and initialize RLNBaseContract
+   */
+  public static async create(
+    options: RLNContractInitOptions
+  ): Promise<RLNBaseContract> {
+    const instance = new RLNBaseContract(options);
+    const [min, max] = await Promise.all([
+      instance.contract.minMembershipRateLimit(),
+      instance.contract.maxMembershipRateLimit(),
+      instance.contract.Q()
+    ]);
+    instance.minRateLimit = ethers.BigNumber.from(min).toNumber();
+    instance.maxRateLimit = ethers.BigNumber.from(max).toNumber();
+
+    instance.validateRateLimit(instance.rateLimit);
+    return instance;
   }
 
   /**
@@ -82,21 +111,21 @@ export class RLNBaseContract {
   }
 
   /**
-   * Gets the minimum allowed rate limit from the contract
-   * @returns Promise<number> The minimum rate limit in messages per epoch
+   * Gets the minimum allowed rate limit (cached)
    */
-  public async getMinRateLimit(): Promise<number> {
-    const minRate = await this.contract.minMembershipRateLimit();
-    return ethers.BigNumber.from(minRate).toNumber();
+  public getMinRateLimit(): number {
+    if (this.minRateLimit === undefined)
+      throw new Error("minRateLimit not initialized");
+    return this.minRateLimit;
   }
 
   /**
-   * Gets the maximum allowed rate limit from the contract
-   * @returns Promise<number> The maximum rate limit in messages per epoch
+   * Gets the maximum allowed rate limit (cached)
    */
-  public async getMaxRateLimit(): Promise<number> {
-    const maxRate = await this.contract.maxMembershipRateLimit();
-    return ethers.BigNumber.from(maxRate).toNumber();
+  public getMaxRateLimit(): number {
+    if (this.maxRateLimit === undefined)
+      throw new Error("maxRateLimit not initialized");
+    return this.maxRateLimit;
   }
 
   /**
@@ -133,7 +162,7 @@ export class RLNBaseContract {
    * Updates the rate limit for future registrations
    * @param newRateLimit The new rate limit to use
    */
-  public async setRateLimit(newRateLimit: number): Promise<void> {
+  public setRateLimit(newRateLimit: number): void {
     this.validateRateLimit(newRateLimit);
     this.rateLimit = newRateLimit;
   }
@@ -324,7 +353,7 @@ export class RLNBaseContract {
     this.contract.on(
       this.membersFilter,
       (
-        _idCommitment: string,
+        _idCommitment: bigint,
         _membershipRateLimit: ethers.BigNumber,
         _index: ethers.BigNumber,
         event: ethers.Event
@@ -336,7 +365,7 @@ export class RLNBaseContract {
     this.contract.on(
       this.membershipErasedFilter,
       (
-        _idCommitment: string,
+        _idCommitment: bigint,
         _membershipRateLimit: ethers.BigNumber,
         _index: ethers.BigNumber,
         event: ethers.Event
@@ -348,7 +377,7 @@ export class RLNBaseContract {
     this.contract.on(
       this.membersExpiredFilter,
       (
-        _idCommitment: string,
+        _idCommitment: bigint,
         _membershipRateLimit: ethers.BigNumber,
         _index: ethers.BigNumber,
         event: ethers.Event
@@ -358,94 +387,89 @@ export class RLNBaseContract {
     );
   }
 
-  /**
-   * Helper method to get remaining messages in current epoch
-   * @param membershipId The ID of the membership to check
-   * @returns number of remaining messages allowed in current epoch
-   */
-  public async getRemainingMessages(membershipId: number): Promise<number> {
-    try {
-      const [startTime, , rateLimit] =
-        await this.contract.getMembershipInfo(membershipId);
-
-      // Calculate current epoch
-      const currentTime = Math.floor(Date.now() / 1000);
-      const epochsPassed = Math.floor(
-        (currentTime - startTime) / RATE_LIMIT_PARAMS.EPOCH_LENGTH
-      );
-      const currentEpochStart =
-        startTime + epochsPassed * RATE_LIMIT_PARAMS.EPOCH_LENGTH;
-
-      // Get message count in current epoch using contract's function
-      const messageCount = await this.contract.getMessageCount(
-        membershipId,
-        currentEpochStart
-      );
-      return Math.max(
-        0,
-        ethers.BigNumber.from(rateLimit)
-          .sub(ethers.BigNumber.from(messageCount))
-          .toNumber()
-      );
-    } catch (error) {
-      log.error(
-        `Error getting remaining messages: ${(error as Error).message}`
-      );
-      return 0; // Fail safe: assume no messages remaining on error
-    }
-  }
-
   public async getMembershipInfo(
-    idCommitment: string
+    idCommitmentBigInt: bigint
   ): Promise<MembershipInfo | undefined> {
     try {
-      const [startBlock, endBlock, rateLimit] =
-        await this.contract.getMembershipInfo(idCommitment);
+      const membershipData =
+        await this.contract.memberships(idCommitmentBigInt);
       const currentBlock = await this.contract.provider.getBlockNumber();
+      const [
+        depositAmount,
+        activeDuration,
+        gracePeriodStartTimestamp,
+        gracePeriodDuration,
+        rateLimit,
+        index,
+        holder,
+        token
+      ] = membershipData;
+
+      const gracePeriodEnd = gracePeriodStartTimestamp.add(gracePeriodDuration);
 
       let state: MembershipState;
-      if (currentBlock < startBlock) {
+      if (currentBlock < gracePeriodStartTimestamp.toNumber()) {
         state = MembershipState.Active;
-      } else if (currentBlock < endBlock) {
+      } else if (currentBlock < gracePeriodEnd.toNumber()) {
         state = MembershipState.GracePeriod;
       } else {
         state = MembershipState.Expired;
       }
 
-      const index = await this.getMemberIndex(idCommitment);
-      if (!index) return undefined;
-
       return {
         index,
-        idCommitment,
-        rateLimit: rateLimit.toNumber(),
-        startBlock: startBlock.toNumber(),
-        endBlock: endBlock.toNumber(),
-        state
+        idCommitment: idCommitmentBigInt.toString(),
+        rateLimit: Number(rateLimit),
+        startBlock: gracePeriodStartTimestamp.toNumber(),
+        endBlock: gracePeriodEnd.toNumber(),
+        state,
+        depositAmount,
+        activeDuration,
+        gracePeriodDuration,
+        holder,
+        token
       };
     } catch (error) {
+      log.error("Error in getMembershipInfo:", error);
       return undefined;
     }
   }
 
   public async extendMembership(
-    idCommitment: string
+    idCommitmentBigInt: bigint
   ): Promise<ethers.ContractTransaction> {
-    return this.contract.extendMemberships([idCommitment]);
+    const tx = await this.contract.extendMemberships([idCommitmentBigInt]);
+    await tx.wait();
+    return tx;
   }
 
   public async eraseMembership(
-    idCommitment: string,
+    idCommitmentBigInt: bigint,
     eraseFromMembershipSet: boolean = true
   ): Promise<ethers.ContractTransaction> {
-    return this.contract.eraseMemberships(
-      [idCommitment],
-      eraseFromMembershipSet
+    if (
+      !(await this.isExpired(idCommitmentBigInt)) ||
+      !(await this.isInGracePeriod(idCommitmentBigInt))
+    ) {
+      throw new Error("Membership is not expired or in grace period");
+    }
+
+    const estimatedGas = await this.contract.estimateGas[
+      "eraseMemberships(uint256[],bool)"
+    ]([idCommitmentBigInt], eraseFromMembershipSet);
+    const gasLimit = estimatedGas.add(10000);
+
+    const tx = await this.contract["eraseMemberships(uint256[],bool)"](
+      [idCommitmentBigInt],
+      eraseFromMembershipSet,
+      { gasLimit }
     );
+    await tx.wait();
+    return tx;
   }
 
   public async registerMembership(
-    idCommitment: string,
+    idCommitmentBigInt: bigint,
     rateLimit: number = DEFAULT_RATE_LIMIT
   ): Promise<ethers.ContractTransaction> {
     if (
@@ -456,18 +480,17 @@ export class RLNBaseContract {
         `Rate limit must be between ${RATE_LIMIT_PARAMS.MIN_RATE} and ${RATE_LIMIT_PARAMS.MAX_RATE}`
       );
     }
-    return this.contract.register(idCommitment, rateLimit, []);
+    return this.contract.register(idCommitmentBigInt, rateLimit, []);
   }
 
-  public async withdraw(token: string, holder: string): Promise<void> {
+  public async withdraw(token: string, walletAddress: string): Promise<void> {
     try {
-      const tx = await this.contract.withdraw(token, { from: holder });
+      const tx = await this.contract.withdraw(token, walletAddress);
       await tx.wait();
     } catch (error) {
       log.error(`Error in withdraw: ${(error as Error).message}`);
     }
   }
-
   public async registerWithIdentity(
     identity: IdentityCredential
   ): Promise<DecryptedCredentials | undefined> {
@@ -476,10 +499,12 @@ export class RLNBaseContract {
         `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()
+      const idCommitmentBigInt = IdentityCredential.getIdCommitmentBigInt(
+        identity.IDCommitment
       );
+
+      // Check if the ID commitment is already registered
+      const existingIndex = await this.getMemberIndex(idCommitmentBigInt);
       if (existingIndex) {
         throw new Error(
           `ID commitment is already registered with index ${existingIndex}`
@@ -495,19 +520,16 @@ export class RLNBaseContract {
       }
 
       const estimatedGas = await this.contract.estimateGas.register(
-        identity.IDCommitmentBigInt,
+        idCommitmentBigInt,
         this.rateLimit,
         []
       );
       const gasLimit = estimatedGas.add(10000);
 
       const txRegisterResponse: ethers.ContractTransaction =
-        await this.contract.register(
-          identity.IDCommitmentBigInt,
-          this.rateLimit,
-          [],
-          { gasLimit }
-        );
+        await this.contract.register(idCommitmentBigInt, this.rateLimit, [], {
+          gasLimit
+        });
 
       const txRegisterReceipt = await txRegisterResponse.wait();
 
@@ -516,7 +538,7 @@ export class RLNBaseContract {
       }
 
       const memberRegistered = txRegisterReceipt.events?.find(
-        (event) => event.event === "MembershipRegistered"
+        (event: ethers.Event) => event.event === "MembershipRegistered"
       );
 
       if (!memberRegistered || !memberRegistered.args) {
@@ -603,14 +625,14 @@ export class RLNBaseContract {
           permit.v,
           permit.r,
           permit.s,
-          identity.IDCommitmentBigInt,
+          IdentityCredential.getIdCommitmentBigInt(identity.IDCommitment),
           this.rateLimit,
           idCommitmentsToErase.map((id) => ethers.BigNumber.from(id))
         );
       const txRegisterReceipt = await txRegisterResponse.wait();
 
       const memberRegistered = txRegisterReceipt.events?.find(
-        (event) => event.event === "MembershipRegistered"
+        (event: ethers.Event) => event.event === "MembershipRegistered"
       );
 
       if (!memberRegistered || !memberRegistered.args) {
@@ -653,16 +675,16 @@ export class RLNBaseContract {
   }
 
   /**
-   * Validates that the rate limit is within the allowed range
+   * Validates that the rate limit is within the allowed range (sync)
    * @throws Error if the rate limit is outside the allowed range
    */
   private validateRateLimit(rateLimit: number): void {
-    if (
-      rateLimit < RATE_LIMIT_PARAMS.MIN_RATE ||
-      rateLimit > RATE_LIMIT_PARAMS.MAX_RATE
-    ) {
+    if (this.minRateLimit === undefined || this.maxRateLimit === undefined) {
+      throw new Error("Rate limits not initialized");
+    }
+    if (rateLimit < this.minRateLimit || rateLimit > this.maxRateLimit) {
       throw new Error(
-        `Rate limit must be between ${RATE_LIMIT_PARAMS.MIN_RATE} and ${RATE_LIMIT_PARAMS.MAX_RATE} messages per epoch`
+        `Rate limit must be between ${this.minRateLimit} and ${this.maxRateLimit} messages per epoch`
       );
     }
   }
@@ -689,11 +711,11 @@ export class RLNBaseContract {
   }
 
   private async getMemberIndex(
-    idCommitment: string
+    idCommitmentBigInt: bigint
   ): Promise<ethers.BigNumber | undefined> {
     try {
       const events = await this.contract.queryFilter(
-        this.contract.filters.MembershipRegistered(idCommitment)
+        this.contract.filters.MembershipRegistered(idCommitmentBigInt)
       );
       if (events.length === 0) return undefined;
 
@@ -704,4 +726,45 @@ export class RLNBaseContract {
       return undefined;
     }
   }
+
+  public async getMembershipStatus(
+    idCommitment: bigint
+  ): Promise<"expired" | "grace" | "active"> {
+    const [isExpired, isInGrace] = await Promise.all([
+      this.contract.isExpired(idCommitment),
+      this.contract.isInGracePeriod(idCommitment)
+    ]);
+
+    if (isExpired) return "expired";
+    if (isInGrace) return "grace";
+    return "active";
+  }
+
+  /**
+   * Checks if a membership is expired for the given idCommitment
+   * @param idCommitmentBigInt The idCommitment as bigint
+   * @returns Promise<boolean> True if expired, false otherwise
+   */
+  public async isExpired(idCommitmentBigInt: bigint): Promise<boolean> {
+    try {
+      return await this.contract.isExpired(idCommitmentBigInt);
+    } catch (error) {
+      log.error("Error in isExpired:", error);
+      return false;
+    }
+  }
+
+  /**
+   * Checks if a membership is in grace period for the given idCommitment
+   * @param idCommitmentBigInt The idCommitment as bigint
+   * @returns Promise<boolean> True if in grace period, false otherwise
+   */
+  public async isInGracePeriod(idCommitmentBigInt: bigint): Promise<boolean> {
+    try {
+      return await this.contract.isInGracePeriod(idCommitmentBigInt);
+    } catch (error) {
+      log.error("Error in isInGracePeriod:", error);
+      return false;
+    }
+  }
 }

package/src/contract/types.ts

@@ -38,6 +38,11 @@ export interface MembershipInfo {
   startBlock: number;
   endBlock: number;
   state: MembershipState;
+  depositAmount: ethers.BigNumber;
+  activeDuration: number;
+  gracePeriodDuration: number;
+  holder: string;
+  token: string;
 }
 
 export enum MembershipState {

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";
 
@@ -13,10 +13,7 @@ import type {
 } from "./keystore/index.js";
 import { KeystoreEntity, Password } from "./keystore/types.js";
 import { RegisterMembershipOptions, StartRLNOptions } from "./types.js";
-import {
-  buildBigIntFromUint8Array,
-  extractMetaMaskSigner
-} from "./utils/index.js";
+import { extractMetaMaskSigner, switchEndianness } from "./utils/index.js";
 import { Zerokit } from "./zerokit.js";
 
 const log = new Logger("waku:credentials");
@@ -80,7 +77,7 @@ export class RLNCredentialsManager {
 
       this.credentials = credentials;
       this.signer = signer!;
-      this.contract = new RLNBaseContract({
+      this.contract = await RLNBaseContract.create({
         address: address!,
         signer: signer!,
         rateLimit: rateLimit ?? this.zerokit?.rateLimit
@@ -116,7 +113,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 +248,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();
@@ -257,26 +258,31 @@ export class RLNCredentialsManager {
 
     // Generate deterministic values using HMAC-SHA256
     // We use different context strings for each component to ensure they're different
-    const idTrapdoor = hmac(sha256, seedBytes, encoder.encode("IDTrapdoor"));
-    const idNullifier = hmac(sha256, seedBytes, encoder.encode("IDNullifier"));
+    const idTrapdoorBE = hmac(sha256, seedBytes, encoder.encode("IDTrapdoor"));
+    const idNullifierBE = 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);
+    const combinedBytes = new Uint8Array([...idTrapdoorBE, ...idNullifierBE]);
+    const idSecretHashBE = sha256(combinedBytes);
 
-    // Generate IDCommitment as a hash of IDSecretHash
-    const idCommitment = sha256(idSecretHash);
+    const idCommitmentBE = sha256(idSecretHashBE);
 
-    // Convert IDCommitment to BigInt
-    const idCommitmentBigInt = buildBigIntFromUint8Array(idCommitment);
+    // All hashing functions return big-endian bytes
+    // We need to switch to little-endian for the identity credential
+    const idTrapdoorLE = switchEndianness(idTrapdoorBE);
+    const idNullifierLE = switchEndianness(idNullifierBE);
+    const idSecretHashLE = switchEndianness(idSecretHashBE);
+    const idCommitmentLE = switchEndianness(idCommitmentBE);
 
     log.info("Successfully generated identity credential");
     return new IdentityCredential(
-      idTrapdoor,
-      idNullifier,
-      idSecretHash,
-      idCommitment,
-      idCommitmentBigInt
+      idTrapdoorLE,
+      idNullifierLE,
+      idSecretHashLE,
+      idCommitmentLE
     );
   }
 }

package/src/identity.ts

@@ -1,12 +1,19 @@
-import { buildBigIntFromUint8Array } from "./utils/index.js";
+import { Logger } from "@waku/utils";
+
+import { DEFAULT_Q } from "./contract/constants.js";
+import { buildBigIntFromUint8ArrayBE } from "./utils/bytes.js";
+
+const log = new Logger("waku:rln:identity");
 
 export class IdentityCredential {
+  /**
+   * All variables are in little-endian format
+   */
   public constructor(
     public readonly IDTrapdoor: Uint8Array,
     public readonly IDNullifier: Uint8Array,
     public readonly IDSecretHash: Uint8Array,
-    public readonly IDCommitment: Uint8Array,
-    public readonly IDCommitmentBigInt: bigint
+    public readonly IDCommitment: Uint8Array
   ) {}
 
   public static fromBytes(memKeys: Uint8Array): IdentityCredential {
@@ -18,14 +25,33 @@ 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, 32);
 
     return new IdentityCredential(
       idTrapdoor,
       idNullifier,
       idSecretHash,
-      idCommitment,
-      idCommitmentBigInt
+      idCommitment
     );
   }
+
+  /**
+   * Converts an ID commitment from bytes to a BigInt, normalizing it against a limit if needed
+   * @param bytes The ID commitment bytes to convert
+   * @param limit Optional limit to normalize against (Q value)
+   * @returns The ID commitment as a BigInt
+   */
+  public static getIdCommitmentBigInt(
+    idCommitment: Uint8Array,
+    limit: bigint = DEFAULT_Q
+  ): bigint {
+    let idCommitmentBigIntBE = buildBigIntFromUint8ArrayBE(idCommitment);
+
+    if (limit && idCommitmentBigIntBE >= limit) {
+      log.warn(
+        `ID commitment is greater than Q, reducing it by Q: ${idCommitmentBigIntBE} % ${limit}`
+      );
+      idCommitmentBigIntBE = idCommitmentBigIntBE % limit;
+    }
+    return idCommitmentBigIntBE;
+  }
 }

package/src/index.ts

@@ -34,7 +34,9 @@ export type {
   Keccak256Hash,
   KeystoreEntity,
   MembershipHash,
-  MembershipInfo,
+  KeystoreMembershipInfo,
   Password,
   Sha256Hash
 } from "./keystore/types.js";
+
+export * from "./contract/index.js";