@waku/core 0.0.36-10590da.0 → 0.0.36-3730abc.0

package/bundle/index.js

@@ -1,5 +1,5 @@
-import { v as version_0, a as allocUnsafe, b as alloc, e as encodingLength$1, c as encode$2, d as decode$4, F as FilterSubscribeRequest, f as FilterSubscribeResponse$1, M as MessagePush, P as PushRpc$1, g as PushResponse, S as StoreQueryRequest$1, h as StoreQueryResponse$1, t as toString$1, i as bases, j as fromString, u as utf8ToBytes, k as createEncoder, p as pubsubTopicToSingleShardInfo, l as bytesToUtf8, s as shardInfoToPubsubTopics, W as WakuMetadataRequest, m as pubsubTopicsToShardInfo, n as WakuMetadataResponse } from './version_0-CiYGrPc2.js';
-export { o as createDecoder } from './version_0-CiYGrPc2.js';
+import { v as version_0, a as allocUnsafe, b as alloc, e as encodingLength$1, c as encode$2, d as decode$4, F as FilterSubscribeRequest, f as FilterSubscribeResponse$1, M as MessagePush, P as PushRpc, L as LightpushResponse, g as LightpushRequest, h as PushResponse, S as StoreQueryRequest$1, i as StoreQueryResponse$1, t as toString$1, j as bases, k as fromString, u as utf8ToBytes, l as createEncoder, p as pubsubTopicToSingleShardInfo, m as bytesToUtf8, s as shardInfoToPubsubTopics, W as WakuMetadataRequest, n as pubsubTopicsToShardInfo, o as WakuMetadataResponse, q as concat$1, r as sha256, w as bytesToHex, x as numberToBytes } from './version_0-y7BmRolm.js';
+export { y as createDecoder } from './version_0-y7BmRolm.js';
 import { e as equals$2, c as coerce, b as base32, a as base58btc, d as base36, L as Logger, P as ProtocolError, T as Tags, E as EPeersByDiscoveryEvents, f as EConnectionStateEvents } from './index-CTo1my9M.js';
 import { B as BaseProtocol } from './base_protocol-DvQrudwy.js';
 export { S as StreamManager } from './base_protocol-DvQrudwy.js';
@@ -514,6 +514,10 @@ function encodeCID(version, code, multihash) {
 }
 const cidSymbol = Symbol.for('@ipld/js-cid/CID');
 
+function isDefined(value) {
+    return Boolean(value);
+}
+
 const MB = 1024 ** 2;
 const SIZE_CAP_IN_MB = 1;
 /**
@@ -2294,24 +2298,42 @@ class FilterSubscribeResponse {
     }
 }
 
-const log$5 = new Logger("filter:v2");
+const log$6 = new Logger("filter:v2");
 const FilterCodecs = {
     SUBSCRIBE: "/vac/waku/filter-subscribe/2.0.0-beta1",
     PUSH: "/vac/waku/filter-push/2.0.0-beta1"
 };
 class FilterCore extends BaseProtocol {
-    handleIncomingMessage;
     pubsubTopics;
+    static handleIncomingMessage;
     constructor(handleIncomingMessage, pubsubTopics, libp2p) {
         super(FilterCodecs.SUBSCRIBE, libp2p.components, pubsubTopics);
-        this.handleIncomingMessage = handleIncomingMessage;
         this.pubsubTopics = pubsubTopics;
+        // TODO(weboko): remove when @waku/sdk 0.0.33 is released
+        const prevHandler = FilterCore.handleIncomingMessage;
+        FilterCore.handleIncomingMessage = !prevHandler
+            ? handleIncomingMessage
+            : async (pubsubTopic, message, peerIdStr) => {
+                try {
+                    await prevHandler(pubsubTopic, message, peerIdStr);
+                }
+                catch (e) {
+                    log$6.error("Previous FilterCore incoming message handler failed ", e);
+                }
+                try {
+                    await handleIncomingMessage(pubsubTopic, message, peerIdStr);
+                }
+                catch (e) {
+                    log$6.error("Present FilterCore incoming message handler failed ", e);
+                }
+                return;
+            };
         libp2p
             .handle(FilterCodecs.PUSH, this.onRequest.bind(this), {
             maxInboundStreams: 100
         })
             .catch((e) => {
-            log$5.error("Failed to register ", FilterCodecs.PUSH, e);
+            log$6.error("Failed to register ", FilterCodecs.PUSH, e);
         });
     }
     async subscribe(pubsubTopic, peerId, contentTopics) {
@@ -2322,7 +2344,7 @@ class FilterCore extends BaseProtocol {
             res = await pipe([request.encode()], encode, stream, decode, async (source) => await all(source));
         }
         catch (error) {
-            log$5.error("Failed to send subscribe request", error);
+            log$6.error("Failed to send subscribe request", error);
             return {
                 success: null,
                 failure: {
@@ -2333,7 +2355,7 @@ class FilterCore extends BaseProtocol {
         }
         const { statusCode, requestId, statusDesc } = FilterSubscribeResponse.decode(res[0].slice());
         if (statusCode < 200 || statusCode >= 300) {
-            log$5.error(`Filter subscribe request ${requestId} failed with status code ${statusCode}: ${statusDesc}`);
+            log$6.error(`Filter subscribe request ${requestId} failed with status code ${statusCode}: ${statusDesc}`);
             return {
                 failure: {
                     error: ProtocolError.REMOTE_PEER_REJECTED,
@@ -2353,7 +2375,7 @@ class FilterCore extends BaseProtocol {
             stream = await this.getStream(peerId);
         }
         catch (error) {
-            log$5.error(`Failed to get a stream for remote peer${peerId.toString()}`, error);
+            log$6.error(`Failed to get a stream for remote peer${peerId.toString()}`, error);
             return {
                 success: null,
                 failure: {
@@ -2367,7 +2389,7 @@ class FilterCore extends BaseProtocol {
             await pipe([unsubscribeRequest.encode()], encode, stream.sink);
         }
         catch (error) {
-            log$5.error("Failed to send unsubscribe request", error);
+            log$6.error("Failed to send unsubscribe request", error);
             return {
                 success: null,
                 failure: {
@@ -2396,7 +2418,7 @@ class FilterCore extends BaseProtocol {
         }
         const { statusCode, requestId, statusDesc } = FilterSubscribeResponse.decode(res[0].slice());
         if (statusCode < 200 || statusCode >= 300) {
-            log$5.error(`Filter unsubscribe all request ${requestId} failed with status code ${statusCode}: ${statusDesc}`);
+            log$6.error(`Filter unsubscribe all request ${requestId} failed with status code ${statusCode}: ${statusDesc}`);
             return {
                 failure: {
                     error: ProtocolError.REMOTE_PEER_REJECTED,
@@ -2416,7 +2438,7 @@ class FilterCore extends BaseProtocol {
             stream = await this.getStream(peerId);
         }
         catch (error) {
-            log$5.error(`Failed to get a stream for remote peer${peerId.toString()}`, error);
+            log$6.error(`Failed to get a stream for remote peer${peerId.toString()}`, error);
             return {
                 success: null,
                 failure: {
@@ -2431,7 +2453,7 @@ class FilterCore extends BaseProtocol {
             res = await pipe([request.encode()], encode, stream, decode, async (source) => await all(source));
         }
         catch (error) {
-            log$5.error("Failed to send ping request", error);
+            log$6.error("Failed to send ping request", error);
             return {
                 success: null,
                 failure: {
@@ -2451,7 +2473,7 @@ class FilterCore extends BaseProtocol {
         }
         const { statusCode, requestId, statusDesc } = FilterSubscribeResponse.decode(res[0].slice());
         if (statusCode < 200 || statusCode >= 300) {
-            log$5.error(`Filter ping request ${requestId} failed with status code ${statusCode}: ${statusDesc}`);
+            log$6.error(`Filter ping request ${requestId} failed with status code ${statusCode}: ${statusDesc}`);
             return {
                 success: null,
                 failure: {
@@ -2468,30 +2490,30 @@ class FilterCore extends BaseProtocol {
     onRequest(streamData) {
         const { connection, stream } = streamData;
         const { remotePeer } = connection;
-        log$5.info(`Received message from ${remotePeer.toString()}`);
+        log$6.info(`Received message from ${remotePeer.toString()}`);
         try {
             pipe(stream, decode, async (source) => {
                 for await (const bytes of source) {
                     const response = FilterPushRpc.decode(bytes.slice());
                     const { pubsubTopic, wakuMessage } = response;
                     if (!wakuMessage) {
-                        log$5.error("Received empty message");
+                        log$6.error("Received empty message");
                         return;
                     }
                     if (!pubsubTopic) {
-                        log$5.error("Pubsub topic missing from push message");
+                        log$6.error("Pubsub topic missing from push message");
                         return;
                     }
-                    await this.handleIncomingMessage(pubsubTopic, wakuMessage, connection.remotePeer.toString());
+                    await FilterCore.handleIncomingMessage?.(pubsubTopic, wakuMessage, connection.remotePeer.toString());
                 }
             }).then(() => {
-                log$5.info("Receiving pipe closed.");
+                log$6.info("Receiving pipe closed.");
             }, async (e) => {
-                log$5.error(`Error with receiving pipe on peer:${connection.remotePeer.toString()} -- stream:${stream.id} -- protocol:${stream.protocol}: `, e);
+                log$6.error(`Error with receiving pipe on peer:${connection.remotePeer.toString()} -- stream:${stream.id} -- protocol:${stream.protocol}: `, e);
             });
         }
         catch (e) {
-            log$5.error("Error decoding message", e);
+            log$6.error("Error decoding message", e);
         }
     }
 }
@@ -2502,13 +2524,13 @@ var index$2 = /*#__PURE__*/Object.freeze({
     FilterCore: FilterCore
 });
 
-class PushRpc {
+class PushRpcV2 {
     proto;
     constructor(proto) {
         this.proto = proto;
     }
     static createRequest(message, pubsubTopic) {
-        return new PushRpc({
+        return new PushRpcV2({
             requestId: v4(),
             request: {
                 message: message,
@@ -2518,11 +2540,11 @@ class PushRpc {
         });
     }
     static decode(bytes) {
-        const res = PushRpc$1.decode(bytes);
-        return new PushRpc(res);
+        const res = PushRpc.decode(bytes);
+        return new PushRpcV2(res);
     }
     encode() {
-        return PushRpc$1.encode(this.proto);
+        return PushRpc.encode(this.proto);
     }
     get query() {
         return this.proto.request;
@@ -2550,17 +2572,244 @@ const isRLNResponseError = (info) => {
         info.includes(RLN_REMOTE_VALIDATION));
 };
 
-const log$4 = new Logger("light-push");
+const log$5 = new Logger("light-push");
 const LightPushCodec = "/vac/waku/lightpush/2.0.0-beta1";
-/**
- * Implements the [Waku v2 Light Push protocol](https://rfc.vac.dev/spec/19/).
- */
+const LightPushCodecV2 = LightPushCodec;
 class LightPushCore extends BaseProtocol {
     pubsubTopics;
     constructor(pubsubTopics, libp2p) {
         super(LightPushCodec, libp2p.components, pubsubTopics);
         this.pubsubTopics = pubsubTopics;
     }
+    async preparePushMessage(encoder, message) {
+        try {
+            if (!message.payload || message.payload.length === 0) {
+                log$5.error("Failed to send waku light push: payload is empty");
+                return { query: null, error: ProtocolError.EMPTY_PAYLOAD };
+            }
+            if (!(await isMessageSizeUnderCap(encoder, message))) {
+                log$5.error("Failed to send waku light push: message is bigger than 1MB");
+                return { query: null, error: ProtocolError.SIZE_TOO_BIG };
+            }
+            const protoMessage = await encoder.toProtoObj(message);
+            if (!protoMessage) {
+                log$5.error("Failed to encode to protoMessage, aborting push");
+                return {
+                    query: null,
+                    error: ProtocolError.ENCODE_FAILED
+                };
+            }
+            const query = PushRpcV2.createRequest(protoMessage, encoder.pubsubTopic);
+            return { query, error: null };
+        }
+        catch (error) {
+            log$5.error("Failed to prepare push message", error);
+            return {
+                query: null,
+                error: ProtocolError.GENERIC_FAIL
+            };
+        }
+    }
+    async send(encoder, message, peerId) {
+        const { query, error: preparationError } = await this.preparePushMessage(encoder, message);
+        if (preparationError || !query) {
+            return {
+                success: null,
+                failure: {
+                    error: preparationError,
+                    peerId
+                }
+            };
+        }
+        let stream;
+        try {
+            stream = await this.getStream(peerId);
+        }
+        catch (error) {
+            log$5.error("Failed to get stream", error);
+            return {
+                success: null,
+                failure: {
+                    error: ProtocolError.NO_STREAM_AVAILABLE,
+                    peerId: peerId
+                }
+            };
+        }
+        let res;
+        try {
+            res = await pipe([query.encode()], encode, stream, decode, async (source) => await all(source));
+        }
+        catch (err) {
+            log$5.error("Failed to send waku light push request", err);
+            return {
+                success: null,
+                failure: {
+                    error: ProtocolError.STREAM_ABORTED,
+                    peerId: peerId
+                }
+            };
+        }
+        const bytes = new Uint8ArrayList();
+        res.forEach((chunk) => {
+            bytes.append(chunk);
+        });
+        let response;
+        try {
+            response = PushRpcV2.decode(bytes).response;
+        }
+        catch (err) {
+            log$5.error("Failed to decode push reply", err);
+            return {
+                success: null,
+                failure: {
+                    error: ProtocolError.DECODE_FAILED,
+                    peerId: peerId
+                }
+            };
+        }
+        if (!response) {
+            log$5.error("Remote peer fault: No response in PushRPC");
+            return {
+                success: null,
+                failure: {
+                    error: ProtocolError.NO_RESPONSE,
+                    peerId: peerId
+                }
+            };
+        }
+        if (!response.isSuccess) {
+            const errorMessage = response.info || "Message rejected";
+            log$5.error("Remote peer rejected the message: ", errorMessage);
+            if (response.info && isRLNResponseError(response.info)) {
+                log$5.error("Remote peer fault: RLN generation");
+                return {
+                    success: null,
+                    failure: {
+                        error: ProtocolError.RLN_PROOF_GENERATION,
+                        peerId: peerId
+                    }
+                };
+            }
+            return {
+                success: null,
+                failure: {
+                    error: ProtocolError.REMOTE_PEER_REJECTED,
+                    peerId: peerId
+                }
+            };
+        }
+        return { success: peerId, failure: null };
+    }
+}
+const LightPushCoreV2 = LightPushCore;
+
+class PushRpcV3 {
+    request;
+    response;
+    constructor(request, response) {
+        this.request = request;
+        this.response = response;
+    }
+    static createRequest(message, pubsubTopic) {
+        const request = {
+            requestId: v4(),
+            message: message,
+            // Only include pubsubTopic if explicitly provided (for nwaku autosharding compatibility)
+            ...(pubsubTopic && { pubsubTopic })
+        };
+        return new PushRpcV3(request, undefined);
+    }
+    static decode(bytes) {
+        const response = LightpushResponse.decode(bytes);
+        return new PushRpcV3(undefined, response);
+    }
+    encode() {
+        if (!this.request) {
+            throw new Error("Cannot encode without a request");
+        }
+        return LightpushRequest.encode(this.request);
+    }
+    get query() {
+        return this.request;
+    }
+}
+
+var LightPushStatusCodeV3;
+(function (LightPushStatusCodeV3) {
+    LightPushStatusCodeV3[LightPushStatusCodeV3["SUCCESS"] = 200] = "SUCCESS";
+    LightPushStatusCodeV3[LightPushStatusCodeV3["BAD_REQUEST"] = 400] = "BAD_REQUEST";
+    LightPushStatusCodeV3[LightPushStatusCodeV3["PAYLOAD_TOO_LARGE"] = 413] = "PAYLOAD_TOO_LARGE";
+    LightPushStatusCodeV3[LightPushStatusCodeV3["INVALID_MESSAGE_ERROR"] = 420] = "INVALID_MESSAGE_ERROR";
+    LightPushStatusCodeV3[LightPushStatusCodeV3["UNSUPPORTED_PUBSUB_TOPIC"] = 421] = "UNSUPPORTED_PUBSUB_TOPIC";
+    LightPushStatusCodeV3[LightPushStatusCodeV3["TOO_MANY_REQUESTS"] = 429] = "TOO_MANY_REQUESTS";
+    LightPushStatusCodeV3[LightPushStatusCodeV3["INTERNAL_SERVER_ERROR"] = 500] = "INTERNAL_SERVER_ERROR";
+    LightPushStatusCodeV3[LightPushStatusCodeV3["SERVICE_NOT_AVAILABLE"] = 503] = "SERVICE_NOT_AVAILABLE";
+    LightPushStatusCodeV3[LightPushStatusCodeV3["OUT_OF_RLN_PROOF"] = 504] = "OUT_OF_RLN_PROOF";
+    LightPushStatusCodeV3[LightPushStatusCodeV3["NO_PEERS_TO_RELAY"] = 505] = "NO_PEERS_TO_RELAY";
+})(LightPushStatusCodeV3 || (LightPushStatusCodeV3 = {}));
+const lightPushStatusDescriptionsV3 = {
+    [LightPushStatusCodeV3.SUCCESS]: "Message sent successfully",
+    [LightPushStatusCodeV3.BAD_REQUEST]: "Bad request format",
+    [LightPushStatusCodeV3.PAYLOAD_TOO_LARGE]: "Message payload exceeds maximum size",
+    [LightPushStatusCodeV3.INVALID_MESSAGE_ERROR]: "Message validation failed",
+    [LightPushStatusCodeV3.UNSUPPORTED_PUBSUB_TOPIC]: "Unsupported pubsub topic",
+    [LightPushStatusCodeV3.TOO_MANY_REQUESTS]: "Rate limit exceeded",
+    [LightPushStatusCodeV3.INTERNAL_SERVER_ERROR]: "Internal server error",
+    [LightPushStatusCodeV3.SERVICE_NOT_AVAILABLE]: "Service temporarily unavailable",
+    [LightPushStatusCodeV3.OUT_OF_RLN_PROOF]: "RLN proof generation failed",
+    [LightPushStatusCodeV3.NO_PEERS_TO_RELAY]: "No relay peers available"
+};
+function lightPushStatusCodeToProtocolErrorV3(statusCode) {
+    if (!statusCode) {
+        return ProtocolError.GENERIC_FAIL;
+    }
+    switch (statusCode) {
+        case LightPushStatusCodeV3.SUCCESS:
+            return ProtocolError.GENERIC_FAIL;
+        case LightPushStatusCodeV3.BAD_REQUEST:
+            return ProtocolError.DECODE_FAILED;
+        case LightPushStatusCodeV3.PAYLOAD_TOO_LARGE:
+            return ProtocolError.SIZE_TOO_BIG;
+        case LightPushStatusCodeV3.INVALID_MESSAGE_ERROR:
+            return ProtocolError.EMPTY_PAYLOAD;
+        case LightPushStatusCodeV3.UNSUPPORTED_PUBSUB_TOPIC:
+            return ProtocolError.TOPIC_NOT_CONFIGURED;
+        case LightPushStatusCodeV3.TOO_MANY_REQUESTS:
+            return ProtocolError.REMOTE_PEER_REJECTED;
+        case LightPushStatusCodeV3.INTERNAL_SERVER_ERROR:
+            return ProtocolError.GENERIC_FAIL;
+        case LightPushStatusCodeV3.SERVICE_NOT_AVAILABLE:
+            return ProtocolError.NO_PEER_AVAILABLE;
+        case LightPushStatusCodeV3.OUT_OF_RLN_PROOF:
+            return ProtocolError.RLN_PROOF_GENERATION;
+        case LightPushStatusCodeV3.NO_PEERS_TO_RELAY:
+            return ProtocolError.NO_PEER_AVAILABLE;
+        default:
+            return ProtocolError.REMOTE_PEER_REJECTED;
+    }
+}
+function isSuccessStatusCodeV3(statusCode) {
+    return statusCode === LightPushStatusCodeV3.SUCCESS;
+}
+function getLightPushStatusDescriptionV3(statusCode, customDesc) {
+    if (customDesc) {
+        return customDesc;
+    }
+    if (!statusCode) {
+        return "Unknown error";
+    }
+    return (lightPushStatusDescriptionsV3[statusCode] ||
+        `Unknown status code: ${statusCode}`);
+}
+
+const log$4 = new Logger("light-push-v3");
+const LightPushCodecV3 = "/vac/waku/lightpush/3.0.0";
+class LightPushCoreV3 extends BaseProtocol {
+    pubsubTopics;
+    constructor(pubsubTopics, libp2p) {
+        super(LightPushCodecV3, libp2p.components, pubsubTopics);
+        this.pubsubTopics = pubsubTopics;
+    }
     async preparePushMessage(encoder, message) {
         try {
             if (!message.payload || message.payload.length === 0) {
@@ -2579,7 +2828,7 @@ class LightPushCore extends BaseProtocol {
                     error: ProtocolError.ENCODE_FAILED
                 };
             }
-            const query = PushRpc.createRequest(protoMessage, encoder.pubsubTopic);
+            const query = PushRpcV3.createRequest(protoMessage, encoder.pubsubTopic);
             return { query, error: null };
         }
         catch (error) {
@@ -2620,7 +2869,6 @@ class LightPushCore extends BaseProtocol {
             res = await pipe([query.encode()], encode, stream, decode, async (source) => await all(source));
         }
         catch (err) {
-            // can fail only because of `stream` abortion
             log$4.error("Failed to send waku light push request", err);
             return {
                 success: null,
@@ -2636,10 +2884,10 @@ class LightPushCore extends BaseProtocol {
         });
         let response;
         try {
-            response = PushRpc.decode(bytes).response;
+            response = LightpushResponse.decode(bytes);
         }
         catch (err) {
-            log$4.error("Failed to decode push reply", err);
+            log$4.error("Failed to decode push response", err);
             return {
                 success: null,
                 failure: {
@@ -2649,7 +2897,7 @@ class LightPushCore extends BaseProtocol {
             };
         }
         if (!response) {
-            log$4.error("Remote peer fault: No response in PushRPC");
+            log$4.error("Remote peer fault: No response received");
             return {
                 success: null,
                 failure: {
@@ -2658,7 +2906,37 @@ class LightPushCore extends BaseProtocol {
                 }
             };
         }
-        if (isRLNResponseError(response.info)) {
+        // Validate request ID matches (except for rate limiting responses)
+        if (response.requestId !== query.query?.requestId) {
+            // nwaku sends "N/A" for rate limiting responses
+            if (response.statusCode !== LightPushStatusCodeV3.TOO_MANY_REQUESTS) {
+                log$4.error("Request ID mismatch", {
+                    sent: query.query?.requestId,
+                    received: response.requestId
+                });
+                return {
+                    success: null,
+                    failure: {
+                        error: ProtocolError.GENERIC_FAIL,
+                        peerId: peerId
+                    }
+                };
+            }
+        }
+        const statusCode = response.statusCode;
+        const isSuccess = isSuccessStatusCodeV3(statusCode);
+        // Special handling for nwaku rate limiting
+        if (statusCode === LightPushStatusCodeV3.TOO_MANY_REQUESTS) {
+            if (response.requestId === "N/A") {
+                log$4.warn("Rate limited by nwaku node", {
+                    statusDesc: response.statusDesc || "Request rejected due to too many requests"
+                });
+            }
+        }
+        if (response.relayPeerCount !== undefined) {
+            log$4.info(`Message relayed to ${response.relayPeerCount} peers`);
+        }
+        if (response.statusDesc && isRLNResponseError(response.statusDesc)) {
             log$4.error("Remote peer fault: RLN generation");
             return {
                 success: null,
@@ -2668,12 +2946,14 @@ class LightPushCore extends BaseProtocol {
                 }
             };
         }
-        if (!response.isSuccess) {
-            log$4.error("Remote peer rejected the message: ", response.info);
+        if (!isSuccess) {
+            const errorMessage = getLightPushStatusDescriptionV3(statusCode, response.statusDesc);
+            log$4.error("Remote peer rejected the message: ", errorMessage);
+            const protocolError = lightPushStatusCodeToProtocolErrorV3(statusCode);
             return {
                 success: null,
                 failure: {
-                    error: ProtocolError.REMOTE_PEER_REJECTED,
+                    error: protocolError,
                     peerId: peerId
                 }
             };
@@ -2682,11 +2962,74 @@ class LightPushCore extends BaseProtocol {
     }
 }
 
+var LightPushStatusCode;
+(function (LightPushStatusCode) {
+    LightPushStatusCode[LightPushStatusCode["SUCCESS"] = 200] = "SUCCESS";
+    LightPushStatusCode[LightPushStatusCode["BAD_REQUEST"] = 400] = "BAD_REQUEST";
+    LightPushStatusCode[LightPushStatusCode["UNSUPPORTED_PUBSUB_TOPIC"] = 404] = "UNSUPPORTED_PUBSUB_TOPIC";
+    LightPushStatusCode[LightPushStatusCode["REQUEST_TOO_LARGE"] = 413] = "REQUEST_TOO_LARGE";
+    LightPushStatusCode[LightPushStatusCode["TOO_MANY_REQUESTS"] = 429] = "TOO_MANY_REQUESTS";
+    LightPushStatusCode[LightPushStatusCode["INTERNAL_SERVER_ERROR"] = 500] = "INTERNAL_SERVER_ERROR";
+    LightPushStatusCode[LightPushStatusCode["NO_PEERS_TO_RELAY"] = 503] = "NO_PEERS_TO_RELAY";
+})(LightPushStatusCode || (LightPushStatusCode = {}));
+function lightPushStatusCodeToProtocolError(statusCode) {
+    switch (statusCode) {
+        case LightPushStatusCode.SUCCESS:
+            return null;
+        case LightPushStatusCode.BAD_REQUEST:
+            return ProtocolError.GENERIC_FAIL;
+        case LightPushStatusCode.UNSUPPORTED_PUBSUB_TOPIC:
+            return ProtocolError.TOPIC_NOT_CONFIGURED;
+        case LightPushStatusCode.REQUEST_TOO_LARGE:
+            return ProtocolError.SIZE_TOO_BIG;
+        case LightPushStatusCode.TOO_MANY_REQUESTS:
+            return ProtocolError.GENERIC_FAIL;
+        case LightPushStatusCode.INTERNAL_SERVER_ERROR:
+            return ProtocolError.REMOTE_PEER_REJECTED;
+        case LightPushStatusCode.NO_PEERS_TO_RELAY:
+            return ProtocolError.NO_PEER_AVAILABLE;
+        default:
+            return ProtocolError.REMOTE_PEER_REJECTED;
+    }
+}
+const lightPushStatusDescriptions = {
+    [LightPushStatusCode.SUCCESS]: "Message pushed successfully",
+    [LightPushStatusCode.BAD_REQUEST]: "Invalid request format or missing required fields",
+    [LightPushStatusCode.UNSUPPORTED_PUBSUB_TOPIC]: "The specified pubsub topic is not supported",
+    [LightPushStatusCode.REQUEST_TOO_LARGE]: "Message size exceeds maximum allowed size",
+    [LightPushStatusCode.TOO_MANY_REQUESTS]: "Rate limit exceeded, too many requests",
+    [LightPushStatusCode.INTERNAL_SERVER_ERROR]: "Internal server error occurred",
+    [LightPushStatusCode.NO_PEERS_TO_RELAY]: "No relay peers available to forward the message"
+};
+function isSuccessStatusCode(statusCode) {
+    return statusCode === LightPushStatusCode.SUCCESS;
+}
+function getLightPushStatusDescription(statusCode, statusDesc) {
+    return (statusDesc ||
+        lightPushStatusDescriptions[statusCode] ||
+        `Unknown status code: ${statusCode}`);
+}
+
 var index$1 = /*#__PURE__*/Object.freeze({
     __proto__: null,
     LightPushCodec: LightPushCodec,
+    LightPushCodecV2: LightPushCodecV2,
+    LightPushCodecV3: LightPushCodecV3,
     LightPushCore: LightPushCore,
-    get PushResponse () { return PushResponse; }
+    LightPushCoreV2: LightPushCoreV2,
+    LightPushCoreV3: LightPushCoreV3,
+    get LightPushStatusCode () { return LightPushStatusCode; },
+    get LightPushStatusCodeV3 () { return LightPushStatusCodeV3; },
+    get PushResponse () { return PushResponse; },
+    PushRpcV3: PushRpcV3,
+    getLightPushStatusDescription: getLightPushStatusDescription,
+    getLightPushStatusDescriptionV3: getLightPushStatusDescriptionV3,
+    isSuccessStatusCode: isSuccessStatusCode,
+    isSuccessStatusCodeV3: isSuccessStatusCodeV3,
+    lightPushStatusCodeToProtocolError: lightPushStatusCodeToProtocolError,
+    lightPushStatusCodeToProtocolErrorV3: lightPushStatusCodeToProtocolErrorV3,
+    lightPushStatusDescriptions: lightPushStatusDescriptions,
+    lightPushStatusDescriptionsV3: lightPushStatusDescriptionsV3
 });
 
 const EmptyMessage = {
@@ -2714,6 +3057,7 @@ class StoreQueryRequest {
     static create(params) {
         const request = new StoreQueryRequest({
             ...params,
+            contentTopics: params.contentTopics || [],
             requestId: v4(),
             timeStart: params.timeStart
                 ? BigInt(params.timeStart.getTime() * ONE_MILLION)
@@ -2726,17 +3070,22 @@ class StoreQueryRequest {
                 ? BigInt(params.paginationLimit)
                 : undefined
         });
-        // Validate request parameters based on RFC
-        if ((params.pubsubTopic && !params.contentTopics) ||
-            (!params.pubsubTopic && params.contentTopics)) {
-            throw new Error("Both pubsubTopic and contentTopics must be set or unset");
-        }
-        if (params.messageHashes &&
-            (params.pubsubTopic ||
-                params.contentTopics ||
-                params.timeStart ||
-                params.timeEnd)) {
-            throw new Error("Message hash lookup queries cannot include content filter criteria");
+        const isHashQuery = params.messageHashes && params.messageHashes.length > 0;
+        const hasContentTopics = params.contentTopics && params.contentTopics.length > 0;
+        const hasTimeFilter = params.timeStart || params.timeEnd;
+        if (isHashQuery) {
+            if (hasContentTopics || hasTimeFilter) {
+                throw new Error("Message hash lookup queries cannot include content filter criteria (contentTopics, timeStart, or timeEnd)");
+            }
+        }
+        else {
+            if ((params.pubsubTopic &&
+                (!params.contentTopics || params.contentTopics.length === 0)) ||
+                (!params.pubsubTopic &&
+                    params.contentTopics &&
+                    params.contentTopics.length > 0)) {
+                throw new Error("Both pubsubTopic and contentTopics must be set together for content-filtered queries");
+            }
         }
         return request;
     }
@@ -2783,8 +3132,12 @@ class StoreCore extends BaseProtocol {
         this.pubsubTopics = pubsubTopics;
     }
     async *queryPerPage(queryOpts, decoders, peerId) {
-        if (queryOpts.contentTopics.toString() !==
-            Array.from(decoders.keys()).toString()) {
+        // Only validate decoder content topics for content-filtered queries
+        const isHashQuery = queryOpts.messageHashes && queryOpts.messageHashes.length > 0;
+        if (!isHashQuery &&
+            queryOpts.contentTopics &&
+            queryOpts.contentTopics.toString() !==
+                Array.from(decoders.keys()).toString()) {
             throw new Error("Internal error, the decoders should match the query's content topics");
         }
         let currentCursor = queryOpts.paginationCursor;
@@ -2793,6 +3146,12 @@ class StoreCore extends BaseProtocol {
                 ...queryOpts,
                 paginationCursor: currentCursor
             });
+            log$3.info("Sending store query request:", {
+                hasMessageHashes: !!queryOpts.messageHashes?.length,
+                messageHashCount: queryOpts.messageHashes?.length,
+                pubsubTopic: queryOpts.pubsubTopic,
+                contentTopics: queryOpts.contentTopics
+            });
             let stream;
             try {
                 stream = await this.getStream(peerId);
@@ -4386,7 +4745,7 @@ class ConnectionManager extends TypedEventEmitter {
      * // Dial using multiaddr with specific protocols
      * await connectionManager.dialPeer(multiaddr, [
      *   "/vac/waku/relay/2.0.0",
-     *   "/vac/waku/lightpush/2.0.0-beta1"
+     *   "/vac/waku/lightpush/3.0.0"
      * ]);
      * ```
      *
@@ -4854,4 +5213,85 @@ function wakuMetadata(pubsubTopics) {
     return (components) => new Metadata(pubsubTopics, components);
 }
 
-export { ConnectionManager, FilterCodecs, FilterCore, LightPushCodec, LightPushCore, MetadataCodec, StoreCodec, StoreCore, createEncoder, index$3 as message, wakuMetadata, index$2 as waku_filter, index$1 as waku_light_push, index as waku_store };
+/**
+ * Deterministic Message Hashing as defined in
+ * [14/WAKU2-MESSAGE](https://rfc.vac.dev/spec/14/#deterministic-message-hashing)
+ *
+ * Computes a SHA-256 hash of the concatenation of pubsub topic, payload, content topic, meta, and timestamp.
+ *
+ * @param pubsubTopic - The pubsub topic string
+ * @param message - The message to be hashed
+ * @returns A Uint8Array containing the SHA-256 hash
+ *
+ * @example
+ * ```typescript
+ * import { messageHash } from "@waku/core";
+ *
+ * const pubsubTopic = "/waku/2/default-waku/proto";
+ * const message = {
+ *   payload: new Uint8Array([1, 2, 3, 4]),
+ *   contentTopic: "/waku/2/default-content/proto",
+ *   meta: new Uint8Array([5, 6, 7, 8]),
+ *   timestamp: new Date()
+ * };
+ *
+ * const hash = messageHash(pubsubTopic, message);
+ * ```
+ */
+function messageHash(pubsubTopic, message) {
+    const pubsubTopicBytes = utf8ToBytes(pubsubTopic);
+    const contentTopicBytes = utf8ToBytes(message.contentTopic);
+    const timestampBytes = tryConvertTimestampToBytes(message.timestamp);
+    const bytes = concat$1([
+        pubsubTopicBytes,
+        message.payload,
+        contentTopicBytes,
+        message.meta,
+        timestampBytes
+    ].filter(isDefined));
+    return sha256(bytes);
+}
+function tryConvertTimestampToBytes(timestamp) {
+    if (!timestamp) {
+        return;
+    }
+    let bigIntTimestamp;
+    if (typeof timestamp === "bigint") {
+        bigIntTimestamp = timestamp;
+    }
+    else {
+        bigIntTimestamp = BigInt(timestamp.valueOf()) * 1000000n;
+    }
+    return numberToBytes(bigIntTimestamp);
+}
+/**
+ * Computes a deterministic message hash and returns it as a hexadecimal string.
+ * This is a convenience wrapper around messageHash that converts the result to a hex string.
+ *
+ * @param pubsubTopic - The pubsub topic string
+ * @param message - The message to be hashed
+ * @returns A string containing the hex representation of the SHA-256 hash
+ *
+ * @example
+ * ```typescript
+ * import { messageHashStr } from "@waku/core";
+ *
+ * const pubsubTopic = "/waku/2/default-waku/proto";
+ * const message = {
+ *   payload: new Uint8Array([1, 2, 3, 4]),
+ *   contentTopic: "/waku/2/default-content/proto",
+ *   meta: new Uint8Array([5, 6, 7, 8]),
+ *   timestamp: new Date()
+ * };
+ *
+ * const hashString = messageHashStr(pubsubTopic, message);
+ * console.log(hashString); // e.g. "a1b2c3d4..."
+ * ```
+ */
+function messageHashStr(pubsubTopic, message) {
+    const hash = messageHash(pubsubTopic, message);
+    const hashStr = bytesToHex(hash);
+    return hashStr;
+}
+
+export { ConnectionManager, FilterCodecs, FilterCore, LightPushCodec, LightPushCodecV2, LightPushCodecV3, LightPushCore, LightPushCoreV2, LightPushCoreV3, LightPushStatusCodeV3, MetadataCodec, StoreCodec, StoreCore, createEncoder, isSuccessStatusCodeV3, lightPushStatusCodeToProtocolErrorV3, index$3 as message, messageHash, messageHashStr, wakuMetadata, index$2 as waku_filter, index$1 as waku_light_push, index as waku_store };