@waku/rln 0.1.1-8928376 → 0.1.1-ac12f68

package/src/rln_contract.ts

@@ -1,21 +1,30 @@
+import { hexToBytes } from "@waku/utils/bytes";
 import { ethers } from "ethers";
 
+import { zeroPadLE } from "./byte_utils.js";
 import { RLN_REGISTRY_ABI, RLN_STORAGE_ABI } from "./constants.js";
-import { IdentityCredential, RLNInstance } from "./rln.js";
+import type { DecryptedCredentials } from "./keystore/index.js";
+import { type IdentityCredential, RLNInstance } from "./rln.js";
 import { MerkleRootTracker } from "./root_tracker.js";
 
 type Member = {
-  pubkey: string;
-  index: number;
+  idCommitment: string;
+  index: ethers.BigNumber;
 };
 
-type Provider = ethers.Signer | ethers.providers.Provider;
+type Signer = ethers.Signer;
 
-type ContractOptions = {
-  address: string;
-  provider: Provider;
+type RLNContractOptions = {
+  signer: Signer;
+  registryAddress: string;
 };
 
+type RLNStorageOptions = {
+  storageIndex?: number;
+};
+
+type RLNContractInitOptions = RLNContractOptions & RLNStorageOptions;
+
 type FetchMembersOptions = {
   fromBlock?: number;
   fetchRange?: number;
@@ -31,15 +40,15 @@ export class RLNContract {
   private storageContract: undefined | ethers.Contract;
   private _membersFilter: undefined | ethers.EventFilter;
 
-  private _members: Member[] = [];
+  private _members: Map<number, Member> = new Map();
 
   public static async init(
     rlnInstance: RLNInstance,
-    options: ContractOptions
+    options: RLNContractInitOptions
   ): Promise<RLNContract> {
     const rlnContract = new RLNContract(rlnInstance, options);
 
-    await rlnContract.initStorageContract(options.provider);
+    await rlnContract.initStorageContract(options.signer);
     await rlnContract.fetchMembers(rlnInstance);
     rlnContract.subscribeToMembers(rlnInstance);
 
@@ -48,42 +57,61 @@ export class RLNContract {
 
   constructor(
     rlnInstance: RLNInstance,
-    { address, provider }: ContractOptions
+    { registryAddress, signer }: RLNContractOptions
   ) {
     const initialRoot = rlnInstance.getMerkleRoot();
 
     this.registryContract = new ethers.Contract(
-      address,
+      registryAddress,
       RLN_REGISTRY_ABI,
-      provider
+      signer
     );
     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);
+  private async initStorageContract(
+    signer: Signer,
+    options: RLNStorageOptions = {}
+  ): Promise<void> {
+    const storageIndex = options?.storageIndex
+      ? options.storageIndex
+      : await this.registryContract.usingStorageIndex();
+    const storageAddress = await this.registryContract.storages(storageIndex);
+
+    if (!storageAddress || storageAddress === ethers.constants.AddressZero) {
+      throw Error("No RLN Storage initialized on registry contract.");
+    }
 
-    this.storageIndex = index;
+    this.storageIndex = storageIndex;
     this.storageContract = new ethers.Contract(
-      address,
+      storageAddress,
       RLN_STORAGE_ABI,
-      provider
+      signer
     );
     this._membersFilter = this.storageContract.filters.MemberRegistered();
 
     this.deployBlock = await this.storageContract.deployedBlockNumber();
   }
 
+  public get registry(): ethers.Contract {
+    if (!this.registryContract) {
+      throw Error("Registry contract was not initialized");
+    }
+    return this.registryContract as ethers.Contract;
+  }
+
   public get contract(): ethers.Contract {
     if (!this.storageContract) {
-      throw Error("Storage contract was not initialized.");
+      throw Error("Storage contract was not initialized");
     }
     return this.storageContract as ethers.Contract;
   }
 
   public get members(): Member[] {
-    return this._members;
+    const sortedMembers = Array.from(this._members.values()).sort(
+      (left, right) => left.index.toNumber() - right.index.toNumber()
+    );
+    return sortedMembers;
   }
 
   private get membersFilter(): ethers.EventFilter {
@@ -115,13 +143,13 @@ export class RLNContract {
       }
 
       if (evt.removed) {
-        const index: number = evt.args.index;
+        const index: ethers.BigNumber = evt.args.index;
         const toRemoveVal = toRemoveTable.get(evt.blockNumber);
         if (toRemoveVal != undefined) {
-          toRemoveVal.push(index);
+          toRemoveVal.push(index.toNumber());
           toRemoveTable.set(evt.blockNumber, toRemoveVal);
         } else {
-          toRemoveTable.set(evt.blockNumber, [index]);
+          toRemoveTable.set(evt.blockNumber, [index.toNumber()]);
         }
       } else {
         let eventsPerBlock = toInsertTable.get(evt.blockNumber);
@@ -132,10 +160,10 @@ export class RLNContract {
         eventsPerBlock.push(evt);
         toInsertTable.set(evt.blockNumber, eventsPerBlock);
       }
-
-      this.removeMembers(rlnInstance, toRemoveTable);
-      this.insertMembers(rlnInstance, toInsertTable);
     });
+
+    this.removeMembers(rlnInstance, toRemoveTable);
+    this.insertMembers(rlnInstance, toInsertTable);
   }
 
   private insertMembers(
@@ -144,18 +172,19 @@ export class RLNContract {
   ): void {
     toInsert.forEach((events: ethers.Event[], blockNumber: number) => {
       events.forEach((evt) => {
-        if (!evt.args) {
+        const _idCommitment = evt?.args?.idCommitment;
+        const index: ethers.BigNumber = evt?.args?.index;
+
+        if (!_idCommitment || !index) {
           return;
         }
 
-        const pubkey = evt.args.pubkey;
-        const index = evt.args.index;
-        const idCommitment = ethers.utils.zeroPad(
-          ethers.utils.arrayify(pubkey),
-          32
-        );
+        const idCommitment = zeroPadLE(hexToBytes(_idCommitment?._hex), 32);
         rlnInstance.insertMember(idCommitment);
-        this.members.push({ index, pubkey });
+        this._members.set(index.toNumber(), {
+          index,
+          idCommitment: _idCommitment?._hex,
+        });
       });
 
       const currentRoot = rlnInstance.getMerkleRoot();
@@ -170,9 +199,8 @@ export class RLNContract {
     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);
+        if (this._members.has(index)) {
+          this._members.delete(index);
         }
         rlnInstance.deleteMember(index);
       });
@@ -183,39 +211,50 @@ export class RLNContract {
 
   public subscribeToMembers(rlnInstance: RLNInstance): void {
     this.contract.on(this.membersFilter, (_pubkey, _index, event) =>
-      this.processEvents(rlnInstance, event)
+      this.processEvents(rlnInstance, [event])
     );
   }
 
-  public async registerWithSignature(
-    rlnInstance: RLNInstance,
-    signature: string
-  ): Promise<ethers.Event | undefined> {
-    const identityCredential =
-      await rlnInstance.generateSeededIdentityCredential(signature);
-
-    return this.registerWithKey(identityCredential);
-  }
-
-  public async registerWithKey(
-    credential: IdentityCredential
-  ): Promise<ethers.Event | undefined> {
-    if (!this.storageIndex) {
+  public async registerWithIdentity(
+    identity: IdentityCredential
+  ): Promise<DecryptedCredentials | undefined> {
+    if (this.storageIndex === undefined) {
       throw Error(
         "Cannot register credential, no storage contract index found."
       );
     }
     const txRegisterResponse: ethers.ContractTransaction =
-      await this.registryContract.register(
+      await this.registryContract["register(uint16,uint256)"](
         this.storageIndex,
-        credential.IDCommitmentBigInt,
-        {
-          gasLimit: 100000,
-        }
+        identity.IDCommitmentBigInt,
+        { gasLimit: 100000 }
       );
     const txRegisterReceipt = await txRegisterResponse.wait();
 
-    return txRegisterReceipt?.events?.[0];
+    // assumption: register(uint16,uint256) emits one event
+    const memberRegistered = txRegisterReceipt?.events?.[0];
+
+    if (!memberRegistered) {
+      return undefined;
+    }
+
+    const decodedData = this.contract.interface.decodeEventLog(
+      "MemberRegistered",
+      memberRegistered.data
+    );
+
+    const network = await this.registryContract.provider.getNetwork();
+    const address = this.registryContract.address;
+    const membershipId = decodedData.index.toNumber();
+
+    return {
+      identity,
+      membership: {
+        address,
+        treeIndex: membershipId,
+        chainId: network.chainId,
+      },
+    };
   }
 
   public roots(): Uint8Array[] {