@waku/rln 0.1.1-fa49e29 → 0.1.2-86d4f56

package/src/rln_contract.ts

@@ -1,7 +1,10 @@
+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 = {
@@ -9,10 +12,10 @@ type Member = {
   index: ethers.BigNumber;
 };
 
-type Provider = ethers.Signer | ethers.providers.Provider;
+type Signer = ethers.Signer;
 
 type RLNContractOptions = {
-  provider: Provider;
+  signer: Signer;
   registryAddress: string;
 };
 
@@ -45,7 +48,7 @@ export class RLNContract {
   ): 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);
 
@@ -54,20 +57,20 @@ export class RLNContract {
 
   constructor(
     rlnInstance: RLNInstance,
-    { registryAddress, provider }: RLNContractOptions
+    { registryAddress, signer }: RLNContractOptions
   ) {
     const initialRoot = rlnInstance.getMerkleRoot();
 
     this.registryContract = new ethers.Contract(
       registryAddress,
       RLN_REGISTRY_ABI,
-      provider
+      signer
     );
     this.merkleRootTracker = new MerkleRootTracker(5, initialRoot);
   }
 
   private async initStorageContract(
-    provider: Provider,
+    signer: Signer,
     options: RLNStorageOptions = {}
   ): Promise<void> {
     const storageIndex = options?.storageIndex
@@ -83,13 +86,20 @@ export class RLNContract {
     this.storageContract = new ethers.Contract(
       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");
@@ -150,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(
@@ -169,15 +179,11 @@ export class RLNContract {
           return;
         }
 
-        const idCommitment = ethers.utils.zeroPad(
-          ethers.utils.arrayify(_idCommitment),
-          32
-        );
+        const idCommitment = zeroPadLE(hexToBytes(_idCommitment?._hex), 32);
         rlnInstance.insertMember(idCommitment);
         this._members.set(index.toNumber(), {
           index,
-          idCommitment:
-            _idCommitment?._hex || ethers.utils.hexlify(idCommitment),
+          idCommitment: _idCommitment?._hex,
         });
       });
 
@@ -209,19 +215,9 @@ export class RLNContract {
     );
   }
 
-  public async registerWithSignature(
-    rlnInstance: RLNInstance,
-    signature: string
-  ): Promise<Member | undefined> {
-    const identityCredential =
-      await rlnInstance.generateSeededIdentityCredential(signature);
-
-    return this.registerWithKey(identityCredential);
-  }
-
-  public async registerWithKey(
-    credential: IdentityCredential
-  ): Promise<Member | undefined> {
+  public async registerWithIdentity(
+    identity: IdentityCredential
+  ): Promise<DecryptedCredentials | undefined> {
     if (this.storageIndex === undefined) {
       throw Error(
         "Cannot register credential, no storage contract index found."
@@ -230,7 +226,7 @@ export class RLNContract {
     const txRegisterResponse: ethers.ContractTransaction =
       await this.registryContract["register(uint16,uint256)"](
         this.storageIndex,
-        credential.IDCommitmentBigInt,
+        identity.IDCommitmentBigInt,
         { gasLimit: 100000 }
       );
     const txRegisterReceipt = await txRegisterResponse.wait();
@@ -247,9 +243,17 @@ export class RLNContract {
       memberRegistered.data
     );
 
+    const network = await this.registryContract.provider.getNetwork();
+    const address = this.registryContract.address;
+    const membershipId = decodedData.index.toNumber();
+
     return {
-      idCommitment: decodedData.idCommitment,
-      index: decodedData.index,
+      identity,
+      membership: {
+        address,
+        treeIndex: membershipId,
+        chainId: network.chainId,
+      },
     };
   }