@waku/rln 0.1.5-053bb95.0 → 0.1.5-197ba46.0

package/src/contract/rln_base_contract.ts

@@ -7,15 +7,8 @@ import { DecryptedCredentials } from "../keystore/types.js";
 import { RLN_ABI } from "./abi.js";
 import { DEFAULT_RATE_LIMIT, RATE_LIMIT_PARAMS } from "./constants.js";
 import {
-  InvalidMembershipError,
-  InvalidRateLimitError,
-  MembershipExistsError,
-  MembershipNotFoundError,
-  RateLimitExceededError,
-  RLNContractError,
-  TransactionError
-} from "./errors.js";
-import {
+  CustomQueryOptions,
+  FetchMembersOptions,
   Member,
   MembershipInfo,
   MembershipRegisteredEvent,
@@ -27,8 +20,18 @@ const log = new Logger("waku:rln:contract:base");
 
 export class RLNBaseContract {
   public contract: ethers.Contract;
+  private deployBlock: undefined | number;
   private rateLimit: number;
 
+  protected _members: Map<number, Member> = new Map();
+  private _membersFilter: ethers.EventFilter;
+  private _membershipErasedFilter: ethers.EventFilter;
+  private _membersExpiredFilter: ethers.EventFilter;
+
+  /**
+   * Constructor for RLNBaseContract.
+   * Allows injecting a mocked contract for testing purposes.
+   */
   public constructor(options: RLNContractInitOptions) {
     const {
       address,
@@ -37,9 +40,38 @@ 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;
+
+    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 });
+    });
   }
 
   /**
@@ -116,151 +148,302 @@ export class RLNBaseContract {
    * @param newRateLimit The new rate limit to use
    */
   public async setRateLimit(newRateLimit: number): Promise<void> {
-    this.validateRateLimit(newRateLimit);
+    await this.validateRateLimit(newRateLimit);
     this.rateLimit = newRateLimit;
   }
 
-  /**
-   * Gets all members in the given range
-   * @param startIndex Start index (inclusive)
-   * @param endIndex End index (exclusive)
-   */
-  public async getMembersInRange(
-    startIndex: number,
-    endIndex: number
-  ): Promise<Member[]> {
-    try {
-      // Get all commitments in one call
-      const idCommitments =
-        await this.contract.getRateCommitmentsInRangeBoundsInclusive(
-          startIndex,
-          endIndex - 1 // -1 because getRateCommitmentsInRangeBoundsInclusive is inclusive
-        );
+  public get members(): Member[] {
+    const sortedMembers = Array.from(this._members.values()).sort(
+      (left, right) => left.index.toNumber() - right.index.toNumber()
+    );
+    return sortedMembers;
+  }
 
-      // Get membership info for each commitment in a single batch
-      const membershipPromises = idCommitments.map(
-        (idCommitment: ethers.BigNumber) =>
-          this.contract
-            .memberships(idCommitment)
-            .then((info: { index: number | ethers.BigNumber }) => ({
-              idCommitment: idCommitment.toString(),
-              index: ethers.BigNumber.from(info.index)
-            }))
-            .catch(() => null) // Skip invalid members
-      );
+  public async fetchMembers(options: FetchMembersOptions = {}): Promise<void> {
+    const registeredMemberEvents = await RLNBaseContract.queryFilter(
+      this.contract,
+      {
+        fromBlock: this.deployBlock,
+        ...options,
+        membersFilter: this.membersFilter
+      }
+    );
+    const removedMemberEvents = await RLNBaseContract.queryFilter(
+      this.contract,
+      {
+        fromBlock: this.deployBlock,
+        ...options,
+        membersFilter: this.membershipErasedFilter
+      }
+    );
+    const expiredMemberEvents = await RLNBaseContract.queryFilter(
+      this.contract,
+      {
+        fromBlock: this.deployBlock,
+        ...options,
+        membersFilter: this.membersExpiredFilter
+      }
+    );
+
+    const events = [
+      ...registeredMemberEvents,
+      ...removedMemberEvents,
+      ...expiredMemberEvents
+    ];
+    this.processEvents(events);
+  }
+
+  public static async queryFilter(
+    contract: ethers.Contract,
+    options: CustomQueryOptions
+  ): Promise<ethers.Event[]> {
+    const FETCH_CHUNK = 5;
+    const BLOCK_RANGE = 3000;
+
+    const {
+      fromBlock,
+      membersFilter,
+      fetchRange = BLOCK_RANGE,
+      fetchChunks = FETCH_CHUNK
+    } = options;
+
+    if (fromBlock === undefined) {
+      return contract.queryFilter(membersFilter);
+    }
+
+    if (!contract.provider) {
+      throw Error("No provider found on the contract.");
+    }
+
+    const toBlock = await contract.provider.getBlockNumber();
+
+    if (toBlock - fromBlock < fetchRange) {
+      return contract.queryFilter(membersFilter, fromBlock, toBlock);
+    }
+
+    const events: ethers.Event[][] = [];
+    const chunks = RLNBaseContract.splitToChunks(
+      fromBlock,
+      toBlock,
+      fetchRange
+    );
 
-      // Wait for all promises to resolve
-      const members = (await Promise.all(membershipPromises)).filter(
-        (m): m is Member => m !== null
+    for (const portion of RLNBaseContract.takeN<[number, number]>(
+      chunks,
+      fetchChunks
+    )) {
+      const promises = portion.map(([left, right]) =>
+        RLNBaseContract.ignoreErrors(
+          contract.queryFilter(membersFilter, left, right),
+          []
+        )
       );
-      return members;
-    } catch (error) {
+      const fetchedEvents = await Promise.all(promises);
+      events.push(fetchedEvents.flatMap((v) => v));
+    }
+
+    return events.flatMap((v) => v);
+  }
+
+  public processEvents(events: ethers.Event[]): void {
+    const toRemoveTable = new Map<number, number[]>();
+    const toInsertTable = new Map<number, ethers.Event[]>();
+
+    events.forEach((evt) => {
+      if (!evt.args) {
+        return;
+      }
+
       if (
-        error instanceof Error &&
-        error.message.includes("InvalidPaginationQuery")
+        evt.event === "MembershipErased" ||
+        evt.event === "MembershipExpired"
       ) {
-        throw new RLNContractError(
-          `Invalid pagination range: start=${startIndex}, end=${endIndex}`
-        );
+        let index = evt.args.index;
+
+        if (!index) {
+          return;
+        }
+
+        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());
+          toRemoveTable.set(evt.blockNumber, toRemoveVal);
+        } else {
+          toRemoveTable.set(evt.blockNumber, [index.toNumber()]);
+        }
+      } else if (evt.event === "MembershipRegistered") {
+        let eventsPerBlock = toInsertTable.get(evt.blockNumber);
+        if (eventsPerBlock == undefined) {
+          eventsPerBlock = [];
+        }
+
+        eventsPerBlock.push(evt);
+        toInsertTable.set(evt.blockNumber, eventsPerBlock);
       }
-      throw error;
+    });
+  }
+
+  public static splitToChunks(
+    from: number,
+    to: number,
+    step: number
+  ): Array<[number, number]> {
+    const chunks: Array<[number, number]> = [];
+
+    let left = from;
+    while (left < to) {
+      const right = left + step < to ? left + step : to;
+
+      chunks.push([left, right] as [number, number]);
+
+      left = right;
     }
+
+    return chunks;
   }
 
-  /**
-   * Gets all current members
-   */
-  public async getAllMembers(): Promise<Member[]> {
-    const nextIndex = (await this.contract.nextFreeIndex()).toNumber();
-    return this.getMembersInRange(0, nextIndex);
+  public static *takeN<T>(array: T[], size: number): Iterable<T[]> {
+    let start = 0;
+
+    while (start < array.length) {
+      const portion = array.slice(start, start + size);
+
+      yield portion;
+
+      start += size;
+    }
   }
 
-  /**
-   * Gets the member index if it exists, or null if it doesn't
-   * Throws only on actual errors (invalid input, network issues, etc)
-   */
-  private async getMemberIndex(
-    idCommitment: string
-  ): Promise<ethers.BigNumber | null> {
+  public static async ignoreErrors<T>(
+    promise: Promise<T>,
+    defaultValue: T
+  ): Promise<T> {
     try {
-      const isValid = await this.contract.isInMembershipSet(idCommitment);
-      if (!isValid) {
-        return null;
+      return await promise;
+    } catch (err: unknown) {
+      if (err instanceof Error) {
+        log.info(`Ignoring an error during query: ${err.message}`);
+      } else {
+        log.info(`Ignoring an unknown error during query`);
       }
-
-      const membershipInfo = await this.contract.memberships(idCommitment);
-      return ethers.BigNumber.from(membershipInfo.index);
-    } catch (error) {
-      log.error(`Error getting member index: ${(error as Error).message}`);
-      throw new InvalidMembershipError(idCommitment);
+      return defaultValue;
     }
   }
 
+  public subscribeToMembers(): void {
+    this.contract.on(
+      this.membersFilter,
+      (
+        _idCommitment: bigint,
+        _membershipRateLimit: ethers.BigNumber,
+        _index: ethers.BigNumber,
+        event: ethers.Event
+      ) => {
+        this.processEvents([event]);
+      }
+    );
+
+    this.contract.on(
+      this.membershipErasedFilter,
+      (
+        _idCommitment: bigint,
+        _membershipRateLimit: ethers.BigNumber,
+        _index: ethers.BigNumber,
+        event: ethers.Event
+      ) => {
+        this.processEvents([event]);
+      }
+    );
+
+    this.contract.on(
+      this.membersExpiredFilter,
+      (
+        _idCommitment: bigint,
+        _membershipRateLimit: ethers.BigNumber,
+        _index: ethers.BigNumber,
+        event: ethers.Event
+      ) => {
+        this.processEvents([event]);
+      }
+    );
+  }
+
   public async getMembershipInfo(
-    idCommitment: string
-  ): Promise<MembershipInfo> {
+    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 === null) {
-        throw new MembershipNotFoundError(idCommitment);
-      }
-
       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) {
-      if (error instanceof RLNContractError) {
-        throw error;
-      }
-      log.error(`Error getting membership info: ${(error as Error).message}`);
-      throw new InvalidMembershipError(idCommitment);
+      log.error("Error in getMembershipInfo:", error);
+      return undefined;
     }
   }
 
-  public async extendMembership(idCommitment: string): Promise<void> {
-    const tx = await this.contract.extendMemberships([idCommitment]);
-    await this.confirmTransaction(tx, "MembershipExtended", (event) => ({
-      idCommitment: event.args!.idCommitment,
-      endBlock: event.args!.endBlock
-    }));
+  public async extendMembership(
+    idCommitmentBigInt: bigint
+  ): Promise<ethers.ContractTransaction> {
+    const tx = await this.contract.extendMemberships([idCommitmentBigInt]);
+    await tx.wait();
+    return tx;
   }
 
   public async eraseMembership(
-    idCommitment: string,
+    idCommitmentBigInt: bigint,
     eraseFromMembershipSet: boolean = true
-  ): Promise<void> {
-    const tx = await this.contract.eraseMemberships(
-      [idCommitment],
+  ): Promise<ethers.ContractTransaction> {
+    const tx = await this.contract.functions.eraseMemberships(
+      [idCommitmentBigInt],
       eraseFromMembershipSet
     );
-    await this.confirmTransaction(tx, "MembershipErased", (event) => ({
-      idCommitment: event.args!.idCommitment,
-      index: event.args!.index
-    }));
+    await tx.wait();
+    return tx;
   }
 
   public async registerMembership(
-    idCommitment: string,
+    idCommitmentBigInt: bigint,
     rateLimit: number = DEFAULT_RATE_LIMIT
-  ): Promise<void> {
+  ): Promise<ethers.ContractTransaction> {
     if (
       rateLimit < RATE_LIMIT_PARAMS.MIN_RATE ||
       rateLimit > RATE_LIMIT_PARAMS.MAX_RATE
@@ -269,25 +452,15 @@ export class RLNBaseContract {
         `Rate limit must be between ${RATE_LIMIT_PARAMS.MIN_RATE} and ${RATE_LIMIT_PARAMS.MAX_RATE}`
       );
     }
-    const tx = await this.contract.register(idCommitment, rateLimit, []);
-    await this.confirmTransaction(tx, "MembershipRegistered", (event) => ({
-      idCommitment: event.args!.idCommitment,
-      membershipRateLimit: event.args!.membershipRateLimit,
-      index: event.args!.index
-    }));
+    return this.contract.register(idCommitmentBigInt, rateLimit, []);
   }
 
-  public async withdraw(token: string, holder: string): Promise<void> {
+  public async withdraw(token: string, from: string): Promise<void> {
     try {
-      const tx = await this.contract.withdraw(token, { from: holder });
-      await this.confirmTransaction(tx, "TokenWithdrawn", (event) => ({
-        token: event.args!.token,
-        holder: event.args!.holder,
-        amount: event.args!.amount
-      }));
+      const tx = await this.contract.withdraw(token, from);
+      await tx.wait();
     } catch (error) {
       log.error(`Error in withdraw: ${(error as Error).message}`);
-      throw error;
     }
   }
 
@@ -301,20 +474,20 @@ export class RLNBaseContract {
 
       // Check if the ID commitment is already registered
       const existingIndex = await this.getMemberIndex(
-        identity.IDCommitmentBigInt.toString()
+        identity.IDCommitmentBigInt
       );
-
-      if (existingIndex !== null) {
-        throw new MembershipExistsError(
-          identity.IDCommitmentBigInt.toString(),
-          existingIndex.toString()
+      if (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) {
-        throw new RateLimitExceededError(this.rateLimit, remainingRateLimit);
+        throw new Error(
+          `Not enough remaining rate limit. Requested: ${this.rateLimit}, Available: ${remainingRateLimit}`
+        );
       }
 
       const estimatedGas = await this.contract.estimateGas.register(
@@ -324,23 +497,37 @@ export class RLNBaseContract {
       );
       const gasLimit = estimatedGas.add(10000);
 
-      const tx = await this.contract.register(
-        identity.IDCommitmentBigInt,
-        this.rateLimit,
-        [],
-        { gasLimit }
-      );
+      const txRegisterResponse: ethers.ContractTransaction =
+        await this.contract.register(
+          identity.IDCommitmentBigInt,
+          this.rateLimit,
+          [],
+          { gasLimit }
+        );
 
-      const decodedData = await this.confirmTransaction(
-        tx,
-        "MembershipRegistered",
-        (event): MembershipRegisteredEvent => ({
-          idCommitment: event.args!.idCommitment,
-          membershipRateLimit: event.args!.membershipRateLimit,
-          index: event.args!.index
-        })
+      const txRegisterReceipt = await txRegisterResponse.wait();
+
+      if (txRegisterReceipt.status === 0) {
+        throw new Error("Transaction failed on-chain");
+      }
+
+      const memberRegistered = txRegisterReceipt.events?.find(
+        (event: ethers.Event) => event.event === "MembershipRegistered"
       );
 
+      if (!memberRegistered || !memberRegistered.args) {
+        log.error(
+          "Failed to register membership: No MembershipRegistered event found"
+        );
+        return undefined;
+      }
+
+      const decodedData: MembershipRegisteredEvent = {
+        idCommitment: memberRegistered.args.idCommitment,
+        membershipRateLimit: memberRegistered.args.membershipRateLimit,
+        index: memberRegistered.args.index
+      };
+
       log.info(
         `Successfully registered membership with index ${decodedData.index} ` +
           `and rate limit ${decodedData.membershipRateLimit}`
@@ -348,55 +535,44 @@ export class RLNBaseContract {
 
       const network = await this.contract.provider.getNetwork();
       const address = this.contract.address;
-      const membershipId = decodedData.index.toString();
+      const membershipId = Number(decodedData.index);
 
       return {
         identity,
         membership: {
           address,
-          treeIndex: parseInt(membershipId),
+          treeIndex: membershipId,
           chainId: network.chainId.toString(),
           rateLimit: decodedData.membershipRateLimit.toNumber()
         }
       };
     } catch (error) {
-      if (error instanceof RLNContractError) {
-        throw error;
-      }
-
       if (error instanceof Error) {
         const errorMessage = error.message;
         log.error("registerWithIdentity - error message:", errorMessage);
         log.error("registerWithIdentity - error stack:", error.stack);
 
-        // Map contract errors to our custom errors
+        // Try to extract more specific error information
         if (errorMessage.includes("CannotExceedMaxTotalRateLimit")) {
-          throw new RateLimitExceededError(
-            this.rateLimit,
-            await this.getRemainingTotalRateLimit()
+          throw new Error(
+            "Registration failed: Cannot exceed maximum total rate limit"
           );
         } else if (errorMessage.includes("InvalidIdCommitment")) {
-          throw new InvalidMembershipError(
-            identity.IDCommitmentBigInt.toString()
-          );
+          throw new Error("Registration failed: Invalid ID commitment");
         } else if (errorMessage.includes("InvalidMembershipRateLimit")) {
-          throw new InvalidRateLimitError(
-            this.rateLimit,
-            RATE_LIMIT_PARAMS.MIN_RATE,
-            RATE_LIMIT_PARAMS.MAX_RATE
-          );
+          throw new Error("Registration failed: Invalid membership rate limit");
         } else if (errorMessage.includes("execution reverted")) {
-          throw new TransactionError(
+          throw new Error(
             "Contract execution reverted. Check contract requirements."
           );
+        } else {
+          throw new Error(`Error in registerWithIdentity: ${errorMessage}`);
         }
-
-        throw new RLNContractError(
-          `Error in registerWithIdentity: ${errorMessage}`
-        );
+      } else {
+        throw new Error("Unknown error in registerWithIdentity", {
+          cause: error
+        });
       }
-
-      throw new RLNContractError("Unknown error in registerWithIdentity");
     }
   }
 
@@ -416,27 +592,36 @@ export class RLNBaseContract {
         `Registering identity with permit and rate limit: ${this.rateLimit} messages/epoch`
       );
 
-      const tx = await this.contract.registerWithPermit(
-        permit.owner,
-        permit.deadline,
-        permit.v,
-        permit.r,
-        permit.s,
-        identity.IDCommitmentBigInt,
-        this.rateLimit,
-        idCommitmentsToErase.map((id) => ethers.BigNumber.from(id))
-      );
+      const txRegisterResponse: ethers.ContractTransaction =
+        await this.contract.registerWithPermit(
+          permit.owner,
+          permit.deadline,
+          permit.v,
+          permit.r,
+          permit.s,
+          identity.IDCommitmentBigInt,
+          this.rateLimit,
+          idCommitmentsToErase.map((id) => ethers.BigNumber.from(id))
+        );
+      const txRegisterReceipt = await txRegisterResponse.wait();
 
-      const decodedData = await this.confirmTransaction(
-        tx,
-        "MembershipRegistered",
-        (event): MembershipRegisteredEvent => ({
-          idCommitment: event.args!.idCommitment,
-          membershipRateLimit: event.args!.membershipRateLimit,
-          index: event.args!.index
-        })
+      const memberRegistered = txRegisterReceipt.events?.find(
+        (event: ethers.Event) => event.event === "MembershipRegistered"
       );
 
+      if (!memberRegistered || !memberRegistered.args) {
+        log.error(
+          "Failed to register membership with permit: No MembershipRegistered event found"
+        );
+        return undefined;
+      }
+
+      const decodedData: MembershipRegisteredEvent = {
+        idCommitment: memberRegistered.args.idCommitment,
+        membershipRateLimit: memberRegistered.args.membershipRateLimit,
+        index: memberRegistered.args.index
+      };
+
       log.info(
         `Successfully registered membership with permit. Index: ${decodedData.index}, ` +
           `Rate limit: ${decodedData.membershipRateLimit}, Erased ${idCommitmentsToErase.length} commitments`
@@ -444,13 +629,13 @@ export class RLNBaseContract {
 
       const network = await this.contract.provider.getNetwork();
       const address = this.contract.address;
-      const membershipId = decodedData.index.toString();
+      const membershipId = Number(decodedData.index);
 
       return {
         identity,
         membership: {
           address,
-          treeIndex: parseInt(membershipId),
+          treeIndex: membershipId,
           chainId: network.chainId.toString(),
           rateLimit: decodedData.membershipRateLimit.toNumber()
         }
@@ -459,7 +644,7 @@ export class RLNBaseContract {
       log.error(
         `Error in registerWithPermitAndErase: ${(error as Error).message}`
       );
-      throw error;
+      return undefined;
     }
   }
 
@@ -467,34 +652,57 @@ 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 validateRateLimit(rateLimit: number): void {
-    if (
-      rateLimit < RATE_LIMIT_PARAMS.MIN_RATE ||
-      rateLimit > RATE_LIMIT_PARAMS.MAX_RATE
-    ) {
-      throw new InvalidRateLimitError(
-        rateLimit,
-        RATE_LIMIT_PARAMS.MIN_RATE,
-        RATE_LIMIT_PARAMS.MAX_RATE
+  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) {
+      throw new Error(
+        `Rate limit must be between ${minRateNum} and ${maxRateNum} messages per epoch`
       );
     }
   }
 
-  /**
-   * Helper to confirm a transaction and extract event data
-   */
-  private async confirmTransaction<T>(
-    tx: ethers.ContractTransaction,
-    expectedEvent: string,
-    transform: (event: ethers.Event) => T
-  ): Promise<T> {
-    const receipt = await tx.wait();
-    const event = receipt.events?.find((e) => e.event === expectedEvent);
+  private get membersFilter(): ethers.EventFilter {
+    if (!this._membersFilter) {
+      throw Error("Members filter was not initialized.");
+    }
+    return this._membersFilter;
+  }
+
+  private get membershipErasedFilter(): ethers.EventFilter {
+    if (!this._membershipErasedFilter) {
+      throw Error("MembershipErased filter was not initialized.");
+    }
+    return this._membershipErasedFilter;
+  }
 
-    if (!event || !event.args) {
-      throw new TransactionError(`Expected event ${expectedEvent} not found`);
+  private get membersExpiredFilter(): ethers.EventFilter {
+    if (!this._membersExpiredFilter) {
+      throw Error("MembersExpired filter was not initialized.");
     }
+    return this._membersExpiredFilter;
+  }
 
-    return transform(event);
+  private async getMemberIndex(
+    idCommitmentBigInt: bigint
+  ): Promise<ethers.BigNumber | undefined> {
+    try {
+      const events = await this.contract.queryFilter(
+        this.contract.filters.MembershipRegistered(idCommitmentBigInt)
+      );
+      if (events.length === 0) return undefined;
+
+      // Get the most recent registration event
+      const event = events[events.length - 1];
+      return event.args?.index;
+    } catch (error) {
+      return undefined;
+    }
   }
 }