@waku/rln 0.0.14 → 0.1.0-b7cb3f9

package/dist/root_tracker.js

@@ -0,0 +1,72 @@
+class RootPerBlock {
+    constructor(root, blockNumber) {
+        this.root = root;
+        this.blockNumber = blockNumber;
+    }
+}
+const maxBufferSize = 20;
+export class MerkleRootTracker {
+    constructor(acceptableRootWindowSize, initialRoot) {
+        this.acceptableRootWindowSize = acceptableRootWindowSize;
+        this.validMerkleRoots = new Array();
+        this.merkleRootBuffer = new Array();
+        this.pushRoot(0, initialRoot);
+    }
+    backFill(fromBlockNumber) {
+        if (this.validMerkleRoots.length == 0)
+            return;
+        let numBlocks = 0;
+        for (let i = this.validMerkleRoots.length - 1; i >= 0; i--) {
+            if (this.validMerkleRoots[i].blockNumber >= fromBlockNumber) {
+                numBlocks++;
+            }
+        }
+        if (numBlocks == 0)
+            return;
+        const olderBlock = fromBlockNumber < this.validMerkleRoots[0].blockNumber;
+        // Remove last roots
+        let rootsToPop = numBlocks;
+        if (this.validMerkleRoots.length < rootsToPop) {
+            rootsToPop = this.validMerkleRoots.length;
+        }
+        this.validMerkleRoots = this.validMerkleRoots.slice(0, this.validMerkleRoots.length - rootsToPop);
+        if (this.merkleRootBuffer.length == 0)
+            return;
+        if (olderBlock) {
+            const idx = this.merkleRootBuffer.findIndex((x) => x.blockNumber == fromBlockNumber);
+            if (idx > -1) {
+                this.merkleRootBuffer = this.merkleRootBuffer.slice(0, idx);
+            }
+        }
+        // Backfill the tree's acceptable roots
+        let rootsToRestore = this.acceptableRootWindowSize - this.validMerkleRoots.length;
+        if (this.merkleRootBuffer.length < rootsToRestore) {
+            rootsToRestore = this.merkleRootBuffer.length;
+        }
+        for (let i = 0; i < rootsToRestore; i++) {
+            const x = this.merkleRootBuffer.pop();
+            if (x)
+                this.validMerkleRoots.unshift(x);
+        }
+    }
+    pushRoot(blockNumber, root) {
+        this.validMerkleRoots.push(new RootPerBlock(root, blockNumber));
+        // Maintain valid merkle root window
+        if (this.validMerkleRoots.length > this.acceptableRootWindowSize) {
+            const x = this.validMerkleRoots.shift();
+            if (x)
+                this.merkleRootBuffer.push(x);
+        }
+        // Maintain merkle root buffer
+        if (this.merkleRootBuffer.length > maxBufferSize) {
+            this.merkleRootBuffer.shift();
+        }
+    }
+    roots() {
+        return this.validMerkleRoots.map((x) => x.root);
+    }
+    buffer() {
+        return this.merkleRootBuffer.map((x) => x.root);
+    }
+}
+//# sourceMappingURL=root_tracker.js.map

package/dist/root_tracker.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"root_tracker.js","sourceRoot":"","sources":["../src/root_tracker.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@waku/rln",
-  "version": "0.0.14",
+  "version": "0.1.0-b7cb3f9",
   "description": "Rate Limit Nullifier for js-waku",
   "types": "./dist/index.d.ts",
   "module": "./dist/index.js",
@@ -83,9 +83,9 @@
     "husky": "^7.0.4",
     "ignore-loader": "^0.1.2",
     "isomorphic-fetch": "^3.0.0",
-    "@waku/interfaces": "^0.0.11",
-    "@waku/message-encryption": "^0.0.14",
-    "@waku/core": "^0.0.16",
+    "@waku/interfaces": "^0.0.12",
+    "@waku/message-encryption": "^0.0.15",
+    "@waku/core": "^0.0.17",
     "jsdom": "^19.0.0",
     "jsdom-global": "^3.0.2",
     "karma": "^6.3.12",
@@ -93,7 +93,7 @@
     "karma-mocha": "^2.0.1",
     "karma-webpack": "^5.0.0",
     "lint-staged": "^13.0.3",
-    "mocha": "^9.1.3",
+    "mocha": "10.1.0",
     "npm-run-all": "^4.1.5",
     "p-timeout": "^4.1.0",
     "prettier": "^2.1.1",
@@ -129,8 +129,8 @@
     ]
   },
   "dependencies": {
-    "@waku/utils": "^0.0.4",
-    "@waku/zerokit-rln-wasm": "^0.0.5",
+    "@waku/utils": "^0.0.5",
+    "@waku/zerokit-rln-wasm": "^0.0.10",
     "ethers": "^5.7.2"
   }
 }

package/src/codec.ts

@@ -9,21 +9,21 @@ import type {
 import debug from "debug";
 
 import { RlnMessage, toRLNSignal } from "./message.js";
-import { MembershipKey, RLNInstance } from "./rln.js";
+import { IdentityCredential, RLNInstance } from "./rln.js";
 
 const log = debug("waku:rln:encoder");
 
 export class RLNEncoder implements IEncoder {
-  private readonly idKey: Uint8Array;
+  private readonly idSecretHash: Uint8Array;
 
   constructor(
     private encoder: IEncoder,
     private rlnInstance: RLNInstance,
     private index: number,
-    membershipKey: MembershipKey
+    identityCredential: IdentityCredential
   ) {
     if (index < 0) throw "invalid membership index";
-    this.idKey = membershipKey.IDKey;
+    this.idSecretHash = identityCredential.IDSecretHash;
   }
 
   async toWire(message: IMessage): Promise<Uint8Array | undefined> {
@@ -50,7 +50,7 @@ export class RLNEncoder implements IEncoder {
       signal,
       this.index,
       message.timestamp,
-      this.idKey
+      this.idSecretHash
     );
     console.timeEnd("proof_gen_timer");
     return proof;
@@ -69,7 +69,7 @@ type RLNEncoderOptions = {
   encoder: IEncoder;
   rlnInstance: RLNInstance;
   index: number;
-  membershipKey: MembershipKey;
+  credential: IdentityCredential;
 };
 
 export const createRLNEncoder = (options: RLNEncoderOptions): RLNEncoder => {
@@ -77,7 +77,7 @@ export const createRLNEncoder = (options: RLNEncoderOptions): RLNEncoder => {
     options.encoder,
     options.rlnInstance,
     options.index,
-    options.membershipKey
+    options.credential
   );
 };
 

package/src/index.ts

@@ -1,8 +1,13 @@
 import { RLNDecoder, RLNEncoder } from "./codec.js";
 import { GOERLI_CONTRACT, RLN_ABI } from "./constants.js";
-import { Proof, RLNInstance } from "./rln.js";
-import { MembershipKey } from "./rln.js";
+import {
+  IdentityCredential,
+  Proof,
+  ProofMetadata,
+  RLNInstance,
+} from "./rln.js";
 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> {
@@ -15,10 +20,12 @@ export async function create(): Promise<RLNInstance> {
 
 export {
   RLNInstance,
-  MembershipKey,
+  IdentityCredential,
   Proof,
+  ProofMetadata,
   RLNEncoder,
   RLNDecoder,
+  MerkleRootTracker,
   RLNContract,
   RLN_ABI,
   GOERLI_CONTRACT,

package/src/rln.ts

@@ -66,18 +66,29 @@ export async function create(): Promise<RLNInstance> {
   return new RLNInstance(zkRLN, witnessCalculator);
 }
 
-export class MembershipKey {
+export class IdentityCredential {
   constructor(
-    public readonly IDKey: Uint8Array,
+    public readonly IDTrapdoor: Uint8Array,
+    public readonly IDNullifier: Uint8Array,
+    public readonly IDSecretHash: Uint8Array,
     public readonly IDCommitment: Uint8Array,
     public readonly IDCommitmentBigInt: bigint
   ) {}
 
-  static fromBytes(memKeys: Uint8Array): MembershipKey {
-    const idKey = memKeys.subarray(0, 32);
-    const idCommitment = memKeys.subarray(32);
+  static fromBytes(memKeys: Uint8Array): IdentityCredential {
+    const idTrapdoor = memKeys.subarray(0, 32);
+    const idNullifier = memKeys.subarray(32, 64);
+    const idSecretHash = memKeys.subarray(64, 96);
+    const idCommitment = memKeys.subarray(96);
     const idCommitmentBigInt = buildBigIntFromUint8Array(idCommitment);
-    return new MembershipKey(idKey, idCommitment, idCommitmentBigInt);
+
+    return new IdentityCredential(
+      idTrapdoor,
+      idNullifier,
+      idSecretHash,
+      idCommitment,
+      idCommitmentBigInt
+    );
   }
 }
 
@@ -89,6 +100,14 @@ const shareYOffset = shareXOffset + 32;
 const nullifierOffset = shareYOffset + 32;
 const rlnIdentifierOffset = nullifierOffset + 32;
 
+export class ProofMetadata {
+  constructor(
+    public readonly nullifier: Uint8Array,
+    public readonly shareX: Uint8Array,
+    public readonly shareY: Uint8Array,
+    public readonly externalNullifier: Uint8Array
+  ) {}
+}
 export class Proof implements IRateLimitProof {
   readonly proof: Uint8Array;
   readonly merkleRoot: Uint8Array;
@@ -112,6 +131,16 @@ export class Proof implements IRateLimitProof {
       rlnIdentifierOffset
     );
   }
+
+  extractMetadata(): ProofMetadata {
+    const externalNullifier = poseidonHash(this.epoch, this.rlnIdentifier);
+    return new ProofMetadata(
+      this.nullifier,
+      this.shareX,
+      this.shareY,
+      externalNullifier
+    );
+  }
 }
 
 export function proofToBytes(p: IRateLimitProof): Uint8Array {
@@ -126,30 +155,60 @@ export function proofToBytes(p: IRateLimitProof): Uint8Array {
   );
 }
 
+export function poseidonHash(...input: Array<Uint8Array>): Uint8Array {
+  const inputLen = writeUIntLE(new Uint8Array(8), input.length, 0, 8);
+  const lenPrefixedData = concatenate(inputLen, ...input);
+  return zerokitRLN.poseidonHash(lenPrefixedData);
+}
+
+export function sha256(input: Uint8Array): Uint8Array {
+  const inputLen = writeUIntLE(new Uint8Array(8), input.length, 0, 8);
+  const lenPrefixedData = concatenate(inputLen, input);
+  return zerokitRLN.hash(lenPrefixedData);
+}
+
 export class RLNInstance {
   constructor(
     private zkRLN: number,
     private witnessCalculator: WitnessCalculator
   ) {}
 
-  generateMembershipKey(): MembershipKey {
-    const memKeys = zerokitRLN.generateMembershipKey(this.zkRLN);
-    return MembershipKey.fromBytes(memKeys);
+  generateIdentityCredentials(): IdentityCredential {
+    const memKeys = zerokitRLN.generateExtendedMembershipKey(this.zkRLN); // TODO: rename this function in zerokit rln-wasm
+    return IdentityCredential.fromBytes(memKeys);
   }
 
-  generateSeededMembershipKey(seed: string): MembershipKey {
+  generateSeededIdentityCredential(seed: string): IdentityCredential {
     const seedBytes = stringEncoder.encode(seed);
-    const memKeys = zerokitRLN.generateSeededMembershipKey(
+    // TODO: rename this function in zerokit rln-wasm
+    const memKeys = zerokitRLN.generateSeededExtendedMembershipKey(
       this.zkRLN,
       seedBytes
     );
-    return MembershipKey.fromBytes(memKeys);
+    return IdentityCredential.fromBytes(memKeys);
   }
 
   insertMember(idCommitment: Uint8Array): void {
     zerokitRLN.insertMember(this.zkRLN, idCommitment);
   }
 
+  insertMembers(index: number, ...idCommitments: Array<Uint8Array>): void {
+    // serializes a seq of IDCommitments to a byte seq
+    // the order of serialization is |id_commitment_len<8>|id_commitment<var>|
+    const idCommitmentLen = writeUIntLE(
+      new Uint8Array(8),
+      idCommitments.length,
+      0,
+      8
+    );
+    const idCommitmentBytes = concatenate(idCommitmentLen, ...idCommitments);
+    zerokitRLN.setLeavesFrom(this.zkRLN, index, idCommitmentBytes);
+  }
+
+  deleteMember(index: number): void {
+    zerokitRLN.deleteLeaf(this.zkRLN, index);
+  }
+
   getMerkleRoot(): Uint8Array {
     return zerokitRLN.getRoot(this.zkRLN);
   }
@@ -174,7 +233,7 @@ export class RLNInstance {
     msg: Uint8Array,
     index: number,
     epoch: Uint8Array | Date | undefined,
-    idKey: Uint8Array
+    idSecretHash: Uint8Array
   ): Promise<IRateLimitProof> {
     if (epoch == undefined) {
       epoch = epochIntToBytes(dateToEpoch(new Date()));
@@ -183,10 +242,15 @@ export class RLNInstance {
     }
 
     if (epoch.length != 32) throw "invalid epoch";
-    if (idKey.length != 32) throw "invalid id key";
+    if (idSecretHash.length != 32) throw "invalid id secret hash";
     if (index < 0) throw "index must be >= 0";
 
-    const serialized_msg = this.serializeMessage(msg, index, epoch, idKey);
+    const serialized_msg = this.serializeMessage(
+      msg,
+      index,
+      epoch,
+      idSecretHash
+    );
     const rlnWitness = zerokitRLN.getSerializedRLNWitness(
       this.zkRLN,
       serialized_msg
@@ -228,7 +292,8 @@ export class RLNInstance {
 
   verifyWithRoots(
     proof: IRateLimitProof | Uint8Array,
-    msg: Uint8Array
+    msg: Uint8Array,
+    ...roots: Array<Uint8Array>
   ): boolean {
     let pBytes: Uint8Array;
     if (proof instanceof Uint8Array) {
@@ -236,17 +301,15 @@ export class RLNInstance {
     } else {
       pBytes = proofToBytes(proof);
     }
-
     // calculate message length
     const msgLen = writeUIntLE(new Uint8Array(8), msg.length, 0, 8);
 
-    // obtain root
-    const root = zerokitRLN.getRoot(this.zkRLN);
+    const rootsBytes = concatenate(...roots);
 
     return zerokitRLN.verifyWithRoots(
       this.zkRLN,
       concatenate(pBytes, msgLen, msg),
-      root
+      rootsBytes
     );
   }
 

package/src/rln_contract.ts

@@ -1,7 +1,7 @@
 import { ethers } from "ethers";
 
 import { RLN_ABI } from "./constants.js";
-import { RLNInstance } from "./rln.js";
+import { IdentityCredential, RLNInstance } from "./rln.js";
 
 type Member = {
   pubkey: string;
@@ -13,6 +13,12 @@ type ContractOptions = {
   provider: ethers.Signer | ethers.providers.Provider;
 };
 
+type FetchMembersOptions = {
+  fromBlock?: number;
+  fetchRange?: number;
+  fetchChunks?: number;
+};
+
 export class RLNContract {
   private _contract: ethers.Contract;
   private membersFilter: ethers.EventFilter;
@@ -46,12 +52,12 @@ export class RLNContract {
 
   public async fetchMembers(
     rlnInstance: RLNInstance,
-    fromBlock?: number
+    options: FetchMembersOptions = {}
   ): Promise<void> {
-    const registeredMemberEvents = await this.contract.queryFilter(
-      this.membersFilter,
-      fromBlock
-    );
+    const registeredMemberEvents = await queryFilter(this.contract, {
+      ...options,
+      membersFilter: this.membersFilter,
+    });
 
     for (const event of registeredMemberEvents) {
       this.addMemberFromEvent(rlnInstance, event);
@@ -84,17 +90,23 @@ export class RLNContract {
     rlnInstance.insertMember(idCommitment);
   }
 
-  public async registerMember(
+  public async registerWithSignature(
     rlnInstance: RLNInstance,
     signature: string
   ): Promise<ethers.Event | undefined> {
-    const membershipKey = await rlnInstance.generateSeededMembershipKey(
-      signature
-    );
+    const identityCredential =
+      await rlnInstance.generateSeededIdentityCredential(signature);
+
+    return this.registerWithKey(identityCredential);
+  }
+
+  public async registerWithKey(
+    credential: IdentityCredential
+  ): Promise<ethers.Event | undefined> {
     const depositValue = await this.contract.MEMBERSHIP_DEPOSIT();
 
     const txRegisterResponse: ethers.ContractTransaction =
-      await this.contract.register(membershipKey.IDCommitmentBigInt, {
+      await this.contract.register(credential.IDCommitmentBigInt, {
         value: depositValue,
       });
     const txRegisterReceipt = await txRegisterResponse.wait();
@@ -102,3 +114,90 @@ export class RLNContract {
     return txRegisterReceipt?.events?.[0];
   }
 }
+
+type CustomQueryOptions = FetchMembersOptions & {
+  membersFilter: ethers.EventFilter;
+};
+
+// these value should be tested on other networks
+const FETCH_CHUNK = 5;
+const BLOCK_RANGE = 3000;
+
+async function queryFilter(
+  contract: ethers.Contract,
+  options: CustomQueryOptions
+): Promise<ethers.Event[]> {
+  const {
+    fromBlock,
+    membersFilter,
+    fetchRange = BLOCK_RANGE,
+    fetchChunks = FETCH_CHUNK,
+  } = options;
+
+  if (!fromBlock) {
+    return contract.queryFilter(membersFilter);
+  }
+
+  if (!contract.signer.provider) {
+    throw Error("No provider found on the contract's signer.");
+  }
+
+  const toBlock = await contract.signer.provider.getBlockNumber();
+
+  if (toBlock - fromBlock < fetchRange) {
+    return contract.queryFilter(membersFilter);
+  }
+
+  const events: ethers.Event[][] = [];
+  const chunks = splitToChunks(fromBlock, toBlock, fetchRange);
+
+  for (const portion of takeN<[number, number]>(chunks, fetchChunks)) {
+    const promises = portion.map(([left, right]) =>
+      ignoreErrors(contract.queryFilter(membersFilter, left, right), [])
+    );
+    const fetchedEvents = await Promise.all(promises);
+    events.push(fetchedEvents.flatMap((v) => v));
+  }
+
+  return events.flatMap((v) => v);
+}
+
+function splitToChunks(
+  from: number,
+  to: number,
+  step: number
+): Array<[number, number]> {
+  const chunks = [];
+
+  let left = from;
+  while (left < to) {
+    const right = left + step < to ? left + step : to;
+
+    chunks.push([left, right] as [number, number]);
+
+    left = right;
+  }
+
+  return chunks;
+}
+
+function* takeN<T>(array: T[], size: number): Iterable<T[]> {
+  let start = 0;
+  let skip = size;
+
+  while (skip < array.length) {
+    const portion = array.slice(start, skip);
+
+    yield portion;
+
+    start = skip;
+    skip += size;
+  }
+}
+
+function ignoreErrors<T>(promise: Promise<T>, defaultValue: T): Promise<T> {
+  return promise.catch((err) => {
+    console.error(`Ignoring an error during query: ${err?.message}`);
+    return defaultValue;
+  });
+}

package/src/root_tracker.ts

@@ -0,0 +1,88 @@
+class RootPerBlock {
+  constructor(public root: Uint8Array, public blockNumber: number) {}
+}
+
+const maxBufferSize = 20;
+
+export class MerkleRootTracker {
+  private validMerkleRoots: Array<RootPerBlock> = new Array<RootPerBlock>();
+  private merkleRootBuffer: Array<RootPerBlock> = new Array<RootPerBlock>();
+  constructor(
+    private acceptableRootWindowSize: number,
+    initialRoot: Uint8Array
+  ) {
+    this.pushRoot(0, initialRoot);
+  }
+
+  backFill(fromBlockNumber: number): void {
+    if (this.validMerkleRoots.length == 0) return;
+
+    let numBlocks = 0;
+    for (let i = this.validMerkleRoots.length - 1; i >= 0; i--) {
+      if (this.validMerkleRoots[i].blockNumber >= fromBlockNumber) {
+        numBlocks++;
+      }
+    }
+
+    if (numBlocks == 0) return;
+
+    const olderBlock = fromBlockNumber < this.validMerkleRoots[0].blockNumber;
+
+    // Remove last roots
+    let rootsToPop = numBlocks;
+    if (this.validMerkleRoots.length < rootsToPop) {
+      rootsToPop = this.validMerkleRoots.length;
+    }
+
+    this.validMerkleRoots = this.validMerkleRoots.slice(
+      0,
+      this.validMerkleRoots.length - rootsToPop
+    );
+
+    if (this.merkleRootBuffer.length == 0) return;
+
+    if (olderBlock) {
+      const idx = this.merkleRootBuffer.findIndex(
+        (x) => x.blockNumber == fromBlockNumber
+      );
+      if (idx > -1) {
+        this.merkleRootBuffer = this.merkleRootBuffer.slice(0, idx);
+      }
+    }
+
+    // Backfill the tree's acceptable roots
+    let rootsToRestore =
+      this.acceptableRootWindowSize - this.validMerkleRoots.length;
+    if (this.merkleRootBuffer.length < rootsToRestore) {
+      rootsToRestore = this.merkleRootBuffer.length;
+    }
+
+    for (let i = 0; i < rootsToRestore; i++) {
+      const x = this.merkleRootBuffer.pop();
+      if (x) this.validMerkleRoots.unshift(x);
+    }
+  }
+
+  pushRoot(blockNumber: number, root: Uint8Array): void {
+    this.validMerkleRoots.push(new RootPerBlock(root, blockNumber));
+
+    // Maintain valid merkle root window
+    if (this.validMerkleRoots.length > this.acceptableRootWindowSize) {
+      const x = this.validMerkleRoots.shift();
+      if (x) this.merkleRootBuffer.push(x);
+    }
+
+    // Maintain merkle root buffer
+    if (this.merkleRootBuffer.length > maxBufferSize) {
+      this.merkleRootBuffer.shift();
+    }
+  }
+
+  roots(): Array<Uint8Array> {
+    return this.validMerkleRoots.map((x) => x.root);
+  }
+
+  buffer(): Array<Uint8Array> {
+    return this.merkleRootBuffer.map((x) => x.root);
+  }
+}