@waku/rln 0.1.1-b429b05 → 0.1.1-bafbe01

package/src/constants.ts

@@ -1,14 +1,68 @@
-export const RLN_ABI = [
-  "function MEMBERSHIP_DEPOSIT() public view returns(uint256)",
-  "function register(uint256 pubkey) external payable",
-  "function withdraw(uint256 secret, uint256 _pubkeyIndex, address payable receiver) external",
-  "event MemberRegistered(uint256 pubkey, uint256 index)",
-  "event MemberWithdrawn(uint256 pubkey, uint256 index)",
+// ref https://github.com/waku-org/waku-rln-contract/blob/19fded82bca07e7b535b429dc507cfb83f10dfcf/deployments/sepolia/WakuRlnRegistry_Implementation.json#L3
+export const RLN_REGISTRY_ABI = [
+  "error IncompatibleStorage()",
+  "error IncompatibleStorageIndex()",
+  "error NoStorageContractAvailable()",
+  "error StorageAlreadyExists(address storageAddress)",
+  "event AdminChanged(address previousAdmin, address newAdmin)",
+  "event BeaconUpgraded(address indexed beacon)",
+  "event Initialized(uint8 version)",
+  "event NewStorageContract(uint16 index, address storageAddress)",
+  "event OwnershipTransferred(address indexed previousOwner, address indexed newOwner)",
+  "event Upgraded(address indexed implementation)",
+  "function forceProgress()",
+  "function initialize(address _poseidonHasher)",
+  "function newStorage()",
+  "function nextStorageIndex() view returns (uint16)",
+  "function owner() view returns (address)",
+  "function poseidonHasher() view returns (address)",
+  "function proxiableUUID() view returns (bytes32)",
+  "function register(uint16 storageIndex, uint256 commitment)",
+  "function register(uint256[] commitments)",
+  "function register(uint16 storageIndex, uint256[] commitments)",
+  "function registerStorage(address storageAddress)",
+  "function renounceOwnership()",
+  "function storages(uint16) view returns (address)",
+  "function transferOwnership(address newOwner)",
+  "function upgradeTo(address newImplementation)",
+  "function upgradeToAndCall(address newImplementation, bytes data) payable",
+  "function usingStorageIndex() view returns (uint16)",
+];
+
+// ref https://github.com/waku-org/waku-rln-contract/blob/19fded82bca07e7b535b429dc507cfb83f10dfcf/deployments/sepolia/WakuRlnStorage_0.json#L3
+export const RLN_STORAGE_ABI = [
+  "constructor(address _poseidonHasher, uint16 _contractIndex)",
+  "error DuplicateIdCommitment()",
+  "error FullTree()",
+  "error InvalidIdCommitment(uint256 idCommitment)",
+  "error NotImplemented()",
+  "event MemberRegistered(uint256 idCommitment, uint256 index)",
+  "event MemberWithdrawn(uint256 idCommitment, uint256 index)",
+  "event OwnershipTransferred(address indexed previousOwner, address indexed newOwner)",
+  "function DEPTH() view returns (uint256)",
+  "function MEMBERSHIP_DEPOSIT() view returns (uint256)",
+  "function SET_SIZE() view returns (uint256)",
+  "function contractIndex() view returns (uint16)",
+  "function deployedBlockNumber() view returns (uint32)",
+  "function idCommitmentIndex() view returns (uint256)",
+  "function isValidCommitment(uint256 idCommitment) view returns (bool)",
+  "function memberExists(uint256) view returns (bool)",
+  "function members(uint256) view returns (uint256)",
+  "function owner() view returns (address)",
+  "function poseidonHasher() view returns (address)",
+  "function register(uint256[] idCommitments)",
+  "function register(uint256 idCommitment) payable",
+  "function renounceOwnership()",
+  "function slash(uint256 idCommitment, address receiver, uint256[8] proof) pure",
+  "function stakedAmounts(uint256) view returns (uint256)",
+  "function transferOwnership(address newOwner)",
+  "function verifier() view returns (address)",
+  "function withdraw() pure",
+  "function withdrawalBalance(address) view returns (uint256)",
 ];
 
 export const SEPOLIA_CONTRACT = {
   chainId: 11155111,
-  startBlock: 3193048,
-  address: "0x9C09146844C1326c2dBC41c451766C7138F88155",
-  abi: RLN_ABI,
+  address: "0xF471d71E9b1455bBF4b85d475afb9BB0954A29c4",
+  abi: RLN_REGISTRY_ABI,
 };

package/src/create.ts

@@ -0,0 +1,9 @@
+import type { RLNInstance } from "./rln.js";
+
+export async function createRLN(): Promise<RLNInstance> {
+  // A dependency graph that contains any wasm must all be imported
+  // asynchronously. This file does the single async import, so
+  // that no one else needs to worry about it again.
+  const rlnModule = await import("./rln.js");
+  return rlnModule.create();
+}

package/src/index.ts

@@ -1,5 +1,11 @@
 import { RLNDecoder, RLNEncoder } from "./codec.js";
-import { RLN_ABI, SEPOLIA_CONTRACT } from "./constants.js";
+import {
+  RLN_REGISTRY_ABI,
+  RLN_STORAGE_ABI,
+  SEPOLIA_CONTRACT,
+} from "./constants.js";
+import { createRLN } from "./create.js";
+import { Keystore } from "./keystore/index.js";
 import {
   IdentityCredential,
   Proof,
@@ -9,16 +15,9 @@ import {
 import { RLNContract } from "./rln_contract.js";
 import { MerkleRootTracker } from "./root_tracker.js";
 
-// reexport the create function, dynamically imported from rln.ts
-export async function create(): Promise<RLNInstance> {
-  // A dependency graph that contains any wasm must all be imported
-  // asynchronously. This file does the single async import, so
-  // that no one else needs to worry about it again.
-  const rlnModule = await import("./rln.js");
-  return await rlnModule.create();
-}
-
 export {
+  createRLN,
+  Keystore,
   RLNInstance,
   IdentityCredential,
   Proof,
@@ -27,6 +26,7 @@ export {
   RLNDecoder,
   MerkleRootTracker,
   RLNContract,
-  RLN_ABI,
+  RLN_STORAGE_ABI,
+  RLN_REGISTRY_ABI,
   SEPOLIA_CONTRACT,
 };

package/src/message.ts

@@ -14,7 +14,7 @@ export function toRLNSignal(contentTopic: string, msg: IMessage): Uint8Array {
 }
 
 export class RlnMessage<T extends IDecodedMessage> implements IDecodedMessage {
-  public pubSubTopic = "";
+  public pubsubTopic = "";
 
   constructor(
     public rlnInstance: RLNInstance,

package/src/metamask.ts

@@ -0,0 +1,15 @@
+import { ethers } from "ethers";
+
+export const extractMetaMaskAccount =
+  async (): Promise<ethers.providers.Web3Provider> => {
+    const ethereum = (window as any).ethereum;
+
+    if (!ethereum) {
+      throw Error(
+        "Missing or invalid Ethereum provider. Please install a Web3 wallet such as MetaMask."
+      );
+    }
+
+    await ethereum.request({ method: "eth_requestAccounts" });
+    return new ethers.providers.Web3Provider(ethereum, "any");
+  };

package/src/rln.ts

@@ -1,9 +1,14 @@
 import type { IRateLimitProof } from "@waku/interfaces";
-import init, * as zerokitRLN from "@waku/zerokit-rln-wasm";
+import init from "@waku/zerokit-rln-wasm";
+import * as zerokitRLN from "@waku/zerokit-rln-wasm";
+import { ethers } from "ethers";
 
-import { writeUIntLE } from "./byte_utils.js";
+import { buildBigIntFromUint8Array, writeUIntLE } from "./byte_utils.js";
+import { SEPOLIA_CONTRACT } from "./constants.js";
 import { dateToEpoch, epochIntToBytes } from "./epoch.js";
+import { extractMetaMaskAccount } from "./metamask.js";
 import verificationKey from "./resources/verification_key.js";
+import { RLNContract } from "./rln_contract.js";
 import * as wc from "./witness_calculator.js";
 import { WitnessCalculator } from "./witness_calculator.js";
 
@@ -26,16 +31,6 @@ function concatenate(...input: Uint8Array[]): Uint8Array {
   return result;
 }
 
-/**
- * Transforms Uint8Array into BigInt
- * @param array: Uint8Array
- * @returns BigInt
- */
-function buildBigIntFromUint8Array(array: Uint8Array): bigint {
-  const dataView = new DataView(array.buffer);
-  return dataView.getBigUint64(0, true);
-}
-
 const stringEncoder = new TextEncoder();
 
 const DEPTH = 20;
@@ -57,7 +52,7 @@ async function loadZkey(): Promise<Uint8Array> {
  * @returns RLNInstance
  */
 export async function create(): Promise<RLNInstance> {
-  await init();
+  await (init as any)?.();
   zerokitRLN.init_panic_hook();
   const witnessCalculator = await loadWitnessCalculator();
   const zkey = await loadZkey();
@@ -167,12 +162,39 @@ export function sha256(input: Uint8Array): Uint8Array {
   return zerokitRLN.hash(lenPrefixedData);
 }
 
+type StartRLNOptions = {
+  /**
+   * If not set - will extract MetaMask account and get provider from it.
+   */
+  provider?: ethers.providers.Provider;
+  /**
+   * If not set - will use default SEPOLIA_CONTRACT address.
+   */
+  registryAddress?: string;
+};
+
 export class RLNInstance {
+  private _contract: null | RLNContract = null;
+
   constructor(
     private zkRLN: number,
     private witnessCalculator: WitnessCalculator
   ) {}
 
+  public get contract(): null | RLNContract {
+    return this._contract;
+  }
+
+  public async start(options: StartRLNOptions = {}): Promise<void> {
+    const provider = options.provider || (await extractMetaMaskAccount());
+    const registryAddress = options.registryAddress || SEPOLIA_CONTRACT.address;
+
+    this._contract = await RLNContract.init(this, {
+      registryAddress,
+      provider,
+    });
+  }
+
   generateIdentityCredentials(): IdentityCredential {
     const memKeys = zerokitRLN.generateExtendedMembershipKey(this.zkRLN); // TODO: rename this function in zerokit rln-wasm
     return IdentityCredential.fromBytes(memKeys);

package/src/rln_contract.ts

@@ -1,19 +1,29 @@
+import { hexToBytes } from "@waku/utils/bytes";
 import { ethers } from "ethers";
 
-import { RLN_ABI } from "./constants.js";
+import { zeroPadLE } from "./byte_utils.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;
+  idCommitment: string;
+  index: ethers.BigNumber;
 };
 
-type ContractOptions = {
-  address: string;
-  provider: ethers.Signer | ethers.providers.Provider;
+type Provider = ethers.Signer | ethers.providers.Provider;
+
+type RLNContractOptions = {
+  provider: Provider;
+  registryAddress: string;
+};
+
+type RLNStorageOptions = {
+  storageIndex?: number;
 };
 
+type RLNContractInitOptions = RLNContractOptions & RLNStorageOptions;
+
 type FetchMembersOptions = {
   fromBlock?: number;
   fetchRange?: number;
@@ -21,18 +31,23 @@ type FetchMembersOptions = {
 };
 
 export class RLNContract {
-  private _contract: ethers.Contract;
-  private membersFilter: ethers.EventFilter;
+  private registryContract: ethers.Contract;
   private merkleRootTracker: MerkleRootTracker;
 
-  private _members: Member[] = [];
+  private deployBlock: undefined | number;
+  private storageIndex: undefined | number;
+  private storageContract: undefined | ethers.Contract;
+  private _membersFilter: undefined | ethers.EventFilter;
+
+  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.fetchMembers(rlnInstance);
     rlnContract.subscribeToMembers(rlnInstance);
 
@@ -41,21 +56,61 @@ export class RLNContract {
 
   constructor(
     rlnInstance: RLNInstance,
-    { address, provider }: ContractOptions
+    { registryAddress, provider }: RLNContractOptions
   ) {
     const initialRoot = rlnInstance.getMerkleRoot();
 
-    this._contract = new ethers.Contract(address, RLN_ABI, provider);
+    this.registryContract = new ethers.Contract(
+      registryAddress,
+      RLN_REGISTRY_ABI,
+      provider
+    );
     this.merkleRootTracker = new MerkleRootTracker(5, initialRoot);
-    this.membersFilter = this.contract.filters.MemberRegistered();
+  }
+
+  private async initStorageContract(
+    provider: Provider,
+    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 = storageIndex;
+    this.storageContract = new ethers.Contract(
+      storageAddress,
+      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;
+    const sortedMembers = Array.from(this._members.values()).sort(
+      (left, right) => left.index.toNumber() - right.index.toNumber()
+    );
+    return sortedMembers;
+  }
+
+  private get membersFilter(): ethers.EventFilter {
+    if (!this._membersFilter) {
+      throw Error("Members filter was not initialized.");
+    }
+    return this._membersFilter as ethers.EventFilter;
   }
 
   public async fetchMembers(
@@ -63,6 +118,7 @@ export class RLNContract {
     options: FetchMembersOptions = {}
   ): Promise<void> {
     const registeredMemberEvents = await queryFilter(this.contract, {
+      fromBlock: this.deployBlock,
       ...options,
       membersFilter: this.membersFilter,
     });
@@ -79,13 +135,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);
@@ -96,10 +152,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(
@@ -108,18 +164,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();
@@ -134,9 +191,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);
       });
@@ -147,14 +203,14 @@ 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> {
+  ): Promise<Member | undefined> {
     const identityCredential =
       await rlnInstance.generateSeededIdentityCredential(signature);
 
@@ -163,16 +219,36 @@ export class RLNContract {
 
   public async registerWithKey(
     credential: IdentityCredential
-  ): Promise<ethers.Event | undefined> {
-    const depositValue = await this.contract.MEMBERSHIP_DEPOSIT();
-
+  ): Promise<Member | undefined> {
+    if (this.storageIndex === undefined) {
+      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(uint16,uint256)"](
+        this.storageIndex,
+        credential.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
+    );
+
+    return {
+      idCommitment: decodedData.idCommitment,
+      index: decodedData.index,
+    };
   }
 
   public roots(): Uint8Array[] {