@waku/rln 0.1.6-006cd41.0 → 0.1.6-0877e51.0

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

@@ -13,6 +13,7 @@ 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 { IdentityCredential } from '../identity.js';
 import { RLN_ABI } from './abi.js';
 import { DEFAULT_RATE_LIMIT, RATE_LIMIT_PARAMS } from './constants.js';
 import { MembershipState } from './types.js';
@@ -24,15 +25,32 @@ class RLNBaseContract {
     contract;
     deployBlock;
     rateLimit;
+    minRateLimit;
+    maxRateLimit;
     _members = new Map();
     _membersFilter;
     _membershipErasedFilter;
     _membersExpiredFilter;
     /**
-     * Constructor for RLNBaseContract.
-     * Allows injecting a mocked contract for testing purposes.
+     * Private constructor for RLNBaseContract. Use static create() instead.
      */
     constructor(options) {
+        const { address, signer, rateLimit = DEFAULT_RATE_LIMIT, contract } = options;
+        log.info("Initializing RLNBaseContract", { address, rateLimit });
+        this.contract = contract || new Contract(address, RLN_ABI, signer);
+        this.rateLimit = rateLimit;
+        try {
+            log.info("Setting up event filters");
+            // Initialize event filters
+            this._membersFilter = this.contract.filters.MembershipRegistered();
+            this._membershipErasedFilter = this.contract.filters.MembershipErased();
+            this._membersExpiredFilter = this.contract.filters.MembershipExpired();
+            log.info("Event filters initialized successfully");
+        }
+        catch (error) {
+            log.error("Failed to initialize event filters", { error });
+            throw new Error("Failed to initialize event filters: " + error.message);
+        }
         // Initialize members and subscriptions
         this.fetchMembers()
             .then(() => {
@@ -41,14 +59,21 @@ class RLNBaseContract {
             .catch((error) => {
             log.error("Failed to initialize members", { error });
         });
-        const { address, signer, rateLimit = DEFAULT_RATE_LIMIT, contract } = options;
-        this.validateRateLimit(rateLimit);
-        this.contract = contract || new Contract(address, RLN_ABI, signer);
-        this.rateLimit = rateLimit;
-        // Initialize event filters
-        this._membersFilter = this.contract.filters.MembershipRegistered();
-        this._membershipErasedFilter = this.contract.filters.MembershipErased();
-        this._membersExpiredFilter = this.contract.filters.MembershipExpired();
+    }
+    /**
+     * Static async factory to create and initialize RLNBaseContract
+     */
+    static async create(options) {
+        const instance = new RLNBaseContract(options);
+        const [min, max] = await Promise.all([
+            instance.contract.minMembershipRateLimit(),
+            instance.contract.maxMembershipRateLimit(),
+            instance.contract.Q()
+        ]);
+        instance.minRateLimit = BigNumber.from(min).toNumber();
+        instance.maxRateLimit = BigNumber.from(max).toNumber();
+        instance.validateRateLimit(instance.rateLimit);
+        return instance;
     }
     /**
      * Gets the current rate limit for this contract instance
@@ -69,20 +94,20 @@ class RLNBaseContract {
         return this.contract.provider;
     }
     /**
-     * Gets the minimum allowed rate limit from the contract
-     * @returns Promise<number> The minimum rate limit in messages per epoch
+     * Gets the minimum allowed rate limit (cached)
      */
-    async getMinRateLimit() {
-        const minRate = await this.contract.minMembershipRateLimit();
-        return BigNumber.from(minRate).toNumber();
+    getMinRateLimit() {
+        if (this.minRateLimit === undefined)
+            throw new Error("minRateLimit not initialized");
+        return this.minRateLimit;
     }
     /**
-     * Gets the maximum allowed rate limit from the contract
-     * @returns Promise<number> The maximum rate limit in messages per epoch
+     * Gets the maximum allowed rate limit (cached)
      */
-    async getMaxRateLimit() {
-        const maxRate = await this.contract.maxMembershipRateLimit();
-        return BigNumber.from(maxRate).toNumber();
+    getMaxRateLimit() {
+        if (this.maxRateLimit === undefined)
+            throw new Error("maxRateLimit not initialized");
+        return this.maxRateLimit;
     }
     /**
      * Gets the maximum total rate limit across all memberships
@@ -115,7 +140,7 @@ class RLNBaseContract {
      * Updates the rate limit for future registrations
      * @param newRateLimit The new rate limit to use
      */
-    async setRateLimit(newRateLimit) {
+    setRateLimit(newRateLimit) {
         this.validateRateLimit(newRateLimit);
         this.rateLimit = newRateLimit;
     }
@@ -247,75 +272,67 @@ class RLNBaseContract {
             this.processEvents([event]);
         });
     }
-    /**
-     * Helper method to get remaining messages in current epoch
-     * @param membershipId The ID of the membership to check
-     * @returns number of remaining messages allowed in current epoch
-     */
-    async getRemainingMessages(membershipId) {
-        try {
-            const [startTime, , rateLimit] = await this.contract.getMembershipInfo(membershipId);
-            // Calculate current epoch
-            const currentTime = Math.floor(Date.now() / 1000);
-            const epochsPassed = Math.floor((currentTime - startTime) / RATE_LIMIT_PARAMS.EPOCH_LENGTH);
-            const currentEpochStart = startTime + epochsPassed * RATE_LIMIT_PARAMS.EPOCH_LENGTH;
-            // Get message count in current epoch using contract's function
-            const messageCount = await this.contract.getMessageCount(membershipId, currentEpochStart);
-            return Math.max(0, BigNumber.from(rateLimit)
-                .sub(BigNumber.from(messageCount))
-                .toNumber());
-        }
-        catch (error) {
-            log.error(`Error getting remaining messages: ${error.message}`);
-            return 0; // Fail safe: assume no messages remaining on error
-        }
-    }
-    async getMembershipInfo(idCommitment) {
+    async getMembershipInfo(idCommitmentBigInt) {
         try {
-            const [startBlock, endBlock, rateLimit] = await this.contract.getMembershipInfo(idCommitment);
+            const membershipData = await this.contract.memberships(idCommitmentBigInt);
             const currentBlock = await this.contract.provider.getBlockNumber();
+            const [depositAmount, activeDuration, gracePeriodStartTimestamp, gracePeriodDuration, rateLimit, index, holder, token] = membershipData;
+            const gracePeriodEnd = gracePeriodStartTimestamp.add(gracePeriodDuration);
             let state;
-            if (currentBlock < startBlock) {
+            if (currentBlock < gracePeriodStartTimestamp.toNumber()) {
                 state = MembershipState.Active;
             }
-            else if (currentBlock < endBlock) {
+            else if (currentBlock < gracePeriodEnd.toNumber()) {
                 state = MembershipState.GracePeriod;
             }
             else {
                 state = MembershipState.Expired;
             }
-            const index = await this.getMemberIndex(idCommitment);
-            if (!index)
-                return undefined;
             return {
                 index,
-                idCommitment,
-                rateLimit: rateLimit.toNumber(),
-                startBlock: startBlock.toNumber(),
-                endBlock: endBlock.toNumber(),
-                state
+                idCommitment: idCommitmentBigInt.toString(),
+                rateLimit: Number(rateLimit),
+                startBlock: gracePeriodStartTimestamp.toNumber(),
+                endBlock: gracePeriodEnd.toNumber(),
+                state,
+                depositAmount,
+                activeDuration,
+                gracePeriodDuration,
+                holder,
+                token
             };
         }
         catch (error) {
+            log.error("Error in getMembershipInfo:", error);
             return undefined;
         }
     }
-    async extendMembership(idCommitment) {
-        return this.contract.extendMemberships([idCommitment]);
+    async extendMembership(idCommitmentBigInt) {
+        const tx = await this.contract.extendMemberships([idCommitmentBigInt]);
+        await tx.wait();
+        return tx;
     }
-    async eraseMembership(idCommitment, eraseFromMembershipSet = true) {
-        return this.contract.eraseMemberships([idCommitment], eraseFromMembershipSet);
+    async eraseMembership(idCommitmentBigInt, eraseFromMembershipSet = true) {
+        if (!(await this.isExpired(idCommitmentBigInt)) ||
+            !(await this.isInGracePeriod(idCommitmentBigInt))) {
+            throw new Error("Membership is not expired or in grace period");
+        }
+        const estimatedGas = await this.contract.estimateGas["eraseMemberships(uint256[],bool)"]([idCommitmentBigInt], eraseFromMembershipSet);
+        const gasLimit = estimatedGas.add(10000);
+        const tx = await this.contract["eraseMemberships(uint256[],bool)"]([idCommitmentBigInt], eraseFromMembershipSet, { gasLimit });
+        await tx.wait();
+        return tx;
     }
-    async registerMembership(idCommitment, rateLimit = DEFAULT_RATE_LIMIT) {
+    async registerMembership(idCommitmentBigInt, 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, []);
+        return this.contract.register(idCommitmentBigInt, rateLimit, []);
     }
-    async withdraw(token, holder) {
+    async withdraw(token, walletAddress) {
         try {
-            const tx = await this.contract.withdraw(token, { from: holder });
+            const tx = await this.contract.withdraw(token, walletAddress);
             await tx.wait();
         }
         catch (error) {
@@ -325,8 +342,9 @@ class RLNBaseContract {
     async registerWithIdentity(identity) {
         try {
             log.info(`Registering identity with rate limit: ${this.rateLimit} messages/epoch`);
+            const idCommitmentBigInt = IdentityCredential.getIdCommitmentBigInt(identity.IDCommitment);
             // Check if the ID commitment is already registered
-            const existingIndex = await this.getMemberIndex(identity.IDCommitmentBigInt.toString());
+            const existingIndex = await this.getMemberIndex(idCommitmentBigInt);
             if (existingIndex) {
                 throw new Error(`ID commitment is already registered with index ${existingIndex}`);
             }
@@ -335,9 +353,11 @@ 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, [], { gasLimit });
+            const txRegisterResponse = await this.contract.register(idCommitmentBigInt, this.rateLimit, [], {
+                gasLimit
+            });
             const txRegisterReceipt = await txRegisterResponse.wait();
             if (txRegisterReceipt.status === 0) {
                 throw new Error("Transaction failed on-chain");
@@ -399,7 +419,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, identity.IDCommitmentBigInt, this.rateLimit, idCommitmentsToErase.map((id) => BigNumber.from(id)));
+            const txRegisterResponse = await this.contract.registerWithPermit(permit.owner, permit.deadline, permit.v, permit.r, permit.s, IdentityCredential.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) {
@@ -432,13 +452,15 @@ class RLNBaseContract {
         }
     }
     /**
-     * Validates that the rate limit is within the allowed range
+     * Validates that the rate limit is within the allowed range (sync)
      * @throws Error if the rate limit is outside the allowed range
      */
     validateRateLimit(rateLimit) {
-        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} messages per epoch`);
+        if (this.minRateLimit === undefined || this.maxRateLimit === undefined) {
+            throw new Error("Rate limits not initialized");
+        }
+        if (rateLimit < this.minRateLimit || rateLimit > this.maxRateLimit) {
+            throw new Error(`Rate limit must be between ${this.minRateLimit} and ${this.maxRateLimit} messages per epoch`);
         }
     }
     get membersFilter() {
@@ -459,9 +481,9 @@ class RLNBaseContract {
         }
         return this._membersExpiredFilter;
     }
-    async getMemberIndex(idCommitment) {
+    async getMemberIndex(idCommitmentBigInt) {
         try {
-            const events = await this.contract.queryFilter(this.contract.filters.MembershipRegistered(idCommitment));
+            const events = await this.contract.queryFilter(this.contract.filters.MembershipRegistered(idCommitmentBigInt));
             if (events.length === 0)
                 return undefined;
             // Get the most recent registration event
@@ -472,6 +494,45 @@ class RLNBaseContract {
             return undefined;
         }
     }
+    async getMembershipStatus(idCommitment) {
+        const [isExpired, isInGrace] = await Promise.all([
+            this.contract.isExpired(idCommitment),
+            this.contract.isInGracePeriod(idCommitment)
+        ]);
+        if (isExpired)
+            return "expired";
+        if (isInGrace)
+            return "grace";
+        return "active";
+    }
+    /**
+     * Checks if a membership is expired for the given idCommitment
+     * @param idCommitmentBigInt The idCommitment as bigint
+     * @returns Promise<boolean> True if expired, false otherwise
+     */
+    async isExpired(idCommitmentBigInt) {
+        try {
+            return await this.contract.isExpired(idCommitmentBigInt);
+        }
+        catch (error) {
+            log.error("Error in isExpired:", error);
+            return false;
+        }
+    }
+    /**
+     * Checks if a membership is in grace period for the given idCommitment
+     * @param idCommitmentBigInt The idCommitment as bigint
+     * @returns Promise<boolean> True if in grace period, false otherwise
+     */
+    async isInGracePeriod(idCommitmentBigInt) {
+        try {
+            return await this.contract.isInGracePeriod(idCommitmentBigInt);
+        }
+        catch (error) {
+            log.error("Error in isInGracePeriod:", error);
+            return false;
+        }
+    }
 }
 
 export { RLNBaseContract };

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

@@ -1,5 +1,5 @@
-import { hmac } from '../node_modules/@noble/hashes/esm/hmac.js';
-import { sha256 } from '../node_modules/@noble/hashes/esm/sha256.js';
+import { hmac } from '../../../node_modules/@noble/hashes/esm/hmac.js';
+import { sha256 } from '../../../node_modules/@noble/hashes/esm/sha2.js';
 import '../../interfaces/dist/protocols.js';
 import '../../interfaces/dist/connection_manager.js';
 import '../../interfaces/dist/health_indicator.js';
@@ -20,7 +20,7 @@ import { RLNBaseContract } from './contract/rln_base_contract.js';
 import { IdentityCredential } from './identity.js';
 import { Keystore } from './keystore/keystore.js';
 import { extractMetaMaskSigner } from './utils/metamask.js';
-import { buildBigIntFromUint8Array } from './utils/bytes.js';
+import { switchEndianness } from './utils/bytes.js';
 import './utils/epoch.js';
 
 const log = new Logger("waku:credentials");
@@ -64,7 +64,7 @@ class RLNCredentialsManager {
             }
             this.credentials = credentials;
             this.signer = signer;
-            this.contract = new RLNBaseContract({
+            this.contract = await RLNBaseContract.create({
                 address: address,
                 signer: signer,
                 rateLimit: rateLimit ?? this.zerokit?.rateLimit
@@ -95,7 +95,7 @@ class RLNCredentialsManager {
             }
             else {
                 log.info("Using local implementation to generate identity");
-                identity = this.generateSeededIdentityCredential(options.signature);
+                identity = await this.generateSeededIdentityCredential(options.signature);
             }
         }
         if (!identity) {
@@ -191,24 +191,26 @@ class RLNCredentialsManager {
      * @param seed A string seed to generate the identity from
      * @returns IdentityCredential
      */
-    generateSeededIdentityCredential(seed) {
+    async generateSeededIdentityCredential(seed) {
         log.info("Generating seeded identity credential");
         // Convert the seed to bytes
         const encoder = new TextEncoder();
         const seedBytes = encoder.encode(seed);
         // Generate deterministic values using HMAC-SHA256
         // We use different context strings for each component to ensure they're different
-        const idTrapdoor = hmac(sha256, seedBytes, encoder.encode("IDTrapdoor"));
-        const idNullifier = hmac(sha256, seedBytes, encoder.encode("IDNullifier"));
-        // Generate IDSecretHash as a hash of IDTrapdoor and IDNullifier
-        const combinedBytes = new Uint8Array([...idTrapdoor, ...idNullifier]);
-        const idSecretHash = sha256(combinedBytes);
-        // Generate IDCommitment as a hash of IDSecretHash
-        const idCommitment = sha256(idSecretHash);
-        // Convert IDCommitment to BigInt
-        const idCommitmentBigInt = buildBigIntFromUint8Array(idCommitment);
+        const idTrapdoorBE = hmac(sha256, seedBytes, encoder.encode("IDTrapdoor"));
+        const idNullifierBE = hmac(sha256, seedBytes, encoder.encode("IDNullifier"));
+        const combinedBytes = new Uint8Array([...idTrapdoorBE, ...idNullifierBE]);
+        const idSecretHashBE = sha256(combinedBytes);
+        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(idTrapdoor, idNullifier, idSecretHash, idCommitment, idCommitmentBigInt);
+        return new IdentityCredential(idTrapdoorLE, idNullifierLE, idSecretHashLE, idCommitmentLE);
     }
 }
 

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

@@ -1,18 +1,35 @@
-import { buildBigIntFromUint8Array } from './utils/bytes.js';
-import './utils/epoch.js';
+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 { DEFAULT_Q } from './contract/constants.js';
+import { buildBigIntFromUint8ArrayBE } from './utils/bytes.js';
 
+const log = new Logger("waku:rln:identity");
 class IdentityCredential {
     IDTrapdoor;
     IDNullifier;
     IDSecretHash;
     IDCommitment;
-    IDCommitmentBigInt;
-    constructor(IDTrapdoor, IDNullifier, IDSecretHash, IDCommitment, IDCommitmentBigInt) {
+    /**
+     * All variables are in little-endian format
+     */
+    constructor(IDTrapdoor, IDNullifier, IDSecretHash, IDCommitment) {
         this.IDTrapdoor = IDTrapdoor;
         this.IDNullifier = IDNullifier;
         this.IDSecretHash = IDSecretHash;
         this.IDCommitment = IDCommitment;
-        this.IDCommitmentBigInt = IDCommitmentBigInt;
     }
     static fromBytes(memKeys) {
         if (memKeys.length < 128) {
@@ -22,8 +39,21 @@ class IdentityCredential {
         const idNullifier = memKeys.subarray(32, 64);
         const idSecretHash = memKeys.subarray(64, 96);
         const idCommitment = memKeys.subarray(96, 128);
-        const idCommitmentBigInt = buildBigIntFromUint8Array(idCommitment, 32);
-        return new IdentityCredential(idTrapdoor, idNullifier, idSecretHash, idCommitment, idCommitmentBigInt);
+        return new IdentityCredential(idTrapdoor, idNullifier, idSecretHash, idCommitment);
+    }
+    /**
+     * Converts an ID commitment from bytes to a BigInt, normalizing it against a limit if needed
+     * @param bytes The ID commitment bytes to convert
+     * @param limit Optional limit to normalize against (Q value)
+     * @returns The ID commitment as a BigInt
+     */
+    static getIdCommitmentBigInt(idCommitment, limit = DEFAULT_Q) {
+        let idCommitmentBigIntBE = buildBigIntFromUint8ArrayBE(idCommitment);
+        if (limit && idCommitmentBigIntBE >= limit) {
+            log.warn(`ID commitment is greater than Q, reducing it by Q: ${idCommitmentBigIntBE} % ${limit}`);
+            idCommitmentBigIntBE = idCommitmentBigIntBE % limit;
+        }
+        return idCommitmentBigIntBE;
     }
 }
 

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

@@ -1,6 +1,6 @@
-import { cipherDecrypt as cipherDecrypt_1 } from '../../node_modules/@chainsafe/bls-keystore/lib/cipher.js';
-import { kdf as kdf_2 } from '../../node_modules/@chainsafe/bls-keystore/lib/kdf.js';
-import { normalizePassword as normalizePassword_1 } from '../../node_modules/@chainsafe/bls-keystore/lib/password.js';
+import { cipherDecrypt as cipherDecrypt_1 } from '../../../../node_modules/@chainsafe/bls-keystore/lib/cipher.js';
+import { kdf as kdf_2 } from '../../../../node_modules/@chainsafe/bls-keystore/lib/kdf.js';
+import { normalizePassword as normalizePassword_1 } from '../../../../node_modules/@chainsafe/bls-keystore/lib/password.js';
 import { keccak256 } from '../../../../node_modules/ethereum-cryptography/esm/keccak.js';
 import { hexToBytes } from '../../../../node_modules/ethereum-cryptography/esm/utils.js';
 import { concatBytes, bytesToHex } from '../../../../node_modules/@noble/hashes/esm/utils.js';

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

@@ -1,4 +1,4 @@
-import '../../node_modules/@chainsafe/bls-keystore/lib/index.js';
+import '../../../../node_modules/@chainsafe/bls-keystore/lib/index.js';
 import '../../../interfaces/dist/protocols.js';
 import '../../../interfaces/dist/connection_manager.js';
 import '../../../interfaces/dist/health_indicator.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 { buildBigIntFromUint8Array } 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,14 +163,16 @@ class Keystore {
         try {
             const str = bytesToUtf8(bytes);
             const obj = JSON.parse(str);
-            // TODO: add runtime validation of nwaku credentials
+            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", []));
             return {
                 identity: {
-                    IDCommitment: Keystore.fromArraylikeToBytes(_.get(obj, "identityCredential.idCommitment", [])),
-                    IDTrapdoor: Keystore.fromArraylikeToBytes(_.get(obj, "identityCredential.idTrapdoor", [])),
-                    IDNullifier: Keystore.fromArraylikeToBytes(_.get(obj, "identityCredential.idNullifier", [])),
-                    IDCommitmentBigInt: buildBigIntFromUint8Array(Keystore.fromArraylikeToBytes(_.get(obj, "identityCredential.idCommitment", []))),
-                    IDSecretHash: Keystore.fromArraylikeToBytes(_.get(obj, "identityCredential.idSecretHash", []))
+                    IDCommitment: idCommitmentLE,
+                    IDTrapdoor: idTrapdoorLE,
+                    IDNullifier: idNullifierLE,
+                    IDSecretHash: idSecretHashLE
                 },
                 membership: {
                     treeIndex: _.get(obj, "treeIndex"),
@@ -208,13 +209,16 @@ class Keystore {
     // follows nwaku implementation
     // https://github.com/waku-org/nwaku/blob/f05528d4be3d3c876a8b07f9bb7dfaae8aa8ec6e/waku/waku_keystore/protocol_types.nim#L98
     static fromIdentityToBytes(options) {
+        function toLittleEndian(bytes) {
+            return new Uint8Array(bytes).reverse();
+        }
         return utf8ToBytes(JSON.stringify({
             treeIndex: options.membership.treeIndex,
             identityCredential: {
-                idCommitment: Array.from(options.identity.IDCommitment),
-                idNullifier: Array.from(options.identity.IDNullifier),
-                idSecretHash: Array.from(options.identity.IDSecretHash),
-                idTrapdoor: Array.from(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/message.js

@@ -1,4 +1,14 @@
+import { Version } from '../../core/dist/lib/message/version_0.js';
+import '../../core/dist/lib/filter/filter.js';
+import '../../core/dist/lib/light_push/light_push.js';
+import '../../core/dist/lib/store/store.js';
+import '../../core/dist/lib/connection_manager/connection_manager.js';
+import '../../interfaces/dist/protocols.js';
+import '../../interfaces/dist/connection_manager.js';
+import '../../interfaces/dist/health_indicator.js';
 import { utf8ToBytes } from '../../utils/dist/bytes/index.js';
+import '../../../node_modules/debug/src/browser.js';
+import '../../core/dist/lib/metadata/metadata.js';
 import { epochBytesToInt } from './utils/epoch.js';
 
 function toRLNSignal(contentTopic, msg) {
@@ -10,6 +20,7 @@ class RlnMessage {
     msg;
     rateLimitProof;
     pubsubTopic = "";
+    version = Version;
     constructor(rlnInstance, msg, rateLimitProof) {
         this.rlnInstance = rlnInstance;
         this.msg = msg;

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

@@ -16,12 +16,12 @@ function concatenate(...input) {
     }
     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");
+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;
@@ -39,15 +39,6 @@ function writeUIntLE(buf, value, offset, byteLength, noAssert) {
     }
     return buf;
 }
-/**
- * Transforms Uint8Array into BigInt
- * @param array: Uint8Array
- * @returns BigInt
- */
-function buildBigIntFromUint8Array(array, byteOffset = 0) {
-    const dataView = new DataView(array.buffer);
-    return dataView.getBigUint64(byteOffset, true);
-}
 /**
  * Fills with zeros to set length
  * @param array little endian Uint8Array
@@ -61,5 +52,12 @@ function zeroPadLE(array, length) {
     }
     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 { buildBigIntFromUint8Array, concatenate, writeUIntLE, zeroPadLE };
+export { buildBigIntFromUint8ArrayBE, concatenate, switchEndianness, writeUIntLE, zeroPadLE };