@waku/rln 0.1.0-e52107d → 0.1.1-5b9414a

package/src/rln_contract.ts

@@ -1,16 +1,19 @@
 import { ethers } from "ethers";
 
-import { RLN_ABI } from "./constants.js";
+import { RLN_REGISTRY_ABI, RLN_STORAGE_ABI } from "./constants.js";
 import { IdentityCredential, RLNInstance } from "./rln.js";
+import { MerkleRootTracker } from "./root_tracker.js";
 
 type Member = {
   pubkey: string;
   index: number;
 };
 
+type Provider = ethers.Signer | ethers.providers.Provider;
+
 type ContractOptions = {
   address: string;
-  provider: ethers.Signer | ethers.providers.Provider;
+  provider: Provider;
 };
 
 type FetchMembersOptions = {
@@ -20,8 +23,13 @@ type FetchMembersOptions = {
 };
 
 export class RLNContract {
-  private _contract: ethers.Contract;
-  private membersFilter: ethers.EventFilter;
+  private registryContract: ethers.Contract;
+  private merkleRootTracker: MerkleRootTracker;
+
+  private deployBlock: undefined | number;
+  private storageIndex: undefined | number;
+  private storageContract: undefined | ethers.Contract;
+  private _membersFilter: undefined | ethers.EventFilter;
 
   private _members: Member[] = [];
 
@@ -29,65 +37,154 @@ export class RLNContract {
     rlnInstance: RLNInstance,
     options: ContractOptions
   ): Promise<RLNContract> {
-    const rlnContract = new RLNContract(options);
+    const rlnContract = new RLNContract(rlnInstance, options);
 
+    await rlnContract.initStorageContract(options.provider);
     await rlnContract.fetchMembers(rlnInstance);
     rlnContract.subscribeToMembers(rlnInstance);
 
     return rlnContract;
   }
 
-  constructor({ address, provider }: ContractOptions) {
-    this._contract = new ethers.Contract(address, RLN_ABI, provider);
-    this.membersFilter = this.contract.filters.MemberRegistered();
+  constructor(
+    rlnInstance: RLNInstance,
+    { address, provider }: ContractOptions
+  ) {
+    const initialRoot = rlnInstance.getMerkleRoot();
+
+    this.registryContract = new ethers.Contract(
+      address,
+      RLN_REGISTRY_ABI,
+      provider
+    );
+    this.merkleRootTracker = new MerkleRootTracker(5, initialRoot);
+  }
+
+  private async initStorageContract(provider: Provider): Promise<void> {
+    const index = await this.registryContract.usingStorageIndex();
+    const address = await this.registryContract.storages(index);
+
+    this.storageIndex = index;
+    this.storageContract = new ethers.Contract(
+      address,
+      RLN_STORAGE_ABI,
+      provider
+    );
+    this._membersFilter = this.storageContract.filters.MemberRegistered();
+
+    this.deployBlock = await this.storageContract.deployedBlockNumber();
   }
 
   public get contract(): ethers.Contract {
-    return this._contract;
+    if (!this.storageContract) {
+      throw Error("Storage contract was not initialized.");
+    }
+    return this.storageContract as ethers.Contract;
   }
 
   public get members(): Member[] {
     return this._members;
   }
 
+  private get membersFilter(): ethers.EventFilter {
+    if (!this._membersFilter) {
+      throw Error("Members filter was not initialized.");
+    }
+    return this._membersFilter as ethers.EventFilter;
+  }
+
   public async fetchMembers(
     rlnInstance: RLNInstance,
     options: FetchMembersOptions = {}
   ): Promise<void> {
     const registeredMemberEvents = await queryFilter(this.contract, {
+      fromBlock: this.deployBlock,
       ...options,
       membersFilter: this.membersFilter,
     });
-
-    for (const event of registeredMemberEvents) {
-      this.addMemberFromEvent(rlnInstance, event);
-    }
+    this.processEvents(rlnInstance, registeredMemberEvents);
   }
 
-  public subscribeToMembers(rlnInstance: RLNInstance): void {
-    this.contract.on(this.membersFilter, (_pubkey, _index, event) =>
-      this.addMemberFromEvent(rlnInstance, event)
-    );
+  public processEvents(rlnInstance: RLNInstance, 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 (evt.removed) {
+        const index: number = evt.args.index;
+        const toRemoveVal = toRemoveTable.get(evt.blockNumber);
+        if (toRemoveVal != undefined) {
+          toRemoveVal.push(index);
+          toRemoveTable.set(evt.blockNumber, toRemoveVal);
+        } else {
+          toRemoveTable.set(evt.blockNumber, [index]);
+        }
+      } else {
+        let eventsPerBlock = toInsertTable.get(evt.blockNumber);
+        if (eventsPerBlock == undefined) {
+          eventsPerBlock = [];
+        }
+
+        eventsPerBlock.push(evt);
+        toInsertTable.set(evt.blockNumber, eventsPerBlock);
+      }
+
+      this.removeMembers(rlnInstance, toRemoveTable);
+      this.insertMembers(rlnInstance, toInsertTable);
+    });
   }
 
-  private addMemberFromEvent(
+  private insertMembers(
     rlnInstance: RLNInstance,
-    event: ethers.Event
+    toInsert: Map<number, ethers.Event[]>
   ): void {
-    if (!event.args) {
-      return;
-    }
+    toInsert.forEach((events: ethers.Event[], blockNumber: number) => {
+      events.forEach((evt) => {
+        if (!evt.args) {
+          return;
+        }
+
+        const pubkey = evt.args.pubkey;
+        const index = evt.args.index;
+        const idCommitment = ethers.utils.zeroPad(
+          ethers.utils.arrayify(pubkey),
+          32
+        );
+        rlnInstance.insertMember(idCommitment);
+        this.members.push({ index, pubkey });
+      });
 
-    const pubkey: string = event.args.pubkey;
-    const index: number = event.args.index;
+      const currentRoot = rlnInstance.getMerkleRoot();
+      this.merkleRootTracker.pushRoot(blockNumber, currentRoot);
+    });
+  }
+
+  private removeMembers(
+    rlnInstance: RLNInstance,
+    toRemove: Map<number, number[]>
+  ): void {
+    const removeDescending = new Map([...toRemove].sort().reverse());
+    removeDescending.forEach((indexes: number[], blockNumber: number) => {
+      indexes.forEach((index) => {
+        const idx = this.members.findIndex((m) => m.index === index);
+        if (idx > -1) {
+          this.members.splice(idx, 1);
+        }
+        rlnInstance.deleteMember(index);
+      });
 
-    this.members.push({ index, pubkey });
+      this.merkleRootTracker.backFill(blockNumber);
+    });
+  }
 
-    const idCommitment = ethers.utils.zeroPad(
-      ethers.utils.arrayify(pubkey),
-      32
+  public subscribeToMembers(rlnInstance: RLNInstance): void {
+    this.contract.on(this.membersFilter, (_pubkey, _index, event) =>
+      this.processEvents(rlnInstance, event)
     );
-    rlnInstance.insertMember(idCommitment);
   }
 
   public async registerWithSignature(
@@ -103,16 +200,27 @@ export class RLNContract {
   public async registerWithKey(
     credential: IdentityCredential
   ): Promise<ethers.Event | undefined> {
-    const depositValue = await this.contract.MEMBERSHIP_DEPOSIT();
-
+    if (!this.storageIndex) {
+      throw Error(
+        "Cannot register credential, no storage contract index found."
+      );
+    }
     const txRegisterResponse: ethers.ContractTransaction =
-      await this.contract.register(credential.IDCommitmentBigInt, {
-        value: depositValue,
-      });
+      await this.registryContract.register(
+        this.storageIndex,
+        credential.IDCommitmentBigInt,
+        {
+          gasLimit: 100000,
+        }
+      );
     const txRegisterReceipt = await txRegisterResponse.wait();
 
     return txRegisterReceipt?.events?.[0];
   }
+
+  public roots(): Uint8Array[] {
+    return this.merkleRootTracker.roots();
+  }
 }
 
 type CustomQueryOptions = FetchMembersOptions & {