@waku/rln 0.1.5-053bb95.0 → 0.1.5-1d384f2.0

package/bundle/packages/rln/dist/contract/rln_contract.js

@@ -5,122 +5,107 @@ import { hexToBytes } from '../../../utils/dist/bytes/index.js';
 import { Logger } from '../../../utils/dist/logger/index.js';
 import { MerkleRootTracker } from '../root_tracker.js';
 import { zeroPadLE } from '../utils/bytes.js';
-import { ContractStateError } from './errors.js';
 import { RLNBaseContract } from './rln_base_contract.js';
+import { BigNumber } from '../../../../node_modules/@ethersproject/bignumber/lib.esm/bignumber.js';
 
 const log = new Logger("waku:rln:contract");
 class RLNContract extends RLNBaseContract {
     instance;
     merkleRootTracker;
-    lastSyncedBlock = 0;
     /**
      * Asynchronous initializer for RLNContract.
      * Allows injecting a mocked contract for testing purposes.
      */
     static async init(rlnInstance, options) {
         const rlnContract = new RLNContract(rlnInstance, options);
-        await rlnContract.syncState();
         return rlnContract;
     }
-    /**
-     * Override base contract method to keep Merkle tree in sync
-     * Registers a new membership with the given commitment and rate limit
-     */
-    async registerMembership(idCommitment, rateLimit = this.getRateLimit()) {
-        await super.registerMembership(idCommitment, rateLimit);
-        await this.syncState();
-    }
-    /**
-     * Override base contract method to keep Merkle tree in sync
-     * Erases an existing membership from the contract
-     */
-    async eraseMembership(idCommitment, eraseFromMembershipSet = true) {
-        await super.eraseMembership(idCommitment, eraseFromMembershipSet);
-        await this.syncState();
-    }
-    /**
-     * Gets the current Merkle root
-     * Returns the latest valid root or empty array if no roots exist
-     */
-    async getMerkleRoot() {
-        await this.syncState();
-        const roots = this.merkleRootTracker.roots();
-        return roots.length > 0 ? roots[0] : new Uint8Array();
-    }
     constructor(rlnInstance, options) {
         super(options);
         this.instance = rlnInstance;
         const initialRoot = rlnInstance.zerokit.getMerkleRoot();
         this.merkleRootTracker = new MerkleRootTracker(5, initialRoot);
     }
-    /**
-     * Syncs the local Merkle tree with the current contract state
-     */
-    async syncState() {
-        try {
-            const currentBlock = await this.provider.getBlockNumber();
-            // If we're already synced, just get new members
-            if (this.lastSyncedBlock > 0) {
-                await this.syncNewMembers(this.lastSyncedBlock, currentBlock);
-                this.lastSyncedBlock = currentBlock;
+    processEvents(events) {
+        const toRemoveTable = new Map();
+        const toInsertTable = new Map();
+        events.forEach((evt) => {
+            if (!evt.args) {
                 return;
             }
-            // First time sync - get all members
-            const nextIndex = await this.contract.nextFreeIndex();
-            const members = await this.getMembersInRange(0, nextIndex.toNumber());
-            // Clear existing members by deleting them one by one
-            // This effectively resets the tree without needing resetTree()
-            for (let i = 0; i < nextIndex.toNumber(); i++) {
-                try {
-                    this.instance.zerokit.deleteMember(i);
+            if (evt.event === "MembershipErased" ||
+                evt.event === "MembershipExpired") {
+                let index = evt.args.index;
+                if (!index) {
+                    return;
                 }
-                catch (error) {
-                    // Ignore errors for non-existent members
-                    continue;
+                if (typeof index === "number" || typeof index === "string") {
+                    index = BigNumber.from(index);
+                }
+                else {
+                    log.error("Index is not a number or string", {
+                        index,
+                        event: evt
+                    });
+                    return;
+                }
+                const toRemoveVal = toRemoveTable.get(evt.blockNumber);
+                if (toRemoveVal != undefined) {
+                    toRemoveVal.push(index.toNumber());
+                    toRemoveTable.set(evt.blockNumber, toRemoveVal);
+                }
+                else {
+                    toRemoveTable.set(evt.blockNumber, [index.toNumber()]);
                 }
             }
-            // Insert all members
-            for (const member of members) {
-                const idCommitment = zeroPadLE(hexToBytes(member.idCommitment), 32);
-                this.instance.zerokit.insertMember(idCommitment);
+            else if (evt.event === "MembershipRegistered") {
+                let eventsPerBlock = toInsertTable.get(evt.blockNumber);
+                if (eventsPerBlock == undefined) {
+                    eventsPerBlock = [];
+                }
+                eventsPerBlock.push(evt);
+                toInsertTable.set(evt.blockNumber, eventsPerBlock);
             }
-            // Update root tracker
-            const currentRoot = this.instance.zerokit.getMerkleRoot();
-            this.merkleRootTracker.pushRoot(currentBlock, currentRoot);
-            this.lastSyncedBlock = currentBlock;
-            log.info(`Synced ${members.length} members to current block ${currentBlock}`);
-        }
-        catch (error) {
-            log.error("Failed to sync state", error);
-            throw new ContractStateError("Failed to sync contract state");
-        }
+        });
+        this.removeMembers(this.instance, toRemoveTable);
+        this.insertMembers(this.instance, toInsertTable);
     }
-    /**
-     * Syncs new members added between fromBlock and toBlock
-     */
-    async syncNewMembers(fromBlock, toBlock) {
-        // Get members that were added
-        const filter = this.contract.filters.MembershipRegistered();
-        const addEvents = await this.contract.queryFilter(filter, fromBlock, toBlock);
-        // Get members that were removed
-        const removeFilter = this.contract.filters.MembershipErased();
-        const removeEvents = await this.contract.queryFilter(removeFilter, fromBlock, toBlock);
-        // Process removals first (in reverse block order)
-        for (const evt of removeEvents.sort((a, b) => b.blockNumber - a.blockNumber)) {
-            if (!evt.args)
-                continue;
-            const index = evt.args.index.toNumber();
-            this.instance.zerokit.deleteMember(index);
-            this.merkleRootTracker.backFill(evt.blockNumber);
-        }
-        // Then process additions
-        for (const evt of addEvents) {
-            if (!evt.args)
-                continue;
-            const idCommitment = zeroPadLE(hexToBytes(evt.args.idCommitment), 32);
-            this.instance.zerokit.insertMember(idCommitment);
-            this.merkleRootTracker.pushRoot(evt.blockNumber, this.instance.zerokit.getMerkleRoot());
-        }
+    insertMembers(rlnInstance, toInsert) {
+        toInsert.forEach((events, blockNumber) => {
+            events.forEach((evt) => {
+                if (!evt.args)
+                    return;
+                const _idCommitment = evt.args.idCommitment;
+                let index = evt.args.index;
+                if (!_idCommitment || !index) {
+                    return;
+                }
+                if (typeof index === "number" || typeof index === "string") {
+                    index = BigNumber.from(index);
+                }
+                const idCommitment = zeroPadLE(hexToBytes(_idCommitment), 32);
+                rlnInstance.zerokit.insertMember(idCommitment);
+                const numericIndex = index.toNumber();
+                this._members.set(numericIndex, {
+                    index,
+                    idCommitment: _idCommitment
+                });
+            });
+            const currentRoot = rlnInstance.zerokit.getMerkleRoot();
+            this.merkleRootTracker.pushRoot(blockNumber, currentRoot);
+        });
+    }
+    removeMembers(rlnInstance, toRemove) {
+        const removeDescending = new Map([...toRemove].reverse());
+        removeDescending.forEach((indexes, blockNumber) => {
+            indexes.forEach((index) => {
+                if (this._members.has(index)) {
+                    this._members.delete(index);
+                    rlnInstance.zerokit.deleteMember(index);
+                }
+            });
+            this.merkleRootTracker.backFill(blockNumber);
+        });
     }
 }
 

package/bundle/packages/rln/dist/credentials_manager.js

@@ -126,7 +126,7 @@ class RLNCredentialsManager {
             options.address ||
             LINEA_CONTRACT.address;
         if (address === LINEA_CONTRACT.address) {
-            chainId = LINEA_CONTRACT.chainId;
+            chainId = LINEA_CONTRACT.chainId.toString();
             log.info(`Using Linea contract with chainId: ${chainId}`);
         }
         const signer = options.signer || (await extractMetaMaskSigner());

package/bundle/packages/rln/dist/identity.js

@@ -25,14 +25,6 @@ class IdentityCredential {
         const idCommitmentBigInt = buildBigIntFromUint8Array(idCommitment, 32);
         return new IdentityCredential(idTrapdoor, idNullifier, idSecretHash, idCommitment, idCommitmentBigInt);
     }
-    toJSON() {
-        return {
-            idTrapdoor: Array.from(this.IDTrapdoor),
-            idNullifier: Array.from(this.IDNullifier),
-            idSecretHash: Array.from(this.IDSecretHash),
-            idCommitment: Array.from(this.IDCommitment)
-        };
-    }
 }
 
 export { IdentityCredential };

package/bundle/packages/rln/dist/keystore/keystore.js

@@ -17,7 +17,6 @@ import { Logger } from '../../../utils/dist/logger/index.js';
 import { sha256 } from '../../../../node_modules/ethereum-cryptography/esm/sha256.js';
 import { bytesToUtf8 } from '../../../../node_modules/ethereum-cryptography/esm/utils.js';
 import _ from '../../../../node_modules/lodash/lodash.js';
-import { IdentityCredential } from '../identity.js';
 import { buildBigIntFromUint8Array } from '../utils/bytes.js';
 import { keccak256Checksum, decryptEipKeystore } from './cipher.js';
 import { isKeystoreValid, isCredentialValid } from './schema_validator.js';
@@ -165,15 +164,15 @@ class Keystore {
         try {
             const str = bytesToUtf8(bytes);
             const obj = JSON.parse(str);
-            // Get identity fields from named object
-            const { idTrapdoor, idNullifier, idSecretHash, idCommitment } = _.get(obj, "identityCredential", {});
-            const idTrapdoorArray = new Uint8Array(idTrapdoor || []);
-            const idNullifierArray = new Uint8Array(idNullifier || []);
-            const idSecretHashArray = new Uint8Array(idSecretHash || []);
-            const idCommitmentArray = new Uint8Array(idCommitment || []);
-            const idCommitmentBigInt = buildBigIntFromUint8Array(idCommitmentArray);
+            // TODO: add runtime validation of nwaku credentials
             return {
-                identity: new IdentityCredential(idTrapdoorArray, idNullifierArray, idSecretHashArray, idCommitmentArray, idCommitmentBigInt),
+                identity: {
+                    IDCommitment: Keystore.fromArraylikeToBytes(_.get(obj, "identityCredential.idCommitment", [])),
+                    IDTrapdoor: Keystore.fromArraylikeToBytes(_.get(obj, "identityCredential.idTrapdoor", [])),
+                    IDNullifier: Keystore.fromArraylikeToBytes(_.get(obj, "identityCredential.idNullifier", [])),
+                    IDCommitmentBigInt: buildBigIntFromUint8Array(Keystore.fromArraylikeToBytes(_.get(obj, "identityCredential.idCommitment", []))),
+                    IDSecretHash: Keystore.fromArraylikeToBytes(_.get(obj, "identityCredential.idSecretHash", []))
+                },
                 membership: {
                     treeIndex: _.get(obj, "treeIndex"),
                     chainId: _.get(obj, "membershipContract.chainId"),
@@ -187,6 +186,20 @@ class Keystore {
             return;
         }
     }
+    static fromArraylikeToBytes(obj) {
+        if (Array.isArray(obj)) {
+            return new Uint8Array(obj);
+        }
+        const bytes = [];
+        let index = 0;
+        let lastElement = obj[index];
+        while (lastElement !== undefined) {
+            bytes.push(lastElement);
+            index += 1;
+            lastElement = obj[index];
+        }
+        return new Uint8Array(bytes);
+    }
     // follows nwaku implementation
     // https://github.com/waku-org/nwaku/blob/f05528d4be3d3c876a8b07f9bb7dfaae8aa8ec6e/waku/waku_keystore/protocol_types.nim#L111
     static computeMembershipHash(info) {
@@ -196,16 +209,16 @@ class Keystore {
     // https://github.com/waku-org/nwaku/blob/f05528d4be3d3c876a8b07f9bb7dfaae8aa8ec6e/waku/waku_keystore/protocol_types.nim#L98
     static fromIdentityToBytes(options) {
         return utf8ToBytes(JSON.stringify({
-            membershipContract: {
-                chainId: options.membership.chainId,
-                address: options.membership.address
-            },
             treeIndex: options.membership.treeIndex,
             identityCredential: {
-                idTrapdoor: Array.from(options.identity.IDTrapdoor),
+                idCommitment: Array.from(options.identity.IDCommitment),
                 idNullifier: Array.from(options.identity.IDNullifier),
                 idSecretHash: Array.from(options.identity.IDSecretHash),
-                idCommitment: Array.from(options.identity.IDCommitment)
+                idTrapdoor: Array.from(options.identity.IDTrapdoor)
+            },
+            membershipContract: {
+                chainId: options.membership.chainId,
+                address: options.membership.address
             },
             userMessageLimit: options.membership.rateLimit
         }));

package/bundle/packages/rln/node_modules/@chainsafe/bls-keystore/node_modules/ethereum-cryptography/random.js

@@ -1,6 +1,6 @@
 import { __exports as random } from '../../../../../../../_virtual/random.js';
 import '../../../../@noble/hashes/utils.js';
-import { __exports as utils } from '../../../../../../../_virtual/utils2.js';
+import { __exports as utils } from '../../../../../../../_virtual/utils.js';
 
 Object.defineProperty(random, "__esModule", { value: true });
 random.getRandomBytes = random.getRandomBytesSync = void 0;

package/bundle/packages/rln/node_modules/@chainsafe/bls-keystore/node_modules/ethereum-cryptography/utils.js

@@ -1,10 +1,10 @@
 import { commonjsGlobal } from '../../../../../../../_virtual/_commonjsHelpers.js';
 import { commonjsRequire } from '../../../../../../../_virtual/_commonjs-dynamic-modules.js';
-import { __module as utils } from '../../../../../../../_virtual/utils.js';
+import { __module as utils } from '../../../../../../../_virtual/utils2.js';
 import '../../../../@noble/hashes/_assert.js';
 import '../../../../@noble/hashes/utils.js';
 import { __exports as _assert } from '../../../../../../../_virtual/_assert.js';
-import { __exports as utils$1 } from '../../../../../../../_virtual/utils2.js';
+import { __exports as utils$1 } from '../../../../../../../_virtual/utils.js';
 
 utils.exports;
 

package/bundle/packages/rln/node_modules/@noble/hashes/_sha2.js

@@ -1,7 +1,7 @@
 import { __exports as _sha2 } from '../../../../../_virtual/_sha2.js';
 import './_assert.js';
 import './utils.js';
-import { __exports as utils } from '../../../../../_virtual/utils2.js';
+import { __exports as utils } from '../../../../../_virtual/utils.js';
 import { __exports as _assert } from '../../../../../_virtual/_assert.js';
 
 Object.defineProperty(_sha2, "__esModule", { value: true });

package/bundle/packages/rln/node_modules/@noble/hashes/hmac.js

@@ -1,7 +1,7 @@
 import { __exports as hmac } from '../../../../../_virtual/hmac.js';
 import './_assert.js';
 import './utils.js';
-import { __exports as utils } from '../../../../../_virtual/utils2.js';
+import { __exports as utils } from '../../../../../_virtual/utils.js';
 import { __exports as _assert } from '../../../../../_virtual/_assert.js';
 
 (function (exports) {

package/bundle/packages/rln/node_modules/@noble/hashes/pbkdf2.js

@@ -2,7 +2,7 @@ import { __exports as pbkdf2$1 } from '../../../../../_virtual/pbkdf22.js';
 import './_assert.js';
 import './hmac.js';
 import './utils.js';
-import { __exports as utils } from '../../../../../_virtual/utils2.js';
+import { __exports as utils } from '../../../../../_virtual/utils.js';
 import { __exports as _assert } from '../../../../../_virtual/_assert.js';
 import { __exports as hmac } from '../../../../../_virtual/hmac.js';
 

package/bundle/packages/rln/node_modules/@noble/hashes/scrypt.js

@@ -3,7 +3,7 @@ import './_assert.js';
 import './sha256.js';
 import './pbkdf2.js';
 import './utils.js';
-import { __exports as utils } from '../../../../../_virtual/utils2.js';
+import { __exports as utils } from '../../../../../_virtual/utils.js';
 import { __exports as _assert } from '../../../../../_virtual/_assert.js';
 import { __exports as pbkdf2 } from '../../../../../_virtual/pbkdf22.js';
 import { __exports as sha256 } from '../../../../../_virtual/sha2562.js';

package/bundle/packages/rln/node_modules/@noble/hashes/sha256.js

@@ -2,7 +2,7 @@ import { __exports as sha256 } from '../../../../../_virtual/sha2562.js';
 import './_sha2.js';
 import './utils.js';
 import { __exports as _sha2 } from '../../../../../_virtual/_sha2.js';
-import { __exports as utils } from '../../../../../_virtual/utils2.js';
+import { __exports as utils } from '../../../../../_virtual/utils.js';
 
 Object.defineProperty(sha256, "__esModule", { value: true });
 sha256.sha224 = sha256.sha256 = void 0;

package/bundle/packages/rln/node_modules/@noble/hashes/sha512.js

@@ -4,7 +4,7 @@ import './_u64.js';
 import './utils.js';
 import { __exports as _u64 } from '../../../../../_virtual/_u64.js';
 import { __exports as _sha2 } from '../../../../../_virtual/_sha2.js';
-import { __exports as utils } from '../../../../../_virtual/utils2.js';
+import { __exports as utils } from '../../../../../_virtual/utils.js';
 
 Object.defineProperty(sha512, "__esModule", { value: true });
 sha512.sha384 = sha512.sha512_256 = sha512.sha512_224 = sha512.sha512 = sha512.SHA512 = void 0;

package/bundle/packages/rln/node_modules/@noble/hashes/utils.js

@@ -1,4 +1,4 @@
-import { __exports as utils } from '../../../../../_virtual/utils2.js';
+import { __exports as utils } from '../../../../../_virtual/utils.js';
 import './cryptoBrowser.js';
 import { __exports as cryptoBrowser } from '../../../../../_virtual/cryptoBrowser.js';