@waku/rln 0.1.5-ff0222a.0 → 0.1.6-b7e9b08.0

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

@@ -0,0 +1,215 @@
+import { hmac } from '../../../node_modules/@noble/hashes/esm/hmac.js';
+import { sha256 } from '../../../node_modules/@noble/hashes/esm/sha256.js';
+import '../../utils/node_modules/@waku/interfaces/dist/protocols.js';
+import '../../utils/node_modules/@waku/interfaces/dist/connection_manager.js';
+import '../../utils/node_modules/@waku/interfaces/dist/health_indicator.js';
+import '../../../node_modules/multiformats/dist/src/bases/base10.js';
+import '../../../node_modules/multiformats/dist/src/bases/base16.js';
+import '../../../node_modules/multiformats/dist/src/bases/base2.js';
+import '../../../node_modules/multiformats/dist/src/bases/base256emoji.js';
+import '../../../node_modules/multiformats/dist/src/bases/base32.js';
+import '../../../node_modules/multiformats/dist/src/bases/base36.js';
+import '../../../node_modules/multiformats/dist/src/bases/base58.js';
+import '../../../node_modules/multiformats/dist/src/bases/base64.js';
+import '../../../node_modules/multiformats/dist/src/bases/base8.js';
+import '../../../node_modules/multiformats/dist/src/bases/identity.js';
+import '../../../node_modules/multiformats/dist/src/codecs/json.js';
+import { Logger } from '../../utils/dist/logger/index.js';
+import { LINEA_CONTRACT } from './contract/constants.js';
+import { RLNBaseContract } from './contract/rln_base_contract.js';
+import { IdentityCredential } from './identity.js';
+import { Keystore } from './keystore/keystore.js';
+import { extractMetaMaskSigner } from './utils/metamask.js';
+import { buildBigIntFromUint8Array } from './utils/bytes.js';
+import './utils/epoch.js';
+
+const log = new Logger("waku:credentials");
+/**
+ * Manages credentials for RLN
+ * This is a lightweight implementation of the RLN contract that doesn't require Zerokit
+ * It is used to register membership and generate identity credentials
+ */
+class RLNCredentialsManager {
+    started = false;
+    starting = false;
+    contract;
+    signer;
+    keystore = Keystore.create();
+    credentials;
+    zerokit;
+    constructor(zerokit) {
+        log.info("RLNCredentialsManager initialized");
+        this.zerokit = zerokit;
+    }
+    get provider() {
+        return this.contract?.provider;
+    }
+    async start(options = {}) {
+        if (this.started || this.starting) {
+            log.info("RLNCredentialsManager already started or starting");
+            return;
+        }
+        log.info("Starting RLNCredentialsManager");
+        this.starting = true;
+        try {
+            const { credentials, keystore } = await RLNCredentialsManager.decryptCredentialsIfNeeded(options.credentials);
+            if (credentials) {
+                log.info("Credentials successfully decrypted");
+            }
+            const { signer, address, rateLimit } = await this.determineStartOptions(options, credentials);
+            log.info(`Using contract address: ${address}`);
+            if (keystore) {
+                this.keystore = keystore;
+                log.info("Using provided keystore");
+            }
+            this.credentials = credentials;
+            this.signer = signer;
+            this.contract = new RLNBaseContract({
+                address: address,
+                signer: signer,
+                rateLimit: rateLimit ?? this.zerokit?.rateLimit
+            });
+            log.info("RLNCredentialsManager successfully started");
+            this.started = true;
+        }
+        catch (error) {
+            log.error("Failed to start RLNCredentialsManager", error);
+            throw error;
+        }
+        finally {
+            this.starting = false;
+        }
+    }
+    async registerMembership(options) {
+        if (!this.contract) {
+            log.error("RLN Contract is not initialized");
+            throw Error("RLN Contract is not initialized.");
+        }
+        log.info("Registering membership");
+        let identity = "identity" in options && options.identity;
+        if ("signature" in options) {
+            log.info("Generating identity from signature");
+            if (this.zerokit) {
+                log.info("Using Zerokit to generate identity");
+                identity = this.zerokit.generateSeededIdentityCredential(options.signature);
+            }
+            else {
+                log.info("Using local implementation to generate identity");
+                identity = this.generateSeededIdentityCredential(options.signature);
+            }
+        }
+        if (!identity) {
+            log.error("Missing signature or identity to register membership");
+            throw Error("Missing signature or identity to register membership.");
+        }
+        log.info("Registering identity with contract");
+        return this.contract.registerWithIdentity(identity);
+    }
+    /**
+     * Changes credentials in use by relying on provided Keystore earlier in rln.start
+     * @param id: string, hash of credentials to select from Keystore
+     * @param password: string or bytes to use to decrypt credentials from Keystore
+     */
+    async useCredentials(id, password) {
+        log.info(`Attempting to use credentials with ID: ${id}`);
+        this.credentials = await this.keystore?.readCredential(id, password);
+        if (this.credentials) {
+            log.info("Successfully loaded credentials");
+        }
+        else {
+            log.warn("Failed to load credentials");
+        }
+    }
+    async determineStartOptions(options, credentials) {
+        let chainId = credentials?.membership.chainId;
+        const address = credentials?.membership.address ||
+            options.address ||
+            LINEA_CONTRACT.address;
+        if (address === LINEA_CONTRACT.address) {
+            chainId = LINEA_CONTRACT.chainId.toString();
+            log.info(`Using Linea contract with chainId: ${chainId}`);
+        }
+        const signer = options.signer || (await extractMetaMaskSigner());
+        const currentChainId = await signer.getChainId();
+        log.info(`Current chain ID: ${currentChainId}`);
+        if (chainId && chainId !== currentChainId.toString()) {
+            log.error(`Chain ID mismatch: contract=${chainId}, current=${currentChainId}`);
+            throw Error(`Failed to start RLN contract, chain ID of contract is different from current one: contract-${chainId}, current network-${currentChainId}`);
+        }
+        return {
+            signer,
+            address
+        };
+    }
+    static async decryptCredentialsIfNeeded(credentials) {
+        if (!credentials) {
+            log.info("No credentials provided");
+            return {};
+        }
+        if ("identity" in credentials) {
+            log.info("Using already decrypted credentials");
+            return { credentials };
+        }
+        log.info("Attempting to decrypt credentials");
+        const keystore = Keystore.fromString(credentials.keystore);
+        if (!keystore) {
+            log.warn("Failed to create keystore from string");
+            return {};
+        }
+        try {
+            const decryptedCredentials = await keystore.readCredential(credentials.id, credentials.password);
+            log.info(`Successfully decrypted credentials with ID: ${credentials.id}`);
+            return {
+                keystore,
+                credentials: decryptedCredentials
+            };
+        }
+        catch (error) {
+            log.error("Failed to decrypt credentials", error);
+            throw error;
+        }
+    }
+    async verifyCredentialsAgainstContract(credentials) {
+        if (!this.contract) {
+            throw Error("Failed to verify chain coordinates: no contract initialized.");
+        }
+        const registryAddress = credentials.membership.address;
+        const currentRegistryAddress = this.contract.address;
+        if (registryAddress !== currentRegistryAddress) {
+            throw Error(`Failed to verify chain coordinates: credentials contract address=${registryAddress} is not equal to registryContract address=${currentRegistryAddress}`);
+        }
+        const chainId = credentials.membership.chainId;
+        const network = await this.contract.provider.getNetwork();
+        const currentChainId = network.chainId;
+        if (chainId !== currentChainId.toString()) {
+            throw Error(`Failed to verify chain coordinates: credentials chainID=${chainId} is not equal to registryContract chainID=${currentChainId}`);
+        }
+    }
+    /**
+     * Generates an identity credential from a seed string
+     * This is a pure implementation that doesn't rely on Zerokit
+     * @param seed A string seed to generate the identity from
+     * @returns IdentityCredential
+     */
+    generateSeededIdentityCredential(seed) {
+        log.info("Generating seeded identity credential");
+        // Convert the seed to bytes
+        const encoder = new TextEncoder();
+        const seedBytes = encoder.encode(seed);
+        // Generate deterministic values using HMAC-SHA256
+        // We use different context strings for each component to ensure they're different
+        const idTrapdoor = hmac(sha256, seedBytes, encoder.encode("IDTrapdoor"));
+        const idNullifier = hmac(sha256, seedBytes, encoder.encode("IDNullifier"));
+        // Generate IDSecretHash as a hash of IDTrapdoor and IDNullifier
+        const combinedBytes = new Uint8Array([...idTrapdoor, ...idNullifier]);
+        const idSecretHash = sha256(combinedBytes);
+        // Generate IDCommitment as a hash of IDSecretHash
+        const idCommitment = sha256(idSecretHash);
+        // Convert IDCommitment to BigInt
+        const idCommitmentBigInt = buildBigIntFromUint8Array(idCommitment);
+        log.info("Successfully generated identity credential");
+        return new IdentityCredential(idTrapdoor, idNullifier, idSecretHash, idCommitment, idCommitmentBigInt);
+    }
+}
+
+export { RLNCredentialsManager };

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

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

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

@@ -1,6 +1,6 @@
-import { cipherDecrypt as cipherDecrypt_1 } from '../../node_modules/@chainsafe/bls-keystore/lib/cipher.js';
-import { kdf as kdf_2 } from '../../node_modules/@chainsafe/bls-keystore/lib/kdf.js';
-import { normalizePassword as normalizePassword_1 } from '../../node_modules/@chainsafe/bls-keystore/lib/password.js';
+import { cipherDecrypt as cipherDecrypt_1 } from '../../../../node_modules/@chainsafe/bls-keystore/lib/cipher.js';
+import { kdf as kdf_2 } from '../../../../node_modules/@chainsafe/bls-keystore/lib/kdf.js';
+import { normalizePassword as normalizePassword_1 } from '../../../../node_modules/@chainsafe/bls-keystore/lib/password.js';
 import { keccak256 } from '../../../../node_modules/ethereum-cryptography/esm/keccak.js';
 import { hexToBytes } from '../../../../node_modules/ethereum-cryptography/esm/utils.js';
 import { concatBytes, bytesToHex } from '../../../../node_modules/@noble/hashes/esm/utils.js';

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

@@ -1,7 +1,7 @@
-import '../../node_modules/@chainsafe/bls-keystore/lib/index.js';
-import '../../../interfaces/dist/protocols.js';
-import '../../../interfaces/dist/connection_manager.js';
-import '../../../interfaces/dist/health_indicator.js';
+import '../../../../node_modules/@chainsafe/bls-keystore/lib/index.js';
+import '../../../utils/node_modules/@waku/interfaces/dist/protocols.js';
+import '../../../utils/node_modules/@waku/interfaces/dist/connection_manager.js';
+import '../../../utils/node_modules/@waku/interfaces/dist/health_indicator.js';
 import '../../../../node_modules/multiformats/dist/src/bases/base10.js';
 import '../../../../node_modules/multiformats/dist/src/bases/base16.js';
 import '../../../../node_modules/multiformats/dist/src/bases/base2.js';
@@ -17,12 +17,11 @@ 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';
 import { __exports as lib } from '../../../../_virtual/index.js';
-import v4 from '../../node_modules/uuid/dist/esm-browser/v4.js';
+import v4 from '../../../../node_modules/uuid/dist/esm-browser/v4.js';
 import { bytesToHex, utf8ToBytes } from '../../../../node_modules/@noble/hashes/esm/utils.js';
 
 const log = new Logger("waku:rln:keystore");
@@ -165,20 +164,20 @@ 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"),
                     address: _.get(obj, "membershipContract.address"),
-                    rateLimit: _.get(obj, "membershipContract.rateLimit")
+                    rateLimit: _.get(obj, "userMessageLimit")
                 }
             };
         }
@@ -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) {
@@ -198,15 +211,16 @@ class Keystore {
         return utf8ToBytes(JSON.stringify({
             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/dist/rln.js

@@ -3,9 +3,9 @@ import '../../core/dist/lib/filter/filter.js';
 import '../../core/dist/lib/light_push/light_push.js';
 import '../../core/dist/lib/store/store.js';
 import '../../core/dist/lib/connection_manager/connection_manager.js';
-import '../../interfaces/dist/protocols.js';
-import '../../interfaces/dist/connection_manager.js';
-import '../../interfaces/dist/health_indicator.js';
+import '../../utils/node_modules/@waku/interfaces/dist/protocols.js';
+import '../../utils/node_modules/@waku/interfaces/dist/connection_manager.js';
+import '../../utils/node_modules/@waku/interfaces/dist/health_indicator.js';
 import '../../../node_modules/multiformats/dist/src/bases/base10.js';
 import '../../../node_modules/multiformats/dist/src/bases/base16.js';
 import '../../../node_modules/multiformats/dist/src/bases/base2.js';
@@ -21,167 +21,45 @@ import { Logger } from '../../utils/dist/logger/index.js';
 import '../../core/dist/lib/metadata/metadata.js';
 import __wbg_init, { init_panic_hook, newRLN } from '../../../node_modules/@waku/zerokit-rln-wasm/rln_wasm.js';
 import { createRLNEncoder, createRLNDecoder } from './codec.js';
-import { LINEA_CONTRACT, DEFAULT_RATE_LIMIT } from './contract/constants.js';
-import { RLNContract } from './contract/rln_contract.js';
-import { Keystore } from './keystore/keystore.js';
+import { DEFAULT_RATE_LIMIT } from './contract/constants.js';
+import { RLNCredentialsManager } from './credentials_manager.js';
 import verificationKey from './resources/verification_key.js';
 import { builder } from './resources/witness_calculator.js';
-import { extractMetaMaskSigner } from './utils/metamask.js';
-import './utils/epoch.js';
 import { Zerokit } from './zerokit.js';
 
 const log = new Logger("waku:rln");
-async function loadWitnessCalculator() {
-    try {
-        const url = new URL("./resources/rln.wasm", import.meta.url);
-        const response = await fetch(url);
-        if (!response.ok) {
-            throw new Error(`Failed to fetch witness calculator: ${response.status} ${response.statusText}`);
-        }
-        return await builder(new Uint8Array(await response.arrayBuffer()), false);
-    }
-    catch (error) {
-        log.error("Error loading witness calculator:", error);
-        throw new Error(`Failed to load witness calculator: ${error instanceof Error ? error.message : String(error)}`);
-    }
-}
-async function loadZkey() {
-    try {
-        const url = new URL("./resources/rln_final.zkey", import.meta.url);
-        const response = await fetch(url);
-        if (!response.ok) {
-            throw new Error(`Failed to fetch zkey: ${response.status} ${response.statusText}`);
-        }
-        return new Uint8Array(await response.arrayBuffer());
-    }
-    catch (error) {
-        log.error("Error loading zkey:", error);
-        throw new Error(`Failed to load zkey: ${error instanceof Error ? error.message : String(error)}`);
-    }
-}
-/**
- * Create an instance of RLN
- * @returns RLNInstance
- */
-async function create() {
-    try {
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        await __wbg_init?.();
-        init_panic_hook();
-        const witnessCalculator = await loadWitnessCalculator();
-        const zkey = await loadZkey();
-        const stringEncoder = new TextEncoder();
-        const vkey = stringEncoder.encode(JSON.stringify(verificationKey));
-        const DEPTH = 20;
-        const zkRLN = newRLN(DEPTH, zkey, vkey);
-        const zerokit = new Zerokit(zkRLN, witnessCalculator, DEFAULT_RATE_LIMIT);
-        return new RLNInstance(zerokit);
-    }
-    catch (error) {
-        log.error("Failed to initialize RLN:", error);
-        throw error;
-    }
-}
-class RLNInstance {
+class RLNInstance extends RLNCredentialsManager {
     zerokit;
-    started = false;
-    starting = false;
-    _contract;
-    _signer;
-    keystore = Keystore.create();
-    _credentials;
-    constructor(zerokit) {
-        this.zerokit = zerokit;
-    }
-    get contract() {
-        return this._contract;
-    }
-    get signer() {
-        return this._signer;
-    }
-    async start(options = {}) {
-        if (this.started || this.starting) {
-            return;
-        }
-        this.starting = true;
+    /**
+     * Create an instance of RLN
+     * @returns RLNInstance
+     */
+    static async create() {
         try {
-            const { credentials, keystore } = await RLNInstance.decryptCredentialsIfNeeded(options.credentials);
-            const { signer, address, rateLimit } = await this.determineStartOptions(options, credentials);
-            if (keystore) {
-                this.keystore = keystore;
-            }
-            this._credentials = credentials;
-            this._signer = signer;
-            this._contract = await RLNContract.init(this, {
-                address: address,
-                signer: signer,
-                rateLimit: rateLimit ?? this.zerokit.getRateLimit
-            });
-            this.started = true;
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            await __wbg_init?.();
+            init_panic_hook();
+            const witnessCalculator = await RLNInstance.loadWitnessCalculator();
+            const zkey = await RLNInstance.loadZkey();
+            const stringEncoder = new TextEncoder();
+            const vkey = stringEncoder.encode(JSON.stringify(verificationKey));
+            const DEPTH = 20;
+            const zkRLN = newRLN(DEPTH, zkey, vkey);
+            const zerokit = new Zerokit(zkRLN, witnessCalculator, DEFAULT_RATE_LIMIT);
+            return new RLNInstance(zerokit);
+        }
+        catch (error) {
+            log.error("Failed to initialize RLN:", error);
+            throw error;
         }
-        finally {
-            this.starting = false;
-        }
-    }
-    async determineStartOptions(options, credentials) {
-        let chainId = credentials?.membership.chainId;
-        const address = credentials?.membership.address ||
-            options.address ||
-            LINEA_CONTRACT.address;
-        if (address === LINEA_CONTRACT.address) {
-            chainId = LINEA_CONTRACT.chainId;
-        }
-        const signer = options.signer || (await extractMetaMaskSigner());
-        const currentChainId = (await signer.getChainId()).toString();
-        if (chainId && chainId !== currentChainId) {
-            throw Error(`Failed to start RLN contract, chain ID of contract is different from current one: contract-${chainId}, current network-${currentChainId}`);
-        }
-        return {
-            signer,
-            address
-        };
     }
-    static async decryptCredentialsIfNeeded(credentials) {
-        if (!credentials) {
-            return {};
-        }
-        if ("identity" in credentials) {
-            return { credentials };
-        }
-        const keystore = Keystore.fromString(credentials.keystore);
-        if (!keystore) {
-            return {};
-        }
-        const decryptedCredentials = await keystore.readCredential(credentials.id, credentials.password);
-        return {
-            keystore,
-            credentials: decryptedCredentials
-        };
-    }
-    async registerMembership(options) {
-        if (!this.contract) {
-            throw Error("RLN Contract is not initialized.");
-        }
-        let identity = "identity" in options && options.identity;
-        if ("signature" in options) {
-            identity = this.zerokit.generateSeededIdentityCredential(options.signature);
-        }
-        if (!identity) {
-            throw Error("Missing signature or identity to register membership.");
-        }
-        return this.contract.registerWithIdentity(identity);
-    }
-    /**
-     * Changes credentials in use by relying on provided Keystore earlier in rln.start
-     * @param id: string, hash of credentials to select from Keystore
-     * @param password: string or bytes to use to decrypt credentials from Keystore
-     */
-    async useCredentials(id, password) {
-        this._credentials = await this.keystore?.readCredential(id, password);
+    constructor(zerokit) {
+        super(zerokit);
+        this.zerokit = zerokit;
     }
     async createEncoder(options) {
         const { credentials: decryptedCredentials } = await RLNInstance.decryptCredentialsIfNeeded(options.credentials);
-        const credentials = decryptedCredentials || this._credentials;
+        const credentials = decryptedCredentials || this.credentials;
         if (!credentials) {
             throw Error("Failed to create Encoder: missing RLN credentials. Use createRLNEncoder directly.");
         }
@@ -193,28 +71,40 @@ class RLNInstance {
             credential: credentials.identity
         });
     }
-    async verifyCredentialsAgainstContract(credentials) {
-        if (!this._contract) {
-            throw Error("Failed to verify chain coordinates: no contract initialized.");
-        }
-        const registryAddress = credentials.membership.address;
-        const currentRegistryAddress = this._contract.address;
-        if (registryAddress !== currentRegistryAddress) {
-            throw Error(`Failed to verify chain coordinates: credentials contract address=${registryAddress} is not equal to registryContract address=${currentRegistryAddress}`);
-        }
-        const chainId = credentials.membership.chainId;
-        const network = await this._contract.provider.getNetwork();
-        const currentChainId = network.chainId.toString();
-        if (chainId !== currentChainId) {
-            throw Error(`Failed to verify chain coordinates: credentials chainID=${chainId} is not equal to registryContract chainID=${currentChainId}`);
-        }
-    }
     createDecoder(contentTopic) {
         return createRLNDecoder({
             rlnInstance: this,
             decoder: createDecoder(contentTopic)
         });
     }
+    static async loadWitnessCalculator() {
+        try {
+            const url = new URL("./resources/rln.wasm", import.meta.url);
+            const response = await fetch(url);
+            if (!response.ok) {
+                throw new Error(`Failed to fetch witness calculator: ${response.status} ${response.statusText}`);
+            }
+            return await builder(new Uint8Array(await response.arrayBuffer()), false);
+        }
+        catch (error) {
+            log.error("Error loading witness calculator:", error);
+            throw new Error(`Failed to load witness calculator: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    static async loadZkey() {
+        try {
+            const url = new URL("./resources/rln_final.zkey", import.meta.url);
+            const response = await fetch(url);
+            if (!response.ok) {
+                throw new Error(`Failed to fetch zkey: ${response.status} ${response.statusText}`);
+            }
+            return new Uint8Array(await response.arrayBuffer());
+        }
+        catch (error) {
+            log.error("Error loading zkey:", error);
+            throw new Error(`Failed to load zkey: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
 }
 
-export { RLNInstance, create };
+export { RLNInstance };

package/bundle/packages/rln/dist/utils/epoch.js

@@ -1,6 +1,6 @@
-import '../../../interfaces/dist/protocols.js';
-import '../../../interfaces/dist/connection_manager.js';
-import '../../../interfaces/dist/health_indicator.js';
+import '../../../utils/node_modules/@waku/interfaces/dist/protocols.js';
+import '../../../utils/node_modules/@waku/interfaces/dist/connection_manager.js';
+import '../../../utils/node_modules/@waku/interfaces/dist/health_indicator.js';
 import '../../../../node_modules/multiformats/dist/src/bases/base10.js';
 import '../../../../node_modules/multiformats/dist/src/bases/base16.js';
 import '../../../../node_modules/multiformats/dist/src/bases/base2.js';

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

@@ -8,11 +8,11 @@ import { epochIntToBytes, dateToEpoch } from './utils/epoch.js';
 class Zerokit {
     zkRLN;
     witnessCalculator;
-    rateLimit;
-    constructor(zkRLN, witnessCalculator, rateLimit = DEFAULT_RATE_LIMIT) {
+    _rateLimit;
+    constructor(zkRLN, witnessCalculator, _rateLimit = DEFAULT_RATE_LIMIT) {
         this.zkRLN = zkRLN;
         this.witnessCalculator = witnessCalculator;
-        this.rateLimit = rateLimit;
+        this._rateLimit = _rateLimit;
     }
     get getZkRLN() {
         return this.zkRLN;
@@ -20,8 +20,8 @@ class Zerokit {
     get getWitnessCalculator() {
         return this.witnessCalculator;
     }
-    get getRateLimit() {
-        return this.rateLimit;
+    get rateLimit() {
+        return this._rateLimit;
     }
     generateIdentityCredentials() {
         const memKeys = generateExtendedMembershipKey(this.zkRLN); // TODO: rename this function in zerokit rln-wasm

package/bundle/packages/utils/dist/common/sharding/index.js

@@ -1,8 +1,8 @@
 import { sha256 } from '../../../../../node_modules/@noble/hashes/esm/sha256.js';
-import '../../../../interfaces/dist/protocols.js';
-import '../../../../interfaces/dist/connection_manager.js';
-import { DEFAULT_CLUSTER_ID } from '../../../../interfaces/dist/constants.js';
-import '../../../../interfaces/dist/health_indicator.js';
+import '../../../node_modules/@waku/interfaces/dist/protocols.js';
+import '../../../node_modules/@waku/interfaces/dist/connection_manager.js';
+import { DEFAULT_CLUSTER_ID } from '../../../node_modules/@waku/interfaces/dist/constants.js';
+import '../../../node_modules/@waku/interfaces/dist/health_indicator.js';
 import { concat, utf8ToBytes } from '../../bytes/index.js';
 
 const singleShardInfoToPubsubTopic = (shardInfo) => {