@waku/rln 0.0.2-09108d9.0 → 0.0.2-2380dac.0

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

@@ -21,8 +21,8 @@ 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, SEPOLIA_CONTRACT } from './contract/constants.js';
 import { RLNContract } from './contract/rln_contract.js';
-import { SEPOLIA_CONTRACT } from './contract/constants.js';
 import { Keystore } from './keystore/keystore.js';
 import verificationKey from './resources/verification_key.js';
 import { builder } from './resources/witness_calculator.js';
@@ -32,19 +32,32 @@ import { Zerokit } from './zerokit.js';
 
 const log = new Logger("waku:rln");
 async function loadWitnessCalculator() {
-    const res = await fetch("/base/rln.wasm");
-    if (!res.ok) {
-        throw new Error(`Failed to fetch rln.wasm: ${res.statusText}`);
+    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)}`);
     }
-    const witnessBuffer = await res.arrayBuffer();
-    return builder(new Uint8Array(witnessBuffer), false);
 }
 async function loadZkey() {
-    const res = await fetch("/base/rln_final.zkey");
-    if (!res.ok) {
-        throw new Error(`Failed to fetch rln_final.zkey: ${res.statusText}`);
+    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)}`);
     }
-    return new Uint8Array(await res.arrayBuffer());
 }
 /**
  * Create an instance of RLN
@@ -61,7 +74,7 @@ async function create() {
         const vkey = stringEncoder.encode(JSON.stringify(verificationKey));
         const DEPTH = 20;
         const zkRLN = newRLN(DEPTH, zkey, vkey);
-        const zerokit = new Zerokit(zkRLN, witnessCalculator);
+        const zerokit = new Zerokit(zkRLN, witnessCalculator, DEFAULT_RATE_LIMIT);
         return new RLNInstance(zerokit);
     }
     catch (error) {
@@ -93,15 +106,16 @@ class RLNInstance {
         this.starting = true;
         try {
             const { credentials, keystore } = await RLNInstance.decryptCredentialsIfNeeded(options.credentials);
-            const { signer, registryAddress } = await this.determineStartOptions(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, {
-                registryAddress: registryAddress,
-                signer: signer
+                address: address,
+                signer: signer,
+                rateLimit: options.rateLimit ?? this.zerokit.getRateLimit
             });
             this.started = true;
         }
@@ -111,10 +125,10 @@ class RLNInstance {
     }
     async determineStartOptions(options, credentials) {
         let chainId = credentials?.membership.chainId;
-        const registryAddress = credentials?.membership.address ||
-            options.registryAddress ||
+        const address = credentials?.membership.address ||
+            options.address ||
             SEPOLIA_CONTRACT.address;
-        if (registryAddress === SEPOLIA_CONTRACT.address) {
+        if (address === SEPOLIA_CONTRACT.address) {
             chainId = SEPOLIA_CONTRACT.chainId;
         }
         const signer = options.signer || (await extractMetaMaskSigner());
@@ -124,7 +138,7 @@ class RLNInstance {
         }
         return {
             signer,
-            registryAddress
+            address
         };
     }
     static async decryptCredentialsIfNeeded(credentials) {
@@ -184,12 +198,12 @@ class RLNInstance {
             throw Error("Failed to verify chain coordinates: no contract initialized.");
         }
         const registryAddress = credentials.membership.address;
-        const currentRegistryAddress = this._contract.registry.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.registry.provider.getNetwork();
+        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}`);

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

@@ -1,4 +1,5 @@
 import { generateExtendedMembershipKey, generateSeededExtendedMembershipKey, insertMember, setLeavesFrom, deleteLeaf, getRoot, getSerializedRLNWitness, RLNWitnessToJson, generate_rln_proof_with_witness, verifyRLNProof, verifyWithRoots } from '../../../node_modules/@waku/zerokit-rln-wasm/rln_wasm.js';
+import { DEFAULT_RATE_LIMIT, RATE_LIMIT_PARAMS } from './contract/constants.js';
 import { IdentityCredential } from './identity.js';
 import { Proof, proofToBytes } from './proof.js';
 import { writeUIntLE, concatenate } from './utils/bytes.js';
@@ -7,9 +8,20 @@ import { epochIntToBytes, dateToEpoch } from './utils/epoch.js';
 class Zerokit {
     zkRLN;
     witnessCalculator;
-    constructor(zkRLN, witnessCalculator) {
+    rateLimit;
+    constructor(zkRLN, witnessCalculator, rateLimit = DEFAULT_RATE_LIMIT) {
         this.zkRLN = zkRLN;
         this.witnessCalculator = witnessCalculator;
+        this.rateLimit = rateLimit;
+    }
+    get getZkRLN() {
+        return this.zkRLN;
+    }
+    get getWitnessCalculator() {
+        return this.witnessCalculator;
+    }
+    get getRateLimit() {
+        return this.rateLimit;
     }
     generateIdentityCredentials() {
         const memKeys = generateExtendedMembershipKey(this.zkRLN); // TODO: rename this function in zerokit rln-wasm
@@ -38,35 +50,40 @@ class Zerokit {
     getMerkleRoot() {
         return getRoot(this.zkRLN);
     }
-    serializeMessage(uint8Msg, memIndex, epoch, idKey) {
+    serializeMessage(uint8Msg, memIndex, epoch, idKey, rateLimit) {
         // calculate message length
         const msgLen = writeUIntLE(new Uint8Array(8), uint8Msg.length, 0, 8);
-        // Converting index to LE bytes
         const memIndexBytes = writeUIntLE(new Uint8Array(8), memIndex, 0, 8);
-        // [ id_key<32> | id_index<8> | epoch<32> | signal_len<8> | signal<var> ]
-        return concatenate(idKey, memIndexBytes, epoch, msgLen, uint8Msg);
+        const rateLimitBytes = writeUIntLE(new Uint8Array(8), rateLimit ?? this.rateLimit, 0, 8);
+        // [ id_key<32> | id_index<8> | epoch<32> | signal_len<8> | signal<var> | rate_limit<8> ]
+        return concatenate(idKey, memIndexBytes, epoch, msgLen, uint8Msg, rateLimitBytes);
     }
-    async generateRLNProof(msg, index, epoch, idSecretHash) {
+    async generateRLNProof(msg, index, epoch, idSecretHash, rateLimit) {
         if (epoch === undefined) {
             epoch = epochIntToBytes(dateToEpoch(new Date()));
         }
         else if (epoch instanceof Date) {
             epoch = epochIntToBytes(dateToEpoch(epoch));
         }
+        const effectiveRateLimit = rateLimit ?? this.rateLimit;
         if (epoch.length !== 32)
             throw new Error("invalid epoch");
         if (idSecretHash.length !== 32)
             throw new Error("invalid id secret hash");
         if (index < 0)
             throw new Error("index must be >= 0");
-        const serialized_msg = this.serializeMessage(msg, index, epoch, idSecretHash);
+        if (effectiveRateLimit < RATE_LIMIT_PARAMS.MIN_RATE ||
+            effectiveRateLimit > RATE_LIMIT_PARAMS.MAX_RATE) {
+            throw new Error(`Rate limit must be between ${RATE_LIMIT_PARAMS.MIN_RATE} and ${RATE_LIMIT_PARAMS.MAX_RATE}`);
+        }
+        const serialized_msg = this.serializeMessage(msg, index, epoch, idSecretHash, effectiveRateLimit);
         const rlnWitness = getSerializedRLNWitness(this.zkRLN, serialized_msg);
         const inputs = RLNWitnessToJson(this.zkRLN, rlnWitness);
-        const calculatedWitness = await this.witnessCalculator.calculateWitness(inputs, false); // no sanity check being used in zerokit
+        const calculatedWitness = await this.witnessCalculator.calculateWitness(inputs, false);
         const proofBytes = generate_rln_proof_with_witness(this.zkRLN, calculatedWitness, rlnWitness);
         return new Proof(proofBytes);
     }
-    verifyRLNProof(proof, msg) {
+    verifyRLNProof(proof, msg, rateLimit) {
         let pBytes;
         if (proof instanceof Uint8Array) {
             pBytes = proof;
@@ -76,9 +93,10 @@ class Zerokit {
         }
         // calculate message length
         const msgLen = writeUIntLE(new Uint8Array(8), msg.length, 0, 8);
-        return verifyRLNProof(this.zkRLN, concatenate(pBytes, msgLen, msg));
+        const rateLimitBytes = writeUIntLE(new Uint8Array(8), rateLimit ?? this.rateLimit, 0, 8);
+        return verifyRLNProof(this.zkRLN, concatenate(pBytes, msgLen, msg, rateLimitBytes));
     }
-    verifyWithRoots(proof, msg, ...roots) {
+    verifyWithRoots(proof, msg, roots, rateLimit) {
         let pBytes;
         if (proof instanceof Uint8Array) {
             pBytes = proof;
@@ -88,10 +106,11 @@ class Zerokit {
         }
         // calculate message length
         const msgLen = writeUIntLE(new Uint8Array(8), msg.length, 0, 8);
+        const rateLimitBytes = writeUIntLE(new Uint8Array(8), rateLimit ?? this.rateLimit, 0, 8);
         const rootsBytes = concatenate(...roots);
-        return verifyWithRoots(this.zkRLN, concatenate(pBytes, msgLen, msg), rootsBytes);
+        return verifyWithRoots(this.zkRLN, concatenate(pBytes, msgLen, msg, rateLimitBytes), rootsBytes);
     }
-    verifyWithNoRoot(proof, msg) {
+    verifyWithNoRoot(proof, msg, rateLimit) {
         let pBytes;
         if (proof instanceof Uint8Array) {
             pBytes = proof;
@@ -101,7 +120,8 @@ class Zerokit {
         }
         // calculate message length
         const msgLen = writeUIntLE(new Uint8Array(8), msg.length, 0, 8);
-        return verifyWithRoots(this.zkRLN, concatenate(pBytes, msgLen, msg), new Uint8Array());
+        const rateLimitBytes = writeUIntLE(new Uint8Array(8), rateLimit ?? this.rateLimit, 0, 8);
+        return verifyWithRoots(this.zkRLN, concatenate(pBytes, msgLen, msg, rateLimitBytes), new Uint8Array());
     }
 }