@waku/rln 0.1.5-9901863.0 → 0.1.5-a8ff776.0

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

@@ -21,45 +21,167 @@ 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 { DEFAULT_RATE_LIMIT } from './contract/constants.js';
-import { RLNCredentialsManager } from './credentials_manager.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 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");
-class RLNInstance extends RLNCredentialsManager {
-    zerokit;
-    /**
-     * Create an instance of RLN
-     * @returns RLNInstance
-     */
-    static async create() {
-        try {
-            // 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;
+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 {
+    zerokit;
+    started = false;
+    starting = false;
+    _contract;
+    _signer;
+    keystore = Keystore.create();
+    _credentials;
     constructor(zerokit) {
-        super(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;
+        try {
+            const { credentials, keystore } = await RLNInstance.decryptCredentialsIfNeeded(options.credentials);
+            const { signer, address } = 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: options.rateLimit ?? this.zerokit.getRateLimit
+            });
+            this.started = true;
+        }
+        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();
+        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);
+    }
     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.");
         }
@@ -71,40 +193,28 @@ class RLNInstance extends RLNCredentialsManager {
             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;
+        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 };
+export { RLNInstance, create };