@waku/rln 0.1.6-acc9100.0 → 0.1.6-b0a2e39.0

package/bundle/packages/proto/dist/generated/light_push_v3.js

@@ -0,0 +1,348 @@
+import { decodeMessage } from '../../../../node_modules/protons-runtime/dist/src/decode.js';
+import { encodeMessage } from '../../../../node_modules/protons-runtime/dist/src/encode.js';
+import '../../../../node_modules/protons-runtime/dist/src/codec.js';
+import { message } from '../../../../node_modules/protons-runtime/dist/src/codecs/message.js';
+import { alloc } from '../../../../node_modules/uint8arrays/dist/src/alloc.js';
+import '../../../../node_modules/protons-runtime/dist/src/utils/float.js';
+import '../../../../node_modules/protons-runtime/dist/src/utils/longbits.js';
+import '../../../../node_modules/protons-runtime/dist/src/utils/writer.js';
+
+/* eslint-disable import/export */
+/* eslint-disable complexity */
+/* eslint-disable @typescript-eslint/no-namespace */
+/* eslint-disable @typescript-eslint/no-unnecessary-boolean-literal-compare */
+/* eslint-disable @typescript-eslint/no-empty-interface */
+var LightpushRequest;
+(function (LightpushRequest) {
+    let _codec;
+    LightpushRequest.codec = () => {
+        if (_codec == null) {
+            _codec = message((obj, w, opts = {}) => {
+                if (opts.lengthDelimited !== false) {
+                    w.fork();
+                }
+                if ((obj.requestId != null && obj.requestId !== '')) {
+                    w.uint32(10);
+                    w.string(obj.requestId);
+                }
+                if (obj.pubsubTopic != null) {
+                    w.uint32(162);
+                    w.string(obj.pubsubTopic);
+                }
+                if (obj.message != null) {
+                    w.uint32(170);
+                    WakuMessage.codec().encode(obj.message, w);
+                }
+                if (opts.lengthDelimited !== false) {
+                    w.ldelim();
+                }
+            }, (reader, length, opts = {}) => {
+                const obj = {
+                    requestId: ''
+                };
+                const end = length == null ? reader.len : reader.pos + length;
+                while (reader.pos < end) {
+                    const tag = reader.uint32();
+                    switch (tag >>> 3) {
+                        case 1: {
+                            obj.requestId = reader.string();
+                            break;
+                        }
+                        case 20: {
+                            obj.pubsubTopic = reader.string();
+                            break;
+                        }
+                        case 21: {
+                            obj.message = WakuMessage.codec().decode(reader, reader.uint32(), {
+                                limits: opts.limits?.message
+                            });
+                            break;
+                        }
+                        default: {
+                            reader.skipType(tag & 7);
+                            break;
+                        }
+                    }
+                }
+                return obj;
+            });
+        }
+        return _codec;
+    };
+    LightpushRequest.encode = (obj) => {
+        return encodeMessage(obj, LightpushRequest.codec());
+    };
+    LightpushRequest.decode = (buf, opts) => {
+        return decodeMessage(buf, LightpushRequest.codec(), opts);
+    };
+})(LightpushRequest || (LightpushRequest = {}));
+var LightpushResponse;
+(function (LightpushResponse) {
+    let _codec;
+    LightpushResponse.codec = () => {
+        if (_codec == null) {
+            _codec = message((obj, w, opts = {}) => {
+                if (opts.lengthDelimited !== false) {
+                    w.fork();
+                }
+                if ((obj.requestId != null && obj.requestId !== '')) {
+                    w.uint32(10);
+                    w.string(obj.requestId);
+                }
+                if ((obj.statusCode != null && obj.statusCode !== 0)) {
+                    w.uint32(80);
+                    w.uint32(obj.statusCode);
+                }
+                if (obj.statusDesc != null) {
+                    w.uint32(90);
+                    w.string(obj.statusDesc);
+                }
+                if (obj.relayPeerCount != null) {
+                    w.uint32(96);
+                    w.uint32(obj.relayPeerCount);
+                }
+                if (opts.lengthDelimited !== false) {
+                    w.ldelim();
+                }
+            }, (reader, length, opts = {}) => {
+                const obj = {
+                    requestId: '',
+                    statusCode: 0
+                };
+                const end = length == null ? reader.len : reader.pos + length;
+                while (reader.pos < end) {
+                    const tag = reader.uint32();
+                    switch (tag >>> 3) {
+                        case 1: {
+                            obj.requestId = reader.string();
+                            break;
+                        }
+                        case 10: {
+                            obj.statusCode = reader.uint32();
+                            break;
+                        }
+                        case 11: {
+                            obj.statusDesc = reader.string();
+                            break;
+                        }
+                        case 12: {
+                            obj.relayPeerCount = reader.uint32();
+                            break;
+                        }
+                        default: {
+                            reader.skipType(tag & 7);
+                            break;
+                        }
+                    }
+                }
+                return obj;
+            });
+        }
+        return _codec;
+    };
+    LightpushResponse.encode = (obj) => {
+        return encodeMessage(obj, LightpushResponse.codec());
+    };
+    LightpushResponse.decode = (buf, opts) => {
+        return decodeMessage(buf, LightpushResponse.codec(), opts);
+    };
+})(LightpushResponse || (LightpushResponse = {}));
+var RateLimitProof;
+(function (RateLimitProof) {
+    let _codec;
+    RateLimitProof.codec = () => {
+        if (_codec == null) {
+            _codec = message((obj, w, opts = {}) => {
+                if (opts.lengthDelimited !== false) {
+                    w.fork();
+                }
+                if ((obj.proof != null && obj.proof.byteLength > 0)) {
+                    w.uint32(10);
+                    w.bytes(obj.proof);
+                }
+                if ((obj.merkleRoot != null && obj.merkleRoot.byteLength > 0)) {
+                    w.uint32(18);
+                    w.bytes(obj.merkleRoot);
+                }
+                if ((obj.epoch != null && obj.epoch.byteLength > 0)) {
+                    w.uint32(26);
+                    w.bytes(obj.epoch);
+                }
+                if ((obj.shareX != null && obj.shareX.byteLength > 0)) {
+                    w.uint32(34);
+                    w.bytes(obj.shareX);
+                }
+                if ((obj.shareY != null && obj.shareY.byteLength > 0)) {
+                    w.uint32(42);
+                    w.bytes(obj.shareY);
+                }
+                if ((obj.nullifier != null && obj.nullifier.byteLength > 0)) {
+                    w.uint32(50);
+                    w.bytes(obj.nullifier);
+                }
+                if ((obj.rlnIdentifier != null && obj.rlnIdentifier.byteLength > 0)) {
+                    w.uint32(58);
+                    w.bytes(obj.rlnIdentifier);
+                }
+                if (opts.lengthDelimited !== false) {
+                    w.ldelim();
+                }
+            }, (reader, length, opts = {}) => {
+                const obj = {
+                    proof: alloc(0),
+                    merkleRoot: alloc(0),
+                    epoch: alloc(0),
+                    shareX: alloc(0),
+                    shareY: alloc(0),
+                    nullifier: alloc(0),
+                    rlnIdentifier: alloc(0)
+                };
+                const end = length == null ? reader.len : reader.pos + length;
+                while (reader.pos < end) {
+                    const tag = reader.uint32();
+                    switch (tag >>> 3) {
+                        case 1: {
+                            obj.proof = reader.bytes();
+                            break;
+                        }
+                        case 2: {
+                            obj.merkleRoot = reader.bytes();
+                            break;
+                        }
+                        case 3: {
+                            obj.epoch = reader.bytes();
+                            break;
+                        }
+                        case 4: {
+                            obj.shareX = reader.bytes();
+                            break;
+                        }
+                        case 5: {
+                            obj.shareY = reader.bytes();
+                            break;
+                        }
+                        case 6: {
+                            obj.nullifier = reader.bytes();
+                            break;
+                        }
+                        case 7: {
+                            obj.rlnIdentifier = reader.bytes();
+                            break;
+                        }
+                        default: {
+                            reader.skipType(tag & 7);
+                            break;
+                        }
+                    }
+                }
+                return obj;
+            });
+        }
+        return _codec;
+    };
+    RateLimitProof.encode = (obj) => {
+        return encodeMessage(obj, RateLimitProof.codec());
+    };
+    RateLimitProof.decode = (buf, opts) => {
+        return decodeMessage(buf, RateLimitProof.codec(), opts);
+    };
+})(RateLimitProof || (RateLimitProof = {}));
+var WakuMessage;
+(function (WakuMessage) {
+    let _codec;
+    WakuMessage.codec = () => {
+        if (_codec == null) {
+            _codec = message((obj, w, opts = {}) => {
+                if (opts.lengthDelimited !== false) {
+                    w.fork();
+                }
+                if ((obj.payload != null && obj.payload.byteLength > 0)) {
+                    w.uint32(10);
+                    w.bytes(obj.payload);
+                }
+                if ((obj.contentTopic != null && obj.contentTopic !== '')) {
+                    w.uint32(18);
+                    w.string(obj.contentTopic);
+                }
+                if (obj.version != null) {
+                    w.uint32(24);
+                    w.uint32(obj.version);
+                }
+                if (obj.timestamp != null) {
+                    w.uint32(80);
+                    w.sint64(obj.timestamp);
+                }
+                if (obj.meta != null) {
+                    w.uint32(90);
+                    w.bytes(obj.meta);
+                }
+                if (obj.rateLimitProof != null) {
+                    w.uint32(170);
+                    RateLimitProof.codec().encode(obj.rateLimitProof, w);
+                }
+                if (obj.ephemeral != null) {
+                    w.uint32(248);
+                    w.bool(obj.ephemeral);
+                }
+                if (opts.lengthDelimited !== false) {
+                    w.ldelim();
+                }
+            }, (reader, length, opts = {}) => {
+                const obj = {
+                    payload: alloc(0),
+                    contentTopic: ''
+                };
+                const end = length == null ? reader.len : reader.pos + length;
+                while (reader.pos < end) {
+                    const tag = reader.uint32();
+                    switch (tag >>> 3) {
+                        case 1: {
+                            obj.payload = reader.bytes();
+                            break;
+                        }
+                        case 2: {
+                            obj.contentTopic = reader.string();
+                            break;
+                        }
+                        case 3: {
+                            obj.version = reader.uint32();
+                            break;
+                        }
+                        case 10: {
+                            obj.timestamp = reader.sint64();
+                            break;
+                        }
+                        case 11: {
+                            obj.meta = reader.bytes();
+                            break;
+                        }
+                        case 21: {
+                            obj.rateLimitProof = RateLimitProof.codec().decode(reader, reader.uint32(), {
+                                limits: opts.limits?.rateLimitProof
+                            });
+                            break;
+                        }
+                        case 31: {
+                            obj.ephemeral = reader.bool();
+                            break;
+                        }
+                        default: {
+                            reader.skipType(tag & 7);
+                            break;
+                        }
+                    }
+                }
+                return obj;
+            });
+        }
+        return _codec;
+    };
+    WakuMessage.encode = (obj) => {
+        return encodeMessage(obj, WakuMessage.codec());
+    };
+    WakuMessage.decode = (buf, opts) => {
+        return decodeMessage(buf, WakuMessage.codec(), opts);
+    };
+})(WakuMessage || (WakuMessage = {}));
+
+export { LightpushRequest, LightpushResponse, RateLimitProof, WakuMessage };

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

@@ -1,3 +1,4 @@
+import '../../interfaces/dist/light_push_v3.js';
 import '../../interfaces/dist/protocols.js';
 import '../../interfaces/dist/connection_manager.js';
 import '../../interfaces/dist/health_indicator.js';

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

@@ -22,12 +22,6 @@ const RATE_LIMIT_PARAMS = {
     MAX_TOTAL_RATE: 160_000, // Maximum total rate limit across all memberships
     EPOCH_LENGTH: 600 // Epoch length in seconds (10 minutes)
 };
-/**
- * Default Q value for the RLN contract
- * This is the upper bound for the ID commitment
- * @see https://github.com/waku-org/specs/blob/master/standards/core/rln-contract.md#implementation-suggestions
- */
-const DEFAULT_Q = BigInt("21888242871839275222246405745257275088548364400416034343698204186575808495617");
 const DEFAULT_RATE_LIMIT = RATE_LIMIT_PARAMS.MAX_RATE;
 
-export { DEFAULT_Q, DEFAULT_RATE_LIMIT, LINEA_CONTRACT, RATE_LIMIT_PARAMS, RATE_LIMIT_TIERS };
+export { DEFAULT_RATE_LIMIT, LINEA_CONTRACT, RATE_LIMIT_PARAMS, RATE_LIMIT_TIERS };

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

@@ -1,3 +1,4 @@
+import '../../../interfaces/dist/light_push_v3.js';
 import '../../../interfaces/dist/protocols.js';
 import '../../../interfaces/dist/connection_manager.js';
 import '../../../interfaces/dist/health_indicator.js';
@@ -13,9 +14,8 @@ 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 { buildBigIntFromUint8ArrayBE } from '../utils/bytes.js';
 import { RLN_ABI } from './abi.js';
-import { DEFAULT_Q, DEFAULT_RATE_LIMIT, RATE_LIMIT_PARAMS } from './constants.js';
+import { 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,11 +27,6 @@ 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;
@@ -72,8 +67,7 @@ class RLNBaseContract {
         const instance = new RLNBaseContract(options);
         const [min, max] = await Promise.all([
             instance.contract.minMembershipRateLimit(),
-            instance.contract.maxMembershipRateLimit(),
-            instance.contract.Q()
+            instance.contract.maxMembershipRateLimit()
         ]);
         instance.minRateLimit = BigNumber.from(min).toNumber();
         instance.maxRateLimit = BigNumber.from(max).toNumber();
@@ -344,24 +338,11 @@ class RLNBaseContract {
             log.error(`Error in withdraw: ${error.message}`);
         }
     }
-    getIdCommitmentBigInt(bytes) {
-        let idCommitmentBigIntBE = buildBigIntFromUint8ArrayBE(bytes);
-        if (!this.contract) {
-            throw Error("RLN contract is not initialized");
-        }
-        if (idCommitmentBigIntBE >= this.idCommitmentBigIntLimit) {
-            log.warn(`ID commitment is greater than Q, reducing it by Q(idCommitmentBigIntLimit): ${idCommitmentBigIntBE} % ${this.idCommitmentBigIntLimit}`);
-            idCommitmentBigIntBE =
-                idCommitmentBigIntBE % this.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(idCommitmentBigInt);
+            const existingIndex = await this.getMemberIndex(identity.IDCommitmentBigInt);
             if (existingIndex) {
                 throw new Error(`ID commitment is already registered with index ${existingIndex}`);
             }
@@ -370,11 +351,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(idCommitmentBigInt, this.rateLimit, []);
+            const estimatedGas = await this.contract.estimateGas.register(identity.IDCommitmentBigInt, this.rateLimit, []);
             const gasLimit = estimatedGas.add(10000);
-            const txRegisterResponse = await this.contract.register(idCommitmentBigInt, this.rateLimit, [], {
-                gasLimit
-            });
+            const txRegisterResponse = await this.contract.register(identity.IDCommitmentBigInt, this.rateLimit, [], { gasLimit });
             const txRegisterReceipt = await txRegisterResponse.wait();
             if (txRegisterReceipt.status === 0) {
                 throw new Error("Transaction failed on-chain");
@@ -436,7 +415,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, this.getIdCommitmentBigInt(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, identity.IDCommitmentBigInt, 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

@@ -1,3 +1,4 @@
+import '../../../interfaces/dist/light_push_v3.js';
 import '../../../interfaces/dist/protocols.js';
 import '../../../interfaces/dist/connection_manager.js';
 import '../../../interfaces/dist/health_indicator.js';

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

@@ -1,5 +1,6 @@
 import { hmac } from '../../../node_modules/@noble/hashes/esm/hmac.js';
-import { sha256 } from '../../../node_modules/@noble/hashes/esm/sha2.js';
+import { sha256 } from '../../../node_modules/@noble/hashes/esm/sha256.js';
+import '../../interfaces/dist/light_push_v3.js';
 import '../../interfaces/dist/protocols.js';
 import '../../interfaces/dist/connection_manager.js';
 import '../../interfaces/dist/health_indicator.js';
@@ -20,7 +21,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 { switchEndianness } from './utils/bytes.js';
+import { buildBigIntFromUint8Array } from './utils/bytes.js';
 import './utils/epoch.js';
 
 const log = new Logger("waku:credentials");
@@ -95,7 +96,7 @@ class RLNCredentialsManager {
             }
             else {
                 log.info("Using local implementation to generate identity");
-                identity = await this.generateSeededIdentityCredential(options.signature);
+                identity = this.generateSeededIdentityCredential(options.signature);
             }
         }
         if (!identity) {
@@ -191,26 +192,24 @@ class RLNCredentialsManager {
      * @param seed A string seed to generate the identity from
      * @returns IdentityCredential
      */
-    async generateSeededIdentityCredential(seed) {
+    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 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);
+        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);
         log.info("Successfully generated identity credential");
-        return new IdentityCredential(idTrapdoorLE, idNullifierLE, idSecretHashLE, idCommitmentLE);
+        return new IdentityCredential(idTrapdoor, idNullifier, idSecretHash, idCommitment, idCommitmentBigInt);
     }
 }
 

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

@@ -1,16 +1,18 @@
+import { buildBigIntFromUint8Array } from './utils/bytes.js';
+import './utils/epoch.js';
+
 class IdentityCredential {
     IDTrapdoor;
     IDNullifier;
     IDSecretHash;
     IDCommitment;
-    /**
-     * All variables are in little-endian format
-     */
-    constructor(IDTrapdoor, IDNullifier, IDSecretHash, IDCommitment) {
+    IDCommitmentBigInt;
+    constructor(IDTrapdoor, IDNullifier, IDSecretHash, IDCommitment, IDCommitmentBigInt) {
         this.IDTrapdoor = IDTrapdoor;
         this.IDNullifier = IDNullifier;
         this.IDSecretHash = IDSecretHash;
         this.IDCommitment = IDCommitment;
+        this.IDCommitmentBigInt = IDCommitmentBigInt;
     }
     static fromBytes(memKeys) {
         if (memKeys.length < 128) {
@@ -20,7 +22,8 @@ class IdentityCredential {
         const idNullifier = memKeys.subarray(32, 64);
         const idSecretHash = memKeys.subarray(64, 96);
         const idCommitment = memKeys.subarray(96, 128);
-        return new IdentityCredential(idTrapdoor, idNullifier, idSecretHash, idCommitment);
+        const idCommitmentBigInt = buildBigIntFromUint8Array(idCommitment, 32);
+        return new IdentityCredential(idTrapdoor, idNullifier, idSecretHash, idCommitment, idCommitmentBigInt);
     }
 }
 

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

@@ -1,4 +1,5 @@
 import '../../../../node_modules/@chainsafe/bls-keystore/lib/index.js';
+import '../../../interfaces/dist/light_push_v3.js';
 import '../../../interfaces/dist/protocols.js';
 import '../../../interfaces/dist/connection_manager.js';
 import '../../../interfaces/dist/health_indicator.js';
@@ -17,6 +18,7 @@ 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';
@@ -163,16 +165,14 @@ class Keystore {
         try {
             const str = bytesToUtf8(bytes);
             const obj = JSON.parse(str);
-            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", []));
+            // TODO: add runtime validation of nwaku credentials
             return {
                 identity: {
-                    IDCommitment: idCommitmentLE,
-                    IDTrapdoor: idTrapdoorLE,
-                    IDNullifier: idNullifierLE,
-                    IDSecretHash: idSecretHashLE
+                    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", []))
                 },
                 membership: {
                     treeIndex: _.get(obj, "treeIndex"),
@@ -209,16 +209,13 @@ 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(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))
+                idCommitment: Array.from(options.identity.IDCommitment),
+                idNullifier: Array.from(options.identity.IDNullifier),
+                idSecretHash: Array.from(options.identity.IDSecretHash),
+                idTrapdoor: Array.from(options.identity.IDTrapdoor)
             },
             membershipContract: {
                 chainId: options.membership.chainId,

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

@@ -1,8 +1,10 @@
 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/light_push/light_push_v3.js';
 import '../../core/dist/lib/store/store.js';
 import '../../core/dist/lib/connection_manager/connection_manager.js';
+import '../../interfaces/dist/light_push_v3.js';
 import '../../interfaces/dist/protocols.js';
 import '../../interfaces/dist/connection_manager.js';
 import '../../interfaces/dist/health_indicator.js';

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

@@ -1,8 +1,10 @@
 import { createEncoder, createDecoder } 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/light_push/light_push_v3.js';
 import '../../core/dist/lib/store/store.js';
 import '../../core/dist/lib/connection_manager/connection_manager.js';
+import '../../interfaces/dist/light_push_v3.js';
 import '../../interfaces/dist/protocols.js';
 import '../../interfaces/dist/connection_manager.js';
 import '../../interfaces/dist/health_indicator.js';