@waku/rln 0.0.2-c41b319.0 → 0.0.2-c8128d1.0

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

@@ -5,11 +5,12 @@ import { hexToBytes } from '../../../utils/dist/bytes/index.js';
 import { Logger } from '../../../utils/dist/logger/index.js';
 import { MerkleRootTracker } from '../root_tracker.js';
 import { zeroPadLE } from '../utils/bytes.js';
-import { RLN_V2_ABI } from './abi/rlnv2.js';
+import { RLN_ABI } from './abi.js';
 import { RATE_LIMIT_PARAMS, DEFAULT_RATE_LIMIT } from './constants.js';
 import { Contract } from '../../../../node_modules/@ethersproject/contracts/lib.esm/index.js';
 import { BigNumber } from '../../../../node_modules/@ethersproject/bignumber/lib.esm/bignumber.js';
 
+/* eslint-disable no-console */
 const log = new Logger("waku:rln:contract");
 var MembershipState;
 (function (MembershipState) {
@@ -26,6 +27,7 @@ class RLNContract {
     _members = new Map();
     _membersFilter;
     _membersRemovedFilter;
+    _membersExpiredFilter;
     /**
      * Asynchronous initializer for RLNContract.
      * Allows injecting a mocked contract for testing purposes.
@@ -45,12 +47,12 @@ class RLNContract {
         this.rateLimit = rateLimit;
         const initialRoot = rlnInstance.zerokit.getMerkleRoot();
         // Use the injected contract if provided; otherwise, instantiate a new one.
-        this.contract =
-            contract || new Contract(address, RLN_V2_ABI, signer);
+        this.contract = contract || new Contract(address, RLN_ABI, signer);
         this.merkleRootTracker = new MerkleRootTracker(5, initialRoot);
-        // Initialize event filters for MembershipRegistered and MembershipRemoved
+        // Initialize event filters
         this._membersFilter = this.contract.filters.MembershipRegistered();
-        this._membersRemovedFilter = this.contract.filters.MembershipRemoved();
+        this._membersRemovedFilter = this.contract.filters.MembershipErased();
+        this._membersExpiredFilter = this.contract.filters.MembershipExpired();
     }
     /**
      * Gets the current rate limit for this contract instance
@@ -58,6 +60,18 @@ class RLNContract {
     getRateLimit() {
         return this.rateLimit;
     }
+    /**
+     * Gets the contract address
+     */
+    get address() {
+        return this.contract.address;
+    }
+    /**
+     * Gets the contract provider
+     */
+    get provider() {
+        return this.contract.provider;
+    }
     /**
      * Gets the minimum allowed rate limit from the contract
      * @returns Promise<number> The minimum rate limit in messages per epoch
@@ -120,10 +134,16 @@ class RLNContract {
     }
     get membersRemovedFilter() {
         if (!this._membersRemovedFilter) {
-            throw Error("MembersRemoved filter was not initialized.");
+            throw Error("MembersErased filter was not initialized.");
         }
         return this._membersRemovedFilter;
     }
+    get membersExpiredFilter() {
+        if (!this._membersExpiredFilter) {
+            throw Error("MembersExpired filter was not initialized.");
+        }
+        return this._membersExpiredFilter;
+    }
     async fetchMembers(rlnInstance, options = {}) {
         const registeredMemberEvents = await queryFilter(this.contract, {
             fromBlock: this.deployBlock,
@@ -135,7 +155,16 @@ class RLNContract {
             ...options,
             membersFilter: this.membersRemovedFilter
         });
-        const events = [...registeredMemberEvents, ...removedMemberEvents];
+        const expiredMemberEvents = await queryFilter(this.contract, {
+            fromBlock: this.deployBlock,
+            ...options,
+            membersFilter: this.membersExpiredFilter
+        });
+        const events = [
+            ...registeredMemberEvents,
+            ...removedMemberEvents,
+            ...expiredMemberEvents
+        ];
         this.processEvents(rlnInstance, events);
     }
     processEvents(rlnInstance, events) {
@@ -145,8 +174,17 @@ class RLNContract {
             if (!evt.args) {
                 return;
             }
-            if (evt.event === "MembershipRemoved") {
-                const index = evt.args.index;
+            if (evt.event === "MembershipErased" ||
+                evt.event === "MembershipExpired") {
+                // Both MembershipErased and MembershipExpired events should remove members
+                let index = evt.args.index;
+                if (!index) {
+                    return;
+                }
+                // Convert index to ethers.BigNumber if it's not already
+                if (typeof index === "number" || typeof index === "string") {
+                    index = BigNumber.from(index);
+                }
                 const toRemoveVal = toRemoveTable.get(evt.blockNumber);
                 if (toRemoveVal != undefined) {
                     toRemoveVal.push(index.toNumber());
@@ -174,14 +212,21 @@ class RLNContract {
                 if (!evt.args)
                     return;
                 const _idCommitment = evt.args.idCommitment;
-                const index = evt.args.index;
+                let index = evt.args.index;
+                // Ensure index is an ethers.BigNumber
                 if (!_idCommitment || !index) {
                     return;
                 }
+                // Convert index to ethers.BigNumber if it's not already
+                if (typeof index === "number" || typeof index === "string") {
+                    index = BigNumber.from(index);
+                }
                 const idCommitment = zeroPadLE(hexToBytes(_idCommitment), 32);
                 rlnInstance.zerokit.insertMember(idCommitment);
-                this._members.set(index.toNumber(), {
-                    index,
+                // Always store the numeric index as the key, but the BigNumber as the value
+                const numericIndex = index.toNumber();
+                this._members.set(numericIndex, {
+                    index, // This is always a BigNumber
                     idCommitment: _idCommitment
                 });
             });
@@ -202,34 +247,78 @@ class RLNContract {
         });
     }
     subscribeToMembers(rlnInstance) {
-        this.contract.on(this.membersFilter, (_idCommitment, _rateLimit, _index, event) => {
+        this.contract.on(this.membersFilter, (_idCommitment, _membershipRateLimit, _index, event) => {
             this.processEvents(rlnInstance, [event]);
         });
-        this.contract.on(this.membersRemovedFilter, (_idCommitment, _index, event) => {
+        this.contract.on(this.membersRemovedFilter, (_idCommitment, _membershipRateLimit, _index, event) => {
+            this.processEvents(rlnInstance, [event]);
+        });
+        this.contract.on(this.membersExpiredFilter, (_idCommitment, _membershipRateLimit, _index, event) => {
             this.processEvents(rlnInstance, [event]);
         });
     }
     async registerWithIdentity(identity) {
         try {
+            console.log("registerWithIdentity - starting registration process");
+            console.log("registerWithIdentity - identity:", identity);
+            console.log("registerWithIdentity - IDCommitmentBigInt:", identity.IDCommitmentBigInt.toString());
+            console.log("registerWithIdentity - rate limit:", this.rateLimit);
             log.info(`Registering identity with rate limit: ${this.rateLimit} messages/epoch`);
+            // Check if the ID commitment is already registered
+            const existingIndex = await this.getMemberIndex(identity.IDCommitmentBigInt.toString());
+            if (existingIndex) {
+                console.error(`ID commitment is already registered with index ${existingIndex}`);
+                throw new Error(`ID commitment is already registered with index ${existingIndex}`);
+            }
+            // Check if there's enough remaining rate limit
+            const remainingRateLimit = await this.getRemainingTotalRateLimit();
+            if (remainingRateLimit < this.rateLimit) {
+                console.error(`Not enough remaining rate limit. Requested: ${this.rateLimit}, Available: ${remainingRateLimit}`);
+                throw new Error(`Not enough remaining rate limit. Requested: ${this.rateLimit}, Available: ${remainingRateLimit}`);
+            }
+            console.log("registerWithIdentity - calling contract.register");
             const txRegisterResponse = await this.contract.register(identity.IDCommitmentBigInt, this.rateLimit, [], { gasLimit: 300000 });
+            console.log("registerWithIdentity - txRegisterResponse:", txRegisterResponse);
+            console.log("registerWithIdentity - hash:", txRegisterResponse.hash);
+            console.log("registerWithIdentity - waiting for transaction confirmation...");
             const txRegisterReceipt = await txRegisterResponse.wait();
+            console.log("registerWithIdentity - txRegisterReceipt:", txRegisterReceipt);
+            console.log("registerWithIdentity - transaction status:", txRegisterReceipt.status);
+            console.log("registerWithIdentity - block number:", txRegisterReceipt.blockNumber);
+            console.log("registerWithIdentity - gas used:", txRegisterReceipt.gasUsed.toString());
+            // Check transaction status
+            if (txRegisterReceipt.status === 0) {
+                console.error("Transaction failed on-chain");
+                throw new Error("Transaction failed on-chain");
+            }
             const memberRegistered = txRegisterReceipt.events?.find((event) => event.event === "MembershipRegistered");
+            console.log("registerWithIdentity - memberRegistered event:", memberRegistered);
             if (!memberRegistered || !memberRegistered.args) {
-                log.error("Failed to register membership: No MembershipRegistered event found");
+                console.log("registerWithIdentity - ERROR: no memberRegistered event found");
+                console.log("registerWithIdentity - all events:", txRegisterReceipt.events);
+                console.error("Failed to register membership: No MembershipRegistered event found");
                 return undefined;
             }
+            console.log("registerWithIdentity - memberRegistered args:", memberRegistered.args);
             const decodedData = {
                 idCommitment: memberRegistered.args.idCommitment,
-                rateLimit: memberRegistered.args.rateLimit,
+                membershipRateLimit: memberRegistered.args.membershipRateLimit,
                 index: memberRegistered.args.index
             };
+            console.log("registerWithIdentity - decodedData:", decodedData);
+            console.log("registerWithIdentity - index:", decodedData.index.toString());
+            console.log("registerWithIdentity - membershipRateLimit:", decodedData.membershipRateLimit.toString());
             log.info(`Successfully registered membership with index ${decodedData.index} ` +
-                `and rate limit ${decodedData.rateLimit}`);
+                `and rate limit ${decodedData.membershipRateLimit}`);
+            console.log("registerWithIdentity - getting network information");
             const network = await this.contract.provider.getNetwork();
+            console.log("registerWithIdentity - network:", network);
+            console.log("registerWithIdentity - chainId:", network.chainId);
             const address = this.contract.address;
+            console.log("registerWithIdentity - contract address:", address);
             const membershipId = decodedData.index.toNumber();
-            return {
+            console.log("registerWithIdentity - membershipId:", membershipId);
+            const result = {
                 identity,
                 membership: {
                     address,
@@ -237,10 +326,39 @@ class RLNContract {
                     chainId: network.chainId
                 }
             };
+            console.log("registerWithIdentity - returning result:", result);
+            return result;
         }
         catch (error) {
-            log.error(`Error in registerWithIdentity: ${error.message}`);
-            return undefined;
+            console.log("registerWithIdentity - ERROR:", error);
+            // Improved error handling to decode contract errors
+            if (error instanceof Error) {
+                const errorMessage = error.message;
+                console.log("registerWithIdentity - error message:", errorMessage);
+                console.log("registerWithIdentity - error stack:", error.stack);
+                // Try to extract more specific error information
+                if (errorMessage.includes("CannotExceedMaxTotalRateLimit")) {
+                    console.error("Registration failed: Cannot exceed maximum total rate limit");
+                }
+                else if (errorMessage.includes("InvalidIdCommitment")) {
+                    console.error("Registration failed: Invalid ID commitment");
+                }
+                else if (errorMessage.includes("InvalidMembershipRateLimit")) {
+                    console.error("Registration failed: Invalid membership rate limit");
+                }
+                else if (errorMessage.includes("execution reverted")) {
+                    // Generic revert
+                    console.error("Contract execution reverted. Check contract requirements.");
+                }
+                else {
+                    console.error(`Error in registerWithIdentity: ${errorMessage}`);
+                }
+            }
+            else {
+                console.error("Unknown error in registerWithIdentity");
+            }
+            // Re-throw the error to allow callers to handle it
+            throw error;
         }
     }
     /**
@@ -276,11 +394,11 @@ class RLNContract {
             }
             const decodedData = {
                 idCommitment: memberRegistered.args.idCommitment,
-                rateLimit: memberRegistered.args.rateLimit,
+                membershipRateLimit: memberRegistered.args.membershipRateLimit,
                 index: memberRegistered.args.index
             };
             log.info(`Successfully registered membership with permit. Index: ${decodedData.index}, ` +
-                `Rate limit: ${decodedData.rateLimit}, Erased ${idCommitmentsToErase.length} commitments`);
+                `Rate limit: ${decodedData.membershipRateLimit}, Erased ${idCommitmentsToErase.length} commitments`);
             const network = await this.contract.provider.getNetwork();
             const address = this.contract.address;
             const membershipId = decodedData.index.toNumber();
@@ -341,17 +459,22 @@ class RLNContract {
         }
     }
     async extendMembership(idCommitment) {
-        return this.contract.extendMemberships([idCommitment]);
+        const tx = await this.contract.extendMemberships([idCommitment]);
+        return await tx.wait();
     }
     async eraseMembership(idCommitment, eraseFromMembershipSet = true) {
-        return this.contract.eraseMemberships([idCommitment], eraseFromMembershipSet);
+        const tx = await this.contract.eraseMemberships([idCommitment], eraseFromMembershipSet);
+        return await tx.wait();
     }
     async registerMembership(idCommitment, rateLimit = DEFAULT_RATE_LIMIT) {
         if (rateLimit < RATE_LIMIT_PARAMS.MIN_RATE ||
             rateLimit > RATE_LIMIT_PARAMS.MAX_RATE) {
             throw new Error(`Rate limit must be between ${RATE_LIMIT_PARAMS.MIN_RATE} and ${RATE_LIMIT_PARAMS.MAX_RATE}`);
         }
-        return this.contract.register(idCommitment, rateLimit, []);
+        console.log("registering membership", idCommitment, rateLimit);
+        const txn = this.contract.register(idCommitment, rateLimit, []);
+        console.log("txn", txn);
+        return txn;
     }
     async getMemberIndex(idCommitment) {
         try {

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

@@ -1,7 +1,3 @@
-import { arrayify } from '../../../node_modules/@ethersproject/bytes/lib.esm/index.js';
-import { keccak256 } from '../../../node_modules/@ethersproject/keccak256/lib.esm/index.js';
-import { Poseidon as m } from '../../../node_modules/@iden3/js-crypto/dist/browser/esm/index.js';
-import { streamXOR } from '../../../node_modules/@stablelib/chacha/lib/chacha.js';
 import { buildBigIntFromUint8Array } from './utils/bytes.js';
 import './utils/epoch.js';
 
@@ -29,26 +25,6 @@ class IdentityCredential {
         const idCommitmentBigInt = buildBigIntFromUint8Array(idCommitment, 32);
         return new IdentityCredential(idTrapdoor, idNullifier, idSecretHash, idCommitment, idCommitmentBigInt);
     }
-    static generateSeeded(signature) {
-        // Generate deterministic seed from signature
-        const seed = arrayify(keccak256(signature));
-        // Use ChaCha for deterministic randomness (as in Rust code)
-        const nonce = new Uint8Array(12);
-        const idSecretHash = new Uint8Array(32);
-        streamXOR(seed, nonce, idSecretHash, idSecretHash);
-        // Convert to bigint for Poseidon
-        const secretBigInt = BigInt("0x" + Buffer.from(idSecretHash).toString("hex"));
-        // Generate commitment using Poseidon
-        const idCommitmentBigInt = m.hash([secretBigInt]);
-        // Convert commitment back to Uint8Array
-        const idCommitment = arrayify("0x" + idCommitmentBigInt.toString(16).padStart(64, "0"));
-        // Generate deterministic trapdoor and nullifier from the secret hash
-        const idTrapdoor = new Uint8Array(32);
-        const idNullifier = new Uint8Array(32);
-        streamXOR(idSecretHash, nonce, idTrapdoor, idTrapdoor);
-        streamXOR(idTrapdoor, nonce, idNullifier, idNullifier);
-        return new IdentityCredential(idTrapdoor, idNullifier, idSecretHash, idCommitment, idCommitmentBigInt);
-    }
 }
 
 export { IdentityCredential };

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

@@ -21,27 +21,43 @@ 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 { IdentityCredential } from './identity.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';
-import { arrayify } from '../../../node_modules/@ethersproject/bytes/lib.esm/index.js';
 
 const log = new Logger("waku:rln");
 async function loadWitnessCalculator() {
-    const url = new URL("./resources/rln.wasm", import.meta.url);
-    const response = await fetch(url);
-    return await builder(new Uint8Array(await response.arrayBuffer()), false);
+    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() {
-    const url = new URL("./resources/rln_final.zkey", import.meta.url);
-    const response = await fetch(url);
-    return new Uint8Array(await response.arrayBuffer());
+    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
@@ -58,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) {
@@ -99,7 +115,7 @@ class RLNInstance {
             this._contract = await RLNContract.init(this, {
                 address: address,
                 signer: signer,
-                rateLimit: options.rateLimit
+                rateLimit: options.rateLimit ?? this.zerokit.getRateLimit
             });
             this.started = true;
         }
@@ -146,10 +162,12 @@ class RLNInstance {
         if (!this.contract) {
             throw Error("RLN Contract is not initialized.");
         }
-        let identity = "identity" in options ? options.identity : undefined;
+        let identity = "identity" in options && options.identity;
         if ("signature" in options) {
-            identity = IdentityCredential.generateSeeded(arrayify(options.signature));
+            identity = this.zerokit.generateSeededIdentityCredential(options.signature);
         }
+        // eslint-disable-next-line no-console
+        console.log("registering membership", identity);
         if (!identity) {
             throw Error("Missing signature or identity to register membership.");
         }
@@ -182,12 +200,12 @@ class RLNInstance {
             throw Error("Failed to verify chain coordinates: no contract initialized.");
         }
         const registryAddress = credentials.membership.address;
-        const currentRegistryAddress = this._contract.contract.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.contract.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

@@ -8,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
@@ -39,32 +50,33 @@ class Zerokit {
     getMerkleRoot() {
         return getRoot(this.zkRLN);
     }
-    serializeMessage(uint8Msg, memIndex, epoch, idKey, rateLimit = DEFAULT_RATE_LIMIT) {
+    serializeMessage(uint8Msg, memIndex, epoch, idKey, rateLimit) {
         // calculate message length
         const msgLen = writeUIntLE(new Uint8Array(8), uint8Msg.length, 0, 8);
         const memIndexBytes = writeUIntLE(new Uint8Array(8), memIndex, 0, 8);
-        const rateLimitBytes = writeUIntLE(new Uint8Array(8), rateLimit, 0, 8);
+        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, rateLimit = DEFAULT_RATE_LIMIT) {
+    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");
-        if (rateLimit < RATE_LIMIT_PARAMS.MIN_RATE ||
-            rateLimit > RATE_LIMIT_PARAMS.MAX_RATE) {
+        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, rateLimit);
+        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);
@@ -81,9 +93,7 @@ class Zerokit {
         }
         // calculate message length
         const msgLen = writeUIntLE(new Uint8Array(8), msg.length, 0, 8);
-        const rateLimitBytes = rateLimit
-            ? writeUIntLE(new Uint8Array(8), rateLimit, 0, 8)
-            : new Uint8Array(8); // Zero if not specified
+        const rateLimitBytes = writeUIntLE(new Uint8Array(8), rateLimit ?? this.rateLimit, 0, 8);
         return verifyRLNProof(this.zkRLN, concatenate(pBytes, msgLen, msg, rateLimitBytes));
     }
     verifyWithRoots(proof, msg, roots, rateLimit) {
@@ -96,9 +106,7 @@ class Zerokit {
         }
         // calculate message length
         const msgLen = writeUIntLE(new Uint8Array(8), msg.length, 0, 8);
-        const rateLimitBytes = rateLimit
-            ? writeUIntLE(new Uint8Array(8), rateLimit, 0, 8)
-            : new Uint8Array(8); // Zero if not specified
+        const rateLimitBytes = writeUIntLE(new Uint8Array(8), rateLimit ?? this.rateLimit, 0, 8);
         const rootsBytes = concatenate(...roots);
         return verifyWithRoots(this.zkRLN, concatenate(pBytes, msgLen, msg, rateLimitBytes), rootsBytes);
     }
@@ -112,9 +120,7 @@ class Zerokit {
         }
         // calculate message length
         const msgLen = writeUIntLE(new Uint8Array(8), msg.length, 0, 8);
-        const rateLimitBytes = rateLimit
-            ? writeUIntLE(new Uint8Array(8), rateLimit, 0, 8)
-            : new Uint8Array(8); // Zero if not specified
+        const rateLimitBytes = writeUIntLE(new Uint8Array(8), rateLimit ?? this.rateLimit, 0, 8);
         return verifyWithRoots(this.zkRLN, concatenate(pBytes, msgLen, msg, rateLimitBytes), new Uint8Array());
     }
 }