@waku/rln 0.1.6-b133417.0 → 0.1.6-b4748fd.0

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

@@ -13,9 +13,9 @@ 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 { BytesUtils } from '../utils/bytes.js';
+import { buildBigIntFromUint8ArrayBE } from '../utils/bytes.js';
 import { RLN_ABI } from './abi.js';
-import { DEFAULT_RATE_LIMIT, RATE_LIMIT_PARAMS } from './constants.js';
+import { DEFAULT_Q, DEFAULT_RATE_LIMIT, RATE_LIMIT_PARAMS } from './constants.js';
 import { MembershipState } from './types.js';
 import { Contract } from '../../../../node_modules/@ethersproject/contracts/lib.esm/index.js';
 import { BigNumber } from '../../../../node_modules/@ethersproject/bignumber/lib.esm/bignumber.js';
@@ -27,6 +27,11 @@ class RLNBaseContract {
     rateLimit;
     minRateLimit;
     maxRateLimit;
+    /**
+     * Default Q value for the RLN contract.
+     * @see https://github.com/waku-org/waku-rlnv2-contract/blob/b7e9a9b1bc69256a2a3076c1f099b50ce84e7eff/src/WakuRlnV2.sol#L25
+     */
+    idCommitmentBigIntLimit = DEFAULT_Q;
     _members = new Map();
     _membersFilter;
     _membershipErasedFilter;
@@ -65,12 +70,14 @@ class RLNBaseContract {
      */
     static async create(options) {
         const instance = new RLNBaseContract(options);
-        const [min, max] = await Promise.all([
+        const [min, max, idCommitmentBigIntLimit] = await Promise.all([
             instance.contract.minMembershipRateLimit(),
-            instance.contract.maxMembershipRateLimit()
+            instance.contract.maxMembershipRateLimit(),
+            instance.contract.Q()
         ]);
         instance.minRateLimit = BigNumber.from(min).toNumber();
         instance.maxRateLimit = BigNumber.from(max).toNumber();
+        instance.idCommitmentBigIntLimit = BigInt(idCommitmentBigIntLimit.toString());
         instance.validateRateLimit(instance.rateLimit);
         return instance;
     }
@@ -338,11 +345,28 @@ class RLNBaseContract {
             log.error(`Error in withdraw: ${error.message}`);
         }
     }
+    getIdCommitmentBigInt(bytes) {
+        let idCommitmentBigIntBE = buildBigIntFromUint8ArrayBE(bytes);
+        log.info("1");
+        if (!this.contract) {
+            throw Error("RLN contract is not initialized");
+        }
+        const idCommitmentBigIntLimit = this.contract.idCommitmentBigIntLimit;
+        log.info("idCommitmentBigIntBE: ", idCommitmentBigIntBE);
+        log.info("idCommitmentBigIntLimit: ", idCommitmentBigIntLimit);
+        log.info("idCommitmentBigIntBE >= idCommitmentBigIntLimit: ", idCommitmentBigIntBE >= idCommitmentBigIntLimit);
+        if (idCommitmentBigIntBE >= idCommitmentBigIntLimit) {
+            log.warn(`ID commitment is greater than Q, reducing it by Q(idCommitmentBigIntLimit): ${idCommitmentBigIntBE} % ${idCommitmentBigIntLimit}`);
+            idCommitmentBigIntBE = idCommitmentBigIntBE % idCommitmentBigIntLimit;
+        }
+        return idCommitmentBigIntBE;
+    }
     async registerWithIdentity(identity) {
         try {
             log.info(`Registering identity with rate limit: ${this.rateLimit} messages/epoch`);
+            const idCommitmentBigInt = this.getIdCommitmentBigInt(identity.IDCommitment);
             // Check if the ID commitment is already registered
-            const existingIndex = await this.getMemberIndex(identity.IDCommitmentBigInt);
+            const existingIndex = await this.getMemberIndex(idCommitmentBigInt);
             if (existingIndex) {
                 throw new Error(`ID commitment is already registered with index ${existingIndex}`);
             }
@@ -351,9 +375,9 @@ class RLNBaseContract {
             if (remainingRateLimit < this.rateLimit) {
                 throw new Error(`Not enough remaining rate limit. Requested: ${this.rateLimit}, Available: ${remainingRateLimit}`);
             }
-            const estimatedGas = await this.contract.estimateGas.register(identity.IDCommitmentBigInt, this.rateLimit, []);
+            const estimatedGas = await this.contract.estimateGas.register(idCommitmentBigInt, this.rateLimit, []);
             const gasLimit = estimatedGas.add(10000);
-            const txRegisterResponse = await this.contract.register(identity.IDCommitmentBigInt, this.rateLimit, [], {
+            const txRegisterResponse = await this.contract.register(idCommitmentBigInt, this.rateLimit, [], {
                 gasLimit
             });
             const txRegisterReceipt = await txRegisterResponse.wait();
@@ -417,7 +441,7 @@ class RLNBaseContract {
     async registerWithPermitAndErase(identity, permit, idCommitmentsToErase) {
         try {
             log.info(`Registering identity with permit and rate limit: ${this.rateLimit} messages/epoch`);
-            const txRegisterResponse = await this.contract.registerWithPermit(permit.owner, permit.deadline, permit.v, permit.r, permit.s, BytesUtils.buildBigIntFromUint8ArrayBE(identity.IDCommitment), this.rateLimit, idCommitmentsToErase.map((id) => BigNumber.from(id)));
+            const txRegisterResponse = await this.contract.registerWithPermit(permit.owner, permit.deadline, permit.v, permit.r, permit.s, this.getIdCommitmentBigInt(identity.IDCommitment), this.rateLimit, idCommitmentsToErase.map((id) => BigNumber.from(id)));
             const txRegisterReceipt = await txRegisterResponse.wait();
             const memberRegistered = txRegisterReceipt.events?.find((event) => event.event === "MembershipRegistered");
             if (!memberRegistered || !memberRegistered.args) {

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

@@ -4,7 +4,7 @@ import '../../../interfaces/dist/health_indicator.js';
 import { hexToBytes } from '../../../utils/dist/bytes/index.js';
 import { Logger } from '../../../utils/dist/logger/index.js';
 import { MerkleRootTracker } from '../root_tracker.js';
-import { BytesUtils } from '../utils/bytes.js';
+import { zeroPadLE } from '../utils/bytes.js';
 import { RLNBaseContract } from './rln_base_contract.js';
 import { BigNumber } from '../../../../node_modules/@ethersproject/bignumber/lib.esm/bignumber.js';
 
@@ -83,7 +83,7 @@ class RLNContract extends RLNBaseContract {
                 if (typeof index === "number" || typeof index === "string") {
                     index = BigNumber.from(index);
                 }
-                const idCommitment = BytesUtils.zeroPadLE(hexToBytes(_idCommitment), 32);
+                const idCommitment = zeroPadLE(hexToBytes(_idCommitment), 32);
                 rlnInstance.zerokit.insertMember(idCommitment);
                 const numericIndex = index.toNumber();
                 this._members.set(numericIndex, {

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

@@ -15,12 +15,12 @@ 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 { LINEA_CONTRACT, DEFAULT_Q } from './contract/constants.js';
+import { LINEA_CONTRACT } from './contract/constants.js';
 import { RLNBaseContract } from './contract/rln_base_contract.js';
 import { IdentityCredential } from './identity.js';
 import { Keystore } from './keystore/keystore.js';
-import { BytesUtils } from './utils/bytes.js';
 import { extractMetaMaskSigner } from './utils/metamask.js';
+import { switchEndianness } from './utils/bytes.js';
 import './utils/epoch.js';
 
 const log = new Logger("waku:credentials");
@@ -202,21 +202,15 @@ class RLNCredentialsManager {
         const idNullifierBE = hmac(sha256, seedBytes, encoder.encode("IDNullifier"));
         const combinedBytes = new Uint8Array([...idTrapdoorBE, ...idNullifierBE]);
         const idSecretHashBE = sha256(combinedBytes);
-        const idCommitmentRawBE = sha256(idSecretHashBE);
-        const idCommitmentBE = this.reduceIdCommitment(idCommitmentRawBE);
-        log.info("Successfully generated identity credential, storing in Big Endian format");
-        return new IdentityCredential(idTrapdoorBE, idNullifierBE, idSecretHashBE, idCommitmentBE);
-    }
-    /**
-     * Helper: take 32-byte BE, reduce mod Q, return 32-byte BE
-     */
-    reduceIdCommitment(bytesBE, limit = DEFAULT_Q) {
-        const nBE = BytesUtils.buildBigIntFromUint8ArrayBE(bytesBE);
-        if (nBE >= limit) {
-            log.warn(`ID commitment is greater than Q, reducing it by Q: ${nBE} % ${limit}`);
-            return BytesUtils.bigIntToUint8Array32BE(nBE % limit);
-        }
-        return bytesBE;
+        const idCommitmentBE = sha256(idSecretHashBE);
+        // All hashing functions return big-endian bytes
+        // We need to switch to little-endian for the identity credential
+        const idTrapdoorLE = switchEndianness(idTrapdoorBE);
+        const idNullifierLE = switchEndianness(idNullifierBE);
+        const idSecretHashLE = switchEndianness(idSecretHashBE);
+        const idCommitmentLE = switchEndianness(idCommitmentBE);
+        log.info("Successfully generated identity credential");
+        return new IdentityCredential(idTrapdoorLE, idNullifierLE, idSecretHashLE, idCommitmentLE);
     }
 }
 

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

@@ -1,11 +1,8 @@
-import { BytesUtils } from './utils/bytes.js';
-
 class IdentityCredential {
     IDTrapdoor;
     IDNullifier;
     IDSecretHash;
     IDCommitment;
-    IDCommitmentBigInt;
     /**
      * All variables are in little-endian format
      */
@@ -14,8 +11,6 @@ class IdentityCredential {
         this.IDNullifier = IDNullifier;
         this.IDSecretHash = IDSecretHash;
         this.IDCommitment = IDCommitment;
-        this.IDCommitmentBigInt =
-            BytesUtils.buildBigIntFromUint8ArrayBE(IDCommitment);
     }
     static fromBytes(memKeys) {
         if (memKeys.length < 128) {

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

@@ -17,7 +17,6 @@ import { Logger } from '../../../utils/dist/logger/index.js';
 import { sha256 } from '../../../../node_modules/ethereum-cryptography/esm/sha256.js';
 import { bytesToUtf8 } from '../../../../node_modules/ethereum-cryptography/esm/utils.js';
 import _ from '../../../../node_modules/lodash/lodash.js';
-import { BytesUtils } from '../utils/bytes.js';
 import { keccak256Checksum, decryptEipKeystore } from './cipher.js';
 import { isKeystoreValid, isCredentialValid } from './schema_validator.js';
 import { __exports as lib } from '../../../../_virtual/index.js';
@@ -164,24 +163,16 @@ class Keystore {
         try {
             const str = bytesToUtf8(bytes);
             const obj = JSON.parse(str);
-            // Little Endian
             const idCommitmentLE = Keystore.fromArraylikeToBytes(_.get(obj, "identityCredential.idCommitment", []));
             const idTrapdoorLE = Keystore.fromArraylikeToBytes(_.get(obj, "identityCredential.idTrapdoor", []));
             const idNullifierLE = Keystore.fromArraylikeToBytes(_.get(obj, "identityCredential.idNullifier", []));
             const idSecretHashLE = Keystore.fromArraylikeToBytes(_.get(obj, "identityCredential.idSecretHash", []));
-            // Big Endian
-            const idCommitmentBE = BytesUtils.switchEndianness(idCommitmentLE);
-            const idTrapdoorBE = BytesUtils.switchEndianness(idTrapdoorLE);
-            const idNullifierBE = BytesUtils.switchEndianness(idNullifierLE);
-            const idSecretHashBE = BytesUtils.switchEndianness(idSecretHashLE);
-            const idCommitmentBigInt = BytesUtils.buildBigIntFromUint8ArrayBE(idCommitmentBE);
             return {
                 identity: {
-                    IDCommitment: idCommitmentBE,
-                    IDTrapdoor: idTrapdoorBE,
-                    IDNullifier: idNullifierBE,
-                    IDSecretHash: idSecretHashBE,
-                    IDCommitmentBigInt: idCommitmentBigInt
+                    IDCommitment: idCommitmentLE,
+                    IDTrapdoor: idTrapdoorLE,
+                    IDNullifier: idNullifierLE,
+                    IDSecretHash: idSecretHashLE
                 },
                 membership: {
                     treeIndex: _.get(obj, "treeIndex"),
@@ -217,15 +208,17 @@ class Keystore {
     }
     // follows nwaku implementation
     // https://github.com/waku-org/nwaku/blob/f05528d4be3d3c876a8b07f9bb7dfaae8aa8ec6e/waku/waku_keystore/protocol_types.nim#L98
-    // IdentityCredential is stored in Big Endian format => switch to Little Endian
     static fromIdentityToBytes(options) {
+        function toLittleEndian(bytes) {
+            return new Uint8Array(bytes).reverse();
+        }
         return utf8ToBytes(JSON.stringify({
             treeIndex: options.membership.treeIndex,
             identityCredential: {
-                idCommitment: Array.from(BytesUtils.switchEndianness(options.identity.IDCommitment)),
-                idNullifier: Array.from(BytesUtils.switchEndianness(options.identity.IDNullifier)),
-                idSecretHash: Array.from(BytesUtils.switchEndianness(options.identity.IDSecretHash)),
-                idTrapdoor: Array.from(BytesUtils.switchEndianness(options.identity.IDTrapdoor))
+                idCommitment: Array.from(toLittleEndian(options.identity.IDCommitment)),
+                idNullifier: Array.from(toLittleEndian(options.identity.IDNullifier)),
+                idSecretHash: Array.from(toLittleEndian(options.identity.IDSecretHash)),
+                idTrapdoor: Array.from(toLittleEndian(options.identity.IDTrapdoor))
             },
             membershipContract: {
                 chainId: options.membership.chainId,

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

@@ -1,4 +1,4 @@
-import { BytesUtils } from './utils/bytes.js';
+import { concatenate } from './utils/bytes.js';
 import { poseidonHash } from './utils/hash.js';
 import './utils/epoch.js';
 
@@ -48,7 +48,7 @@ class Proof {
     }
 }
 function proofToBytes(p) {
-    return BytesUtils.concatenate(p.proof, p.merkleRoot, p.epoch, p.shareX, p.shareY, p.nullifier, p.rlnIdentifier);
+    return concatenate(p.proof, p.merkleRoot, p.epoch, p.shareX, p.shareY, p.nullifier, p.rlnIdentifier);
 }
 
 export { Proof, proofToBytes };

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

@@ -1,110 +1,63 @@
-class BytesUtils {
-    /**
-     * Switches endianness of a byte array
-     */
-    static switchEndianness(bytes) {
-        return new Uint8Array(bytes.reverse());
-    }
-    /**
-     * Builds a BigInt from a big-endian Uint8Array
-     * @param bytes The big-endian bytes to convert
-     * @returns The resulting BigInt in big-endian format
-     */
-    static buildBigIntFromUint8ArrayBE(bytes) {
-        let result = 0n;
-        for (let i = 0; i < bytes.length; i++) {
-            result = (result << 8n) + BigInt(bytes[i]);
-        }
-        return result;
-    }
-    /**
-     * Switches endianness of a bigint value
-     * @param value The bigint value to switch endianness for
-     * @returns The bigint value with reversed endianness
-     */
-    static switchEndiannessBigInt(value) {
-        // Convert bigint to byte array
-        const bytes = [];
-        let tempValue = value;
-        while (tempValue > 0n) {
-            bytes.push(Number(tempValue & 0xffn));
-            tempValue >>= 8n;
-        }
-        // Reverse bytes and convert back to bigint
-        return bytes
-            .reverse()
-            .reduce((acc, byte) => (acc << 8n) + BigInt(byte), 0n);
-    }
-    /**
-     * Converts a big-endian bigint to a 32-byte big-endian Uint8Array
-     * @param value The big-endian bigint to convert
-     * @returns A 32-byte big-endian Uint8Array
-     */
-    static bigIntToUint8Array32BE(value) {
-        const bytes = new Uint8Array(32);
-        for (let i = 31; i >= 0; i--) {
-            bytes[i] = Number(value & 0xffn);
-            value >>= 8n;
-        }
-        return bytes;
-    }
-    /**
-     * Writes an unsigned integer to a buffer in little-endian format
-     */
-    static writeUIntLE(buf, value, offset, byteLength, noAssert) {
-        value = +value;
-        offset = offset >>> 0;
-        byteLength = byteLength >>> 0;
-        if (!noAssert) {
-            const maxBytes = Math.pow(2, 8 * byteLength) - 1;
-            BytesUtils.checkInt(buf, value, offset, byteLength, maxBytes, 0);
-        }
-        let mul = 1;
-        let i = 0;
-        buf[offset] = value & 0xff;
-        while (++i < byteLength && (mul *= 0x100)) {
-            buf[offset + i] = (value / mul) & 0xff;
-        }
-        return buf;
-    }
-    /**
-     * Fills with zeros to set length
-     * @param array little endian Uint8Array
-     * @param length amount to pad
-     * @returns little endian Uint8Array padded with zeros to set length
-     */
-    static zeroPadLE(array, length) {
-        const result = new Uint8Array(length);
-        for (let i = 0; i < length; i++) {
-            result[i] = array[i] || 0;
-        }
-        return result;
-    }
-    // Adapted from https://github.com/feross/buffer
-    static checkInt(buf, value, offset, ext, max, min) {
-        if (value > max || value < min)
-            throw new RangeError('"value" argument is out of bounds');
-        if (offset + ext > buf.length)
-            throw new RangeError("Index out of range");
-    }
-    /**
-     * Concatenate Uint8Arrays
-     * @param input
-     * @returns concatenation of all Uint8Array received as input
-     */
-    static concatenate(...input) {
-        let totalLength = 0;
-        for (const arr of input) {
-            totalLength += arr.length;
-        }
-        const result = new Uint8Array(totalLength);
-        let offset = 0;
-        for (const arr of input) {
-            result.set(arr, offset);
-            offset += arr.length;
-        }
-        return result;
-    }
+/**
+ * Concatenate Uint8Arrays
+ * @param input
+ * @returns concatenation of all Uint8Array received as input
+ */
+function concatenate(...input) {
+    let totalLength = 0;
+    for (const arr of input) {
+        totalLength += arr.length;
+    }
+    const result = new Uint8Array(totalLength);
+    let offset = 0;
+    for (const arr of input) {
+        result.set(arr, offset);
+        offset += arr.length;
+    }
+    return result;
+}
+function switchEndianness(bytes) {
+    return new Uint8Array(bytes.reverse());
+}
+function buildBigIntFromUint8ArrayBE(bytes) {
+    // Interpret bytes as big-endian
+    return bytes.reduce((acc, byte) => (acc << 8n) + BigInt(byte), 0n);
+}
+function writeUIntLE(buf, value, offset, byteLength, noAssert) {
+    value = +value;
+    offset = offset >>> 0;
+    byteLength = byteLength >>> 0;
+    {
+        const maxBytes = Math.pow(2, 8 * byteLength) - 1;
+        checkInt(buf, value, offset, byteLength, maxBytes, 0);
+    }
+    let mul = 1;
+    let i = 0;
+    buf[offset] = value & 0xff;
+    while (++i < byteLength && (mul *= 0x100)) {
+        buf[offset + i] = (value / mul) & 0xff;
+    }
+    return buf;
+}
+/**
+ * Fills with zeros to set length
+ * @param array little endian Uint8Array
+ * @param length amount to pad
+ * @returns little endian Uint8Array padded with zeros to set length
+ */
+function zeroPadLE(array, length) {
+    const result = new Uint8Array(length);
+    for (let i = 0; i < length; i++) {
+        result[i] = array[i] || 0;
+    }
+    return result;
+}
+// Adapted from https://github.com/feross/buffer
+function checkInt(buf, value, offset, ext, max, min) {
+    if (value > max || value < min)
+        throw new RangeError('"value" argument is out of bounds');
+    if (offset + ext > buf.length)
+        throw new RangeError("Index out of range");
 }
 
-export { BytesUtils };
+export { buildBigIntFromUint8ArrayBE, concatenate, switchEndianness, writeUIntLE, zeroPadLE };

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

@@ -1,9 +1,9 @@
 import { poseidonHash as poseidonHash$1 } from '../../../../node_modules/@waku/zerokit-rln-wasm/rln_wasm.js';
-import { BytesUtils } from './bytes.js';
+import { writeUIntLE, concatenate } from './bytes.js';
 
 function poseidonHash(...input) {
-    const inputLen = BytesUtils.writeUIntLE(new Uint8Array(8), input.length, 0, 8);
-    const lenPrefixedData = BytesUtils.concatenate(inputLen, ...input);
+    const inputLen = writeUIntLE(new Uint8Array(8), input.length, 0, 8);
+    const lenPrefixedData = concatenate(inputLen, ...input);
     return poseidonHash$1(lenPrefixedData);
 }
 

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

@@ -2,7 +2,7 @@ import { generateExtendedMembershipKey, generateSeededExtendedMembershipKey, ins
 import { DEFAULT_RATE_LIMIT, RATE_LIMIT_PARAMS } from './contract/constants.js';
 import { IdentityCredential } from './identity.js';
 import { Proof, proofToBytes } from './proof.js';
-import { BytesUtils } from './utils/bytes.js';
+import { writeUIntLE, concatenate } from './utils/bytes.js';
 import { epochIntToBytes, dateToEpoch } from './utils/epoch.js';
 
 class Zerokit {
@@ -40,8 +40,8 @@ class Zerokit {
     insertMembers(index, ...idCommitments) {
         // serializes a seq of IDCommitments to a byte seq
         // the order of serialization is |id_commitment_len<8>|id_commitment<var>|
-        const idCommitmentLen = BytesUtils.writeUIntLE(new Uint8Array(8), idCommitments.length, 0, 8);
-        const idCommitmentBytes = BytesUtils.concatenate(idCommitmentLen, ...idCommitments);
+        const idCommitmentLen = writeUIntLE(new Uint8Array(8), idCommitments.length, 0, 8);
+        const idCommitmentBytes = concatenate(idCommitmentLen, ...idCommitments);
         setLeavesFrom(this.zkRLN, index, idCommitmentBytes);
     }
     deleteMember(index) {
@@ -52,11 +52,11 @@ class Zerokit {
     }
     serializeMessage(uint8Msg, memIndex, epoch, idKey, rateLimit) {
         // calculate message length
-        const msgLen = BytesUtils.writeUIntLE(new Uint8Array(8), uint8Msg.length, 0, 8);
-        const memIndexBytes = BytesUtils.writeUIntLE(new Uint8Array(8), memIndex, 0, 8);
-        const rateLimitBytes = BytesUtils.writeUIntLE(new Uint8Array(8), rateLimit ?? this.rateLimit, 0, 8);
+        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 ?? this.rateLimit, 0, 8);
         // [ id_key<32> | id_index<8> | epoch<32> | signal_len<8> | signal<var> | rate_limit<8> ]
-        return BytesUtils.concatenate(idKey, memIndexBytes, epoch, msgLen, uint8Msg, rateLimitBytes);
+        return concatenate(idKey, memIndexBytes, epoch, msgLen, uint8Msg, rateLimitBytes);
     }
     async generateRLNProof(msg, index, epoch, idSecretHash, rateLimit) {
         if (epoch === undefined) {
@@ -92,9 +92,9 @@ class Zerokit {
             pBytes = proofToBytes(proof);
         }
         // calculate message length
-        const msgLen = BytesUtils.writeUIntLE(new Uint8Array(8), msg.length, 0, 8);
-        const rateLimitBytes = BytesUtils.writeUIntLE(new Uint8Array(8), rateLimit ?? this.rateLimit, 0, 8);
-        return verifyRLNProof(this.zkRLN, BytesUtils.concatenate(pBytes, msgLen, msg, rateLimitBytes));
+        const msgLen = writeUIntLE(new Uint8Array(8), msg.length, 0, 8);
+        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) {
         let pBytes;
@@ -105,10 +105,10 @@ class Zerokit {
             pBytes = proofToBytes(proof);
         }
         // calculate message length
-        const msgLen = BytesUtils.writeUIntLE(new Uint8Array(8), msg.length, 0, 8);
-        const rateLimitBytes = BytesUtils.writeUIntLE(new Uint8Array(8), rateLimit ?? this.rateLimit, 0, 8);
-        const rootsBytes = BytesUtils.concatenate(...roots);
-        return verifyWithRoots(this.zkRLN, BytesUtils.concatenate(pBytes, msgLen, msg, rateLimitBytes), rootsBytes);
+        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, rateLimitBytes), rootsBytes);
     }
     verifyWithNoRoot(proof, msg, rateLimit) {
         let pBytes;
@@ -119,9 +119,9 @@ class Zerokit {
             pBytes = proofToBytes(proof);
         }
         // calculate message length
-        const msgLen = BytesUtils.writeUIntLE(new Uint8Array(8), msg.length, 0, 8);
-        const rateLimitBytes = BytesUtils.writeUIntLE(new Uint8Array(8), rateLimit ?? this.rateLimit, 0, 8);
-        return verifyWithRoots(this.zkRLN, BytesUtils.concatenate(pBytes, msgLen, msg, rateLimitBytes), new Uint8Array());
+        const msgLen = writeUIntLE(new Uint8Array(8), msg.length, 0, 8);
+        const rateLimitBytes = writeUIntLE(new Uint8Array(8), rateLimit ?? this.rateLimit, 0, 8);
+        return verifyWithRoots(this.zkRLN, concatenate(pBytes, msgLen, msg, rateLimitBytes), new Uint8Array());
     }
 }