@waku/rln 0.1.0 → 0.1.1-5d7f77f

package/bundle/index.js

@@ -1909,9 +1909,9 @@ class RlnMessage {
         this.rateLimitProof = rateLimitProof;
         this.pubSubTopic = "";
     }
-    verify() {
+    verify(roots) {
         return this.rateLimitProof
-            ? this.rlnInstance.verifyWithRoots(this.rateLimitProof, toRLNSignal(this.msg.contentTopic, this.msg)) // this.rlnInstance.verifyRLNProof once issue status-im/nwaku#1248 is fixed
+            ? this.rlnInstance.verifyWithRoots(this.rateLimitProof, toRLNSignal(this.msg.contentTopic, this.msg), ...roots) // this.rlnInstance.verifyRLNProof once issue status-im/nwaku#1248 is fixed
             : undefined;
     }
     verifyNoRoot() {
@@ -1931,6 +1931,9 @@ class RlnMessage {
     get ephemeral() {
         return this.msg.ephemeral;
     }
+    get meta() {
+        return this.msg.meta;
+    }
     get epoch() {
         const bytes = this.msg.rateLimitProof?.epoch;
         if (!bytes)
@@ -2005,10 +2008,10 @@ const RLN_ABI = [
     "event MemberRegistered(uint256 pubkey, uint256 index)",
     "event MemberWithdrawn(uint256 pubkey, uint256 index)",
 ];
-const GOERLI_CONTRACT = {
-    chainId: 5,
-    startBlock: 7109391,
-    address: "0x4252105670fe33d2947e8ead304969849e64f2a6",
+const SEPOLIA_CONTRACT = {
+    chainId: 11155111,
+    startBlock: 3193048,
+    address: "0x9C09146844C1326c2dBC41c451766C7138F88155",
     abi: RLN_ABI,
 };
 
@@ -27147,14 +27150,88 @@ try {
 }
 catch (error) { }
 
+class RootPerBlock {
+    constructor(root, blockNumber) {
+        this.root = root;
+        this.blockNumber = blockNumber;
+    }
+}
+const maxBufferSize = 20;
+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);
+    }
+}
+
 class RLNContract {
-    constructor({ address, provider }) {
+    constructor(rlnInstance, { address, provider }) {
         this._members = [];
+        const initialRoot = rlnInstance.getMerkleRoot();
         this._contract = new Contract(address, RLN_ABI, provider);
+        this.merkleRootTracker = new MerkleRootTracker(5, initialRoot);
         this.membersFilter = this.contract.filters.MemberRegistered();
     }
     static async init(rlnInstance, options) {
-        const rlnContract = new RLNContract(options);
+        const rlnContract = new RLNContract(rlnInstance, options);
         await rlnContract.fetchMembers(rlnInstance);
         rlnContract.subscribeToMembers(rlnInstance);
         return rlnContract;
@@ -27170,22 +27247,69 @@ class RLNContract {
             ...options,
             membersFilter: this.membersFilter,
         });
-        for (const event of registeredMemberEvents) {
-            this.addMemberFromEvent(rlnInstance, event);
-        }
+        this.processEvents(rlnInstance, registeredMemberEvents);
     }
-    subscribeToMembers(rlnInstance) {
-        this.contract.on(this.membersFilter, (_pubkey, _index, event) => this.addMemberFromEvent(rlnInstance, event));
+    processEvents(rlnInstance, events) {
+        const toRemoveTable = new Map();
+        const toInsertTable = new Map();
+        events.forEach((evt) => {
+            if (!evt.args) {
+                return;
+            }
+            if (evt.removed) {
+                const index = 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);
+        });
     }
-    addMemberFromEvent(rlnInstance, event) {
-        if (!event.args) {
-            return;
-        }
-        const pubkey = event.args.pubkey;
-        const index = event.args.index;
-        this.members.push({ index, pubkey });
-        const idCommitment = zeroPad(arrayify(pubkey), 32);
-        rlnInstance.insertMember(idCommitment);
+    insertMembers(rlnInstance, toInsert) {
+        toInsert.forEach((events, blockNumber) => {
+            events.forEach((evt) => {
+                if (!evt.args) {
+                    return;
+                }
+                const pubkey = evt.args.pubkey;
+                const index = evt.args.index;
+                const idCommitment = zeroPad(arrayify(pubkey), 32);
+                rlnInstance.insertMember(idCommitment);
+                this.members.push({ index, pubkey });
+            });
+            const currentRoot = rlnInstance.getMerkleRoot();
+            this.merkleRootTracker.pushRoot(blockNumber, currentRoot);
+        });
+    }
+    removeMembers(rlnInstance, toRemove) {
+        const removeDescending = new Map([...toRemove].sort().reverse());
+        removeDescending.forEach((indexes, blockNumber) => {
+            indexes.forEach((index) => {
+                const idx = this.members.findIndex((m) => m.index === index);
+                if (idx > -1) {
+                    this.members.splice(idx, 1);
+                }
+                rlnInstance.deleteMember(index);
+            });
+            this.merkleRootTracker.backFill(blockNumber);
+        });
+    }
+    subscribeToMembers(rlnInstance) {
+        this.contract.on(this.membersFilter, (_pubkey, _index, event) => this.processEvents(rlnInstance, event));
     }
     async registerWithSignature(rlnInstance, signature) {
         const identityCredential = await rlnInstance.generateSeededIdentityCredential(signature);
@@ -27199,6 +27323,9 @@ class RLNContract {
         const txRegisterReceipt = await txRegisterResponse.wait();
         return txRegisterReceipt?.events?.[0];
     }
+    roots() {
+        return this.merkleRootTracker.roots();
+    }
 }
 // these value should be tested on other networks
 const FETCH_CHUNK = 5;
@@ -27251,78 +27378,6 @@ function ignoreErrors(promise, defaultValue) {
     });
 }
 
-class RootPerBlock {
-    constructor(root, blockNumber) {
-        this.root = root;
-        this.blockNumber = blockNumber;
-    }
-}
-const maxBufferSize = 20;
-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);
-    }
-}
-
 // reexport the create function, dynamically imported from rln.ts
 async function create() {
     // A dependency graph that contains any wasm must all be imported
@@ -27332,4 +27387,4 @@ async function create() {
     return await rlnModule.create();
 }
 
-export { GOERLI_CONTRACT, IdentityCredential, MerkleRootTracker, Proof, ProofMetadata, RLNContract, RLNDecoder, RLNEncoder, RLNInstance, RLN_ABI, create };
+export { IdentityCredential, MerkleRootTracker, Proof, ProofMetadata, RLNContract, RLNDecoder, RLNEncoder, RLNInstance, RLN_ABI, SEPOLIA_CONTRACT, create };