chore: switch to composition instead of inheritance

Author: danisharora099

packages/rln/src/contract/rln_contract.ts

@@ -11,9 +11,14 @@ import { RLNContractInitOptions } from "./types.js";
 
 const log = new Logger("waku:rln:contract");
 
-export class RLNContract extends RLNBaseContract {
+export class RLNContract {
   private instance: RLNInstance;
   private merkleRootTracker: MerkleRootTracker;
+  private base: RLNBaseContract;
+  private _members: Map<
+    number,
+    { index: ethers.BigNumber; idCommitment: string }
+  >;
 
   /**
    * Asynchronous initializer for RLNContract.
@@ -23,24 +28,121 @@ export class RLNContract extends RLNBaseContract {
     rlnInstance: RLNInstance,
     options: RLNContractInitOptions
   ): Promise<RLNContract> {
-    const rlnContract = new RLNContract(rlnInstance, options);
-
+    const base = await RLNBaseContract.create(options);
+    const rlnContract = new RLNContract(rlnInstance, base);
     return rlnContract;
   }
 
-  private constructor(
-    rlnInstance: RLNInstance,
-    options: RLNContractInitOptions
-  ) {
-    super(options);
-
+  private constructor(rlnInstance: RLNInstance, base: RLNBaseContract) {
     this.instance = rlnInstance;
-
+    this.base = base;
+    this._members = new Map();
     const initialRoot = rlnInstance.zerokit.getMerkleRoot();
     this.merkleRootTracker = new MerkleRootTracker(5, initialRoot);
+    this.base.contract.on("MembershipRegistered", (...args) => {
+      const event = args[args.length - 1];
+      this.processEvents([event]);
+    });
+    this.base.contract.on("MembershipErased", (...args) => {
+      const event = args[args.length - 1];
+      this.processEvents([event]);
+    });
+    this.base.contract.on("MembershipExpired", (...args) => {
+      const event = args[args.length - 1];
+      this.processEvents([event]);
+    });
+  }
+
+  public get contract(): ethers.Contract {
+    return this.base.contract;
+  }
+  public get members(): { index: ethers.BigNumber; idCommitment: string }[] {
+    return Array.from(this._members.values());
+  }
+  public get address(): string {
+    return this.base.address;
+  }
+  public get provider(): ethers.providers.Provider {
+    return this.base.provider;
+  }
+  public getRateLimit(): number {
+    return this.base.getRateLimit();
+  }
+  public getMinRateLimit(): number {
+    return this.base.getMinRateLimit();
+  }
+  public getMaxRateLimit(): number {
+    return this.base.getMaxRateLimit();
+  }
+  public async getMaxTotalRateLimit(): Promise<number> {
+    return this.base.getMaxTotalRateLimit();
+  }
+  public async getCurrentTotalRateLimit(): Promise<number> {
+    return this.base.getCurrentTotalRateLimit();
+  }
+  public async getRemainingTotalRateLimit(): Promise<number> {
+    return this.base.getRemainingTotalRateLimit();
+  }
+  public setRateLimit(newRateLimit: number): void {
+    this.base.setRateLimit(newRateLimit);
+  }
+  public async fetchMembers(options = {}): Promise<void> {
+    await this.base.fetchMembers(options);
+  }
+  public async getMembershipInfo(idCommitmentBigInt: bigint): Promise<any> {
+    return this.base.getMembershipInfo(idCommitmentBigInt);
+  }
+  public async extendMembership(
+    idCommitmentBigInt: bigint
+  ): Promise<ethers.ContractTransaction> {
+    return this.base.extendMembership(idCommitmentBigInt);
+  }
+  public async eraseMembership(
+    idCommitmentBigInt: bigint,
+    eraseFromMembershipSet = true
+  ): Promise<ethers.ContractTransaction> {
+    return this.base.eraseMembership(
+      idCommitmentBigInt,
+      eraseFromMembershipSet
+    );
+  }
+  public async registerMembership(
+    idCommitmentBigInt: bigint,
+    rateLimit: number
+  ): Promise<ethers.ContractTransaction> {
+    return this.base.registerMembership(idCommitmentBigInt, rateLimit);
+  }
+  public async withdraw(token: string, walletAddress: string): Promise<void> {
+    return this.base.withdraw(token, walletAddress);
+  }
+  public async registerWithIdentity(identity: any): Promise<any> {
+    return this.base.registerWithIdentity(identity);
+  }
+  public async registerWithPermitAndErase(
+    identity: any,
+    permit: any,
+    idCommitmentsToErase: string[]
+  ): Promise<any> {
+    return this.base.registerWithPermitAndErase(
+      identity,
+      permit,
+      idCommitmentsToErase
+    );
+  }
+  public async getMembershipStatus(
+    idCommitment: bigint
+  ): Promise<"expired" | "grace" | "active"> {
+    return this.base.getMembershipStatus(idCommitment);
+  }
+  public async isExpired(idCommitmentBigInt: bigint): Promise<boolean> {
+    return this.base.isExpired(idCommitmentBigInt);
+  }
+  public async isInGracePeriod(idCommitmentBigInt: bigint): Promise<boolean> {
+    return this.base.isInGracePeriod(idCommitmentBigInt);
   }
 
-  public override processEvents(events: ethers.Event[]): void {
+  // RLNContract-specific event processing
+  public processEvents(events: ethers.Event[]): void {
     const toRemoveTable = new Map<number, number[]>();
     const toInsertTable = new Map<number, ethers.Event[]>();