@waku/rln 0.1.5-861a776.0 → 0.1.5-9901863.0

package/bundle/packages/rln/dist/{rln_light.js → credentials_manager.js}

@@ -16,54 +16,127 @@ 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 { RLNLightContract } from './contract/rln_light_contract.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';
 
-new Logger("waku:rln");
-class RLNLightInstance {
+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;
-    constructor() { }
+    zerokit;
+    constructor(zerokit) {
+        log.info("RLNCredentialsManager initialized");
+        this.zerokit = zerokit;
+    }
     get contract() {
         return this._contract;
     }
+    set contract(contract) {
+        this._contract = contract;
+    }
     get signer() {
         return this._signer;
     }
+    set signer(signer) {
+        this._signer = signer;
+    }
+    get credentials() {
+        return this._credentials;
+    }
+    set credentials(credentials) {
+        this._credentials = credentials;
+    }
+    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 RLNLightInstance.decryptCredentialsIfNeeded(options.credentials);
+            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 = await RLNLightContract.init({
+            this._contract = new RLNBaseContract({
                 address: address,
                 signer: signer,
-                rateLimit: rateLimit
+                rateLimit: rateLimit ?? this.zerokit?.getRateLimit
             });
+            log.info("RLNCredentialsManager successfully started");
             this.started = true;
         }
+        catch (error) {
+            log.error("Failed to start RLNCredentialsManager", error);
+            throw error;
+        }
         finally {
             this.starting = false;
         }
     }
-    get credentials() {
-        return this._credentials;
+    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;
@@ -72,10 +145,13 @@ class RLNLightInstance {
             LINEA_CONTRACT.address;
         if (address === LINEA_CONTRACT.address) {
             chainId = LINEA_CONTRACT.chainId;
+            log.info(`Using Linea contract with chainId: ${chainId}`);
         }
         const signer = options.signer || (await extractMetaMaskSigner());
-        const currentChainId = (await signer.getChainId()).toString();
-        if (chainId && chainId !== currentChainId) {
+        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 {
@@ -85,20 +161,47 @@ class RLNLightInstance {
     }
     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 {};
         }
-        const decryptedCredentials = await keystore.readCredential(credentials.id, credentials.password);
-        return {
-            keystore,
-            credentials: decryptedCredentials
-        };
+        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
@@ -107,6 +210,7 @@ class RLNLightInstance {
      * @returns IdentityCredential
      */
     generateSeededIdentityCredential(seed) {
+        log.info("Generating seeded identity credential");
         // Convert the seed to bytes
         const encoder = new TextEncoder();
         const seedBytes = encoder.encode(seed);
@@ -121,29 +225,9 @@ class RLNLightInstance {
         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);
     }
-    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.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);
-    }
 }
 
-export { RLNLightInstance };
+export { RLNCredentialsManager };

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

@@ -26,13 +26,12 @@ class IdentityCredential {
         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()
-        ];
+        return {
+            idTrapdoor: Array.from(this.IDTrapdoor),
+            idNullifier: Array.from(this.IDNullifier),
+            idSecretHash: Array.from(this.IDSecretHash),
+            idCommitment: Array.from(this.IDCommitment)
+        };
     }
 }
 

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

@@ -165,8 +165,8 @@ class Keystore {
         try {
             const str = bytesToUtf8(bytes);
             const obj = JSON.parse(str);
-            // Get identity arrays
-            const [idTrapdoor, idNullifier, idSecretHash, idCommitment] = _.get(obj, "identityCredential", []);
+            // 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 || []);
@@ -178,7 +178,7 @@ class Keystore {
                     treeIndex: _.get(obj, "treeIndex"),
                     chainId: _.get(obj, "membershipContract.chainId"),
                     address: _.get(obj, "membershipContract.address"),
-                    rateLimit: _.get(obj, "membershipContract.rateLimit")
+                    rateLimit: _.get(obj, "userMessageLimit")
                 }
             };
         }
@@ -196,17 +196,18 @@ class Keystore {
     // https://github.com/waku-org/nwaku/blob/f05528d4be3d3c876a8b07f9bb7dfaae8aa8ec6e/waku/waku_keystore/protocol_types.nim#L98
     static fromIdentityToBytes(options) {
         return utf8ToBytes(JSON.stringify({
-            treeIndex: options.membership.treeIndex,
-            identityCredential: [
-                Array.from(options.identity.IDTrapdoor),
-                Array.from(options.identity.IDNullifier),
-                Array.from(options.identity.IDSecretHash),
-                Array.from(options.identity.IDCommitment)
-            ],
             membershipContract: {
                 chainId: options.membership.chainId,
                 address: options.membership.address
-            }
+            },
+            treeIndex: options.membership.treeIndex,
+            identityCredential: {
+                idTrapdoor: Array.from(options.identity.IDTrapdoor),
+                idNullifier: Array.from(options.identity.IDNullifier),
+                idSecretHash: Array.from(options.identity.IDSecretHash),
+                idCommitment: Array.from(options.identity.IDCommitment)
+            },
+            userMessageLimit: options.membership.rateLimit
         }));
     }
 }

package/bundle/packages/rln/dist/rln.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 };