@waku/rln 0.1.5-fdaf129.0 → 0.1.5

package/src/contract/rln_base_contract.ts

@@ -1,4 +1,3 @@
-/* eslint-disable no-console */
 import { Logger } from "@waku/utils";
 import { ethers } from "ethers";
 
@@ -34,6 +33,15 @@ export class RLNBaseContract {
    * Allows injecting a mocked contract for testing purposes.
    */
   public constructor(options: RLNContractInitOptions) {
+    // Initialize members and subscriptions
+    this.fetchMembers()
+      .then(() => {
+        this.subscribeToMembers();
+      })
+      .catch((error) => {
+        log.error("Failed to initialize members", { error });
+      });
+
     const {
       address,
       signer,
@@ -41,38 +49,15 @@ export class RLNBaseContract {
       contract
     } = options;
 
-    log.info("Initializing RLNBaseContract", { address, rateLimit });
+    this.validateRateLimit(rateLimit);
 
     this.contract = contract || new ethers.Contract(address, RLN_ABI, signer);
     this.rateLimit = rateLimit;
 
-    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 });
-      });
-
-    // Validate rate limit asynchronously
-    this.validateRateLimit(rateLimit).catch((error) => {
-      log.error("Failed to validate initial rate limit", { error });
-    });
+    // Initialize event filters
+    this._membersFilter = this.contract.filters.MembershipRegistered();
+    this._membershipErasedFilter = this.contract.filters.MembershipErased();
+    this._membersExpiredFilter = this.contract.filters.MembershipExpired();
   }
 
   /**
@@ -149,7 +134,7 @@ export class RLNBaseContract {
    * @param newRateLimit The new rate limit to use
    */
   public async setRateLimit(newRateLimit: number): Promise<void> {
-    await this.validateRateLimit(newRateLimit);
+    this.validateRateLimit(newRateLimit);
     this.rateLimit = newRateLimit;
   }
 
@@ -339,7 +324,7 @@ export class RLNBaseContract {
     this.contract.on(
       this.membersFilter,
       (
-        _idCommitment: bigint,
+        _idCommitment: string,
         _membershipRateLimit: ethers.BigNumber,
         _index: ethers.BigNumber,
         event: ethers.Event
@@ -351,7 +336,7 @@ export class RLNBaseContract {
     this.contract.on(
       this.membershipErasedFilter,
       (
-        _idCommitment: bigint,
+        _idCommitment: string,
         _membershipRateLimit: ethers.BigNumber,
         _index: ethers.BigNumber,
         event: ethers.Event
@@ -363,7 +348,7 @@ export class RLNBaseContract {
     this.contract.on(
       this.membersExpiredFilter,
       (
-        _idCommitment: bigint,
+        _idCommitment: string,
         _membershipRateLimit: ethers.BigNumber,
         _index: ethers.BigNumber,
         event: ethers.Event
@@ -373,74 +358,94 @@ 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(
-    idCommitmentBigInt: bigint
+    idCommitment: string
   ): Promise<MembershipInfo | undefined> {
     try {
-      const membershipData =
-        await this.contract.memberships(idCommitmentBigInt);
+      const [startBlock, endBlock, rateLimit] =
+        await this.contract.getMembershipInfo(idCommitment);
       const currentBlock = await this.contract.provider.getBlockNumber();
-      console.log("membershipData", membershipData);
-
-      const [
-        depositAmount,
-        activeDuration,
-        gracePeriodStartTimestamp,
-        gracePeriodDuration,
-        rateLimit,
-        index,
-        holder,
-        token
-      ] = membershipData;
-
-      const gracePeriodEnd = gracePeriodStartTimestamp.add(gracePeriodDuration);
 
       let state: MembershipState;
-      if (currentBlock < gracePeriodStartTimestamp.toNumber()) {
+      if (currentBlock < startBlock) {
         state = MembershipState.Active;
-      } else if (currentBlock < gracePeriodEnd.toNumber()) {
+      } else if (currentBlock < endBlock) {
         state = MembershipState.GracePeriod;
       } else {
         state = MembershipState.Expired;
       }
 
+      const index = await this.getMemberIndex(idCommitment);
+      if (!index) return undefined;
+
       return {
         index,
-        idCommitment: idCommitmentBigInt.toString(),
-        rateLimit: Number(rateLimit),
-        startBlock: gracePeriodStartTimestamp.toNumber(),
-        endBlock: gracePeriodEnd.toNumber(),
-        state,
-        depositAmount,
-        activeDuration,
-        gracePeriodDuration,
-        holder,
-        token
+        idCommitment,
+        rateLimit: rateLimit.toNumber(),
+        startBlock: startBlock.toNumber(),
+        endBlock: endBlock.toNumber(),
+        state
       };
     } catch (error) {
-      console.error("Error in getMembershipInfo:", error);
       return undefined;
     }
   }
 
   public async extendMembership(
-    idCommitmentBigInt: bigint
+    idCommitment: string
   ): Promise<ethers.ContractTransaction> {
-    return this.contract.extendMemberships([idCommitmentBigInt]);
+    return this.contract.extendMemberships([idCommitment]);
   }
 
   public async eraseMembership(
-    idCommitmentBigInt: bigint,
+    idCommitment: string,
     eraseFromMembershipSet: boolean = true
   ): Promise<ethers.ContractTransaction> {
     return this.contract.eraseMemberships(
-      [idCommitmentBigInt],
+      [idCommitment],
       eraseFromMembershipSet
     );
   }
 
   public async registerMembership(
-    idCommitmentBigInt: bigint,
+    idCommitment: string,
     rateLimit: number = DEFAULT_RATE_LIMIT
   ): Promise<ethers.ContractTransaction> {
     if (
@@ -451,12 +456,12 @@ export class RLNBaseContract {
         `Rate limit must be between ${RATE_LIMIT_PARAMS.MIN_RATE} and ${RATE_LIMIT_PARAMS.MAX_RATE}`
       );
     }
-    return this.contract.register(idCommitmentBigInt, rateLimit, []);
+    return this.contract.register(idCommitment, rateLimit, []);
   }
 
-  public async withdraw(token: string, from: string): Promise<void> {
+  public async withdraw(token: string, holder: string): Promise<void> {
     try {
-      const tx = await this.contract.withdraw(token, from);
+      const tx = await this.contract.withdraw(token, { from: holder });
       await tx.wait();
     } catch (error) {
       log.error(`Error in withdraw: ${(error as Error).message}`);
@@ -473,7 +478,7 @@ export class RLNBaseContract {
 
       // Check if the ID commitment is already registered
       const existingIndex = await this.getMemberIndex(
-        identity.IDCommitmentBigInt
+        identity.IDCommitmentBigInt.toString()
       );
       if (existingIndex) {
         throw new Error(
@@ -651,18 +656,13 @@ export class RLNBaseContract {
    * Validates that the rate limit is within the allowed range
    * @throws Error if the rate limit is outside the allowed range
    */
-  private async validateRateLimit(rateLimit: number): Promise<void> {
-    const [minRate, maxRate] = await Promise.all([
-      this.contract.minMembershipRateLimit(),
-      this.contract.maxMembershipRateLimit()
-    ]);
-
-    const minRateNum = ethers.BigNumber.from(minRate).toNumber();
-    const maxRateNum = ethers.BigNumber.from(maxRate).toNumber();
-
-    if (rateLimit < minRateNum || rateLimit > maxRateNum) {
+  private validateRateLimit(rateLimit: number): void {
+    if (
+      rateLimit < RATE_LIMIT_PARAMS.MIN_RATE ||
+      rateLimit > RATE_LIMIT_PARAMS.MAX_RATE
+    ) {
       throw new Error(
-        `Rate limit must be between ${minRateNum} and ${maxRateNum} messages per epoch`
+        `Rate limit must be between ${RATE_LIMIT_PARAMS.MIN_RATE} and ${RATE_LIMIT_PARAMS.MAX_RATE} messages per epoch`
       );
     }
   }
@@ -689,11 +689,11 @@ export class RLNBaseContract {
   }
 
   private async getMemberIndex(
-    idCommitmentBigInt: bigint
+    idCommitment: string
   ): Promise<ethers.BigNumber | undefined> {
     try {
       const events = await this.contract.queryFilter(
-        this.contract.filters.MembershipRegistered(idCommitmentBigInt)
+        this.contract.filters.MembershipRegistered(idCommitment)
       );
       if (events.length === 0) return undefined;
 

package/src/contract/types.ts

@@ -38,11 +38,6 @@ 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/index.ts

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

package/src/keystore/keystore.ts

@@ -21,8 +21,8 @@ import { isCredentialValid, isKeystoreValid } from "./schema_validator.js";
 import type {
   Keccak256Hash,
   KeystoreEntity,
-  KeystoreMembershipInfo,
   MembershipHash,
+  MembershipInfo,
   Password,
   Sha256Hash
 } from "./types.js";
@@ -310,9 +310,7 @@ export class Keystore {
 
   // follows nwaku implementation
   // https://github.com/waku-org/nwaku/blob/f05528d4be3d3c876a8b07f9bb7dfaae8aa8ec6e/waku/waku_keystore/protocol_types.nim#L111
-  private static computeMembershipHash(
-    info: KeystoreMembershipInfo
-  ): MembershipHash {
+  private static computeMembershipHash(info: MembershipInfo): MembershipHash {
     return bytesToHex(
       sha256(utf8ToBytes(`${info.chainId}${info.address}${info.treeIndex}`))
     ).toUpperCase();

package/src/keystore/types.ts

@@ -7,7 +7,7 @@ export type Password = string | Uint8Array;
 
 // see reference
 // https://github.com/waku-org/nwaku/blob/f05528d4be3d3c876a8b07f9bb7dfaae8aa8ec6e/waku/waku_keystore/protocol_types.nim#L111
-export type KeystoreMembershipInfo = {
+export type MembershipInfo = {
   chainId: string;
   address: string;
   treeIndex: number;
@@ -16,7 +16,7 @@ export type KeystoreMembershipInfo = {
 
 export type KeystoreEntity = {
   identity: IdentityCredential;
-  membership: KeystoreMembershipInfo;
+  membership: MembershipInfo;
 };
 
 export type DecryptedCredentials = KeystoreEntity;