@waku/rln 0.0.2-3ab8023.0 → 0.0.2-6cb9c9c.0

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

@@ -0,0 +1,223 @@
+import '../../interfaces/dist/protocols.js';
+import '../../interfaces/dist/connection_manager.js';
+import '../../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 { RLNContract } from './contract/rln_contract.js';
+import { IdentityGenerator } from './identity_generator.js';
+import { Keystore } from './keystore/keystore.js';
+import { extractMetaMaskSigner } from './utils/metamask.js';
+import './utils/epoch.js';
+
+const log = new Logger("waku:rln-light");
+/**
+ * Lightweight RLN implementation without Zerokit
+ * Only supports Keystore and membership registration
+ */
+class RLNLight {
+    started = false;
+    starting = false;
+    _contract;
+    _signer;
+    keystore = Keystore.create();
+    _credentials;
+    identityGenerator = new IdentityGenerator();
+    get contract() {
+        return this._contract;
+    }
+    get signer() {
+        return this._signer;
+    }
+    /**
+     * Get the current credentials
+     */
+    get credentials() {
+        return this._credentials;
+    }
+    /**
+     * Start the RLNLight instance
+     * @param options Configuration options
+     */
+    async start(options = {}) {
+        if (this.started || this.starting) {
+            log.warn("RLNLight already started or starting");
+            return;
+        }
+        this.starting = true;
+        try {
+            // Determine correct options based on credentials, if any
+            const keystoreCredentials = options.address
+                ? await this.findCredentialsByAddress(options.address)
+                : undefined;
+            const { address, signer, rateLimit } = await this.determineStartOptions(options, keystoreCredentials);
+            // Set the signer
+            if (signer) {
+                this._signer = signer;
+            }
+            else {
+                this._signer = await extractMetaMaskSigner();
+            }
+            const contractOptions = {
+                signer: this._signer,
+                address: address,
+                rateLimit: rateLimit
+            };
+            // We need to create a minimal compatible object with RLNInstance interface
+            // but we only need it for contract initialization
+            const compatibleRLN = {
+                zerokit: {
+                    getMerkleRoot: () => new Uint8Array(32),
+                    insertMember: (_idCommitment) => { },
+                    insertMembers: (_index, ..._idCommitments) => { },
+                    deleteMember: (_index) => { }
+                }
+            };
+            this._contract = await RLNContract.init(
+            // Type assertion needed for compatibility with RLNInstance interface
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            compatibleRLN, contractOptions);
+            this.started = true;
+        }
+        catch (error) {
+            log.error("Failed to start RLNLight:", error);
+            throw error;
+        }
+        finally {
+            this.starting = false;
+        }
+    }
+    /**
+     * Find credentials in the keystore by contract address
+     */
+    async findCredentialsByAddress(address) {
+        // Since Keystore doesn't have a direct method to find by address,
+        // we need to iterate through all credentials
+        const hashes = this.keystore.keys();
+        for (const hash of hashes) {
+            try {
+                // Try with an empty password - this won't work but lets us check schema
+                const credential = await this.keystore.readCredential(hash, new Uint8Array(0));
+                if (credential?.membership.address === address) {
+                    return credential;
+                }
+            }
+            catch (e) {
+                // Ignore errors, just means we couldn't read this credential
+            }
+        }
+        return undefined;
+    }
+    /**
+     * Determine the correct options for starting RLNLight
+     */
+    async determineStartOptions(options, credentials) {
+        if (options.credentials) {
+            const { credentials: decrypted } = await RLNLight.decryptCredentialsIfNeeded(options.credentials);
+            if (decrypted?.membership) {
+                this._credentials = decrypted;
+                return {
+                    ...options,
+                    address: decrypted.membership.address
+                };
+            }
+        }
+        else if (credentials) {
+            return {
+                ...options,
+                address: credentials.membership.address
+            };
+        }
+        return options;
+    }
+    /**
+     * Decrypt credentials if they are encrypted
+     */
+    static async decryptCredentialsIfNeeded(credentials) {
+        if (!credentials) {
+            return {};
+        }
+        if ("identity" in credentials) {
+            return { credentials };
+        }
+        else {
+            const keystore = Keystore.create();
+            try {
+                const decrypted = await keystore.readCredential(credentials.id, credentials.password);
+                if (!decrypted) {
+                    return {};
+                }
+                return {
+                    credentials: {
+                        identity: decrypted.identity,
+                        membership: decrypted.membership
+                    },
+                    keystore
+                };
+            }
+            catch (e) {
+                log.error("Failed to decrypt credentials", e);
+                return {};
+            }
+        }
+    }
+    /**
+     * Register a membership using an identity or signature
+     * @param options Options including identity or signature
+     * @returns Decrypted credentials if successful
+     */
+    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.identityGenerator.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
+     * @param id Hash of credentials to select from Keystore
+     * @param password Password to decrypt credentials from Keystore
+     */
+    async useCredentials(id, password) {
+        const decrypted = await this.keystore.readCredential(id, password);
+        if (!decrypted) {
+            throw new Error("Credentials not found or incorrect password");
+        }
+        this._credentials = {
+            identity: decrypted.identity,
+            membership: decrypted.membership
+        };
+    }
+    /**
+     * Generate a new identity credential
+     * @returns New identity credential
+     */
+    generateIdentityCredential() {
+        return this.identityGenerator.generateIdentityCredentials();
+    }
+    /**
+     * Generate a seeded identity credential
+     * @param seed Seed string to generate deterministic identity
+     * @returns Seeded identity credential
+     */
+    generateSeededIdentityCredential(seed) {
+        return this.identityGenerator.generateSeededIdentityCredential(seed);
+    }
+}
+
+export { RLNLight };

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 = undefined;

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

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

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

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

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 sha256 } from '../../../../../_virtual/sha2562.js';
 import { __exports as pbkdf2 } from '../../../../../_virtual/pbkdf22.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 = undefined;

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

@@ -4,7 +4,7 @@ import './_u64.js';
 import './utils.js';
 import { __exports as _sha2 } from '../../../../../_virtual/_sha2.js';
 import { __exports as _u64 } from '../../../../../_virtual/_u64.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 = undefined;

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';