@waku/core 0.0.36-4997440.0 → 0.0.36-76fb1ea.0

package/bundle/{base_protocol-DvQrudwy.js → base_protocol-DbwKyDLW.js}

@@ -1,4 +1,4 @@
-import { L as Logger } from './index-CTo1my9M.js';
+import { L as Logger } from './index-JnhMR9ZE.js';
 
 function selectOpenConnection(connections) {
     return connections

package/bundle/{index-CTo1my9M.js → index-JnhMR9ZE.js}

@@ -645,6 +645,25 @@ var identityBase = /*#__PURE__*/Object.freeze({
 new TextEncoder();
 new TextDecoder();
 
+// Light Push V3 Protocol Types and Constants
+const LightPushCodecV3 = "/vac/waku/lightpush/3.0.0";
+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 = {}));
+function isSuccessStatusCodeV3(statusCode) {
+    return statusCode === LightPushStatusCodeV3.SUCCESS;
+}
+
 var Protocols;
 (function (Protocols) {
     Protocols["Relay"] = "relay";
@@ -1540,4 +1559,4 @@ class Logger {
     }
 }
 
-export { EPeersByDiscoveryEvents as E, Logger as L, ProtocolError as P, Tags as T, base58btc as a, base32 as b, coerce as c, base36 as d, equals as e, EConnectionStateEvents as f, base256emoji$1 as g, base64$1 as h, base58 as i, base36$1 as j, base32$1 as k, base16$1 as l, base10$1 as m, base8$1 as n, base2$1 as o, identityBase as p };
+export { EPeersByDiscoveryEvents as E, Logger as L, ProtocolError as P, Tags as T, base58btc as a, base32 as b, coerce as c, base36 as d, equals as e, LightPushStatusCodeV3 as f, LightPushCodecV3 as g, EConnectionStateEvents as h, isSuccessStatusCodeV3 as i, base256emoji$1 as j, base64$1 as k, base58 as l, base36$1 as m, base32$1 as n, base16$1 as o, base10$1 as p, base8$1 as q, base2$1 as r, identityBase as s };

package/bundle/index.js

@@ -1,8 +1,8 @@
-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, o as concat$1, q as sha256, r as bytesToHex, w as numberToBytes } from './version_0-CyeTW0Vr.js';
-export { x as createDecoder } from './version_0-CyeTW0Vr.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';
+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-sWyv9XWm.js';
+export { y as createDecoder } from './version_0-sWyv9XWm.js';
+import { e as equals$2, c as coerce, b as base32, a as base58btc, d as base36, L as Logger, P as ProtocolError, f as LightPushStatusCodeV3, g as LightPushCodecV3, i as isSuccessStatusCodeV3, T as Tags, E as EPeersByDiscoveryEvents, h as EConnectionStateEvents } from './index-JnhMR9ZE.js';
+import { B as BaseProtocol } from './base_protocol-DbwKyDLW.js';
+export { S as StreamManager } from './base_protocol-DbwKyDLW.js';
 
 /* eslint-disable */
 var encode_1 = encode$1;
@@ -2298,7 +2298,7 @@ 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"
@@ -2318,13 +2318,13 @@ class FilterCore extends BaseProtocol {
                     await prevHandler(pubsubTopic, message, peerIdStr);
                 }
                 catch (e) {
-                    log$5.error("Previous FilterCore incoming message handler failed ", e);
+                    log$6.error("Previous FilterCore incoming message handler failed ", e);
                 }
                 try {
                     await handleIncomingMessage(pubsubTopic, message, peerIdStr);
                 }
                 catch (e) {
-                    log$5.error("Present FilterCore incoming message handler failed ", e);
+                    log$6.error("Present FilterCore incoming message handler failed ", e);
                 }
                 return;
             };
@@ -2333,7 +2333,7 @@ class FilterCore extends BaseProtocol {
             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) {
@@ -2344,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: {
@@ -2355,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,
@@ -2375,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: {
@@ -2389,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: {
@@ -2418,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,
@@ -2438,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: {
@@ -2453,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: {
@@ -2473,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: {
@@ -2490,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 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);
         }
     }
 }
@@ -2524,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,
@@ -2540,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;
@@ -2571,18 +2571,260 @@ const isRLNResponseError = (info) => {
         info.includes(RLN_MESSAGE_ID_PREFIX_ERROR) ||
         info.includes(RLN_REMOTE_VALIDATION));
 };
-
-const log$4 = 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/).
+ * Maps error information from push response to appropriate ProtocolError
+ * Uses pattern matching to handle various error cases
  */
+function mapInfoToProtocolError(info) {
+    if (!info) {
+        return ProtocolError.REMOTE_PEER_REJECTED;
+    }
+    const lowerInfo = info.toLowerCase();
+    // RLN errors
+    if (isRLNResponseError(info)) {
+        return ProtocolError.RLN_PROOF_GENERATION;
+    }
+    // Rate limiting patterns
+    if (lowerInfo.includes("rate limit") ||
+        lowerInfo.includes("too many requests")) {
+        return ProtocolError.REMOTE_PEER_REJECTED;
+    }
+    // Topic errors
+    if (lowerInfo.includes("topic") &&
+        (lowerInfo.includes("not found") || lowerInfo.includes("not configured"))) {
+        return ProtocolError.TOPIC_NOT_CONFIGURED;
+    }
+    // Size errors
+    if (lowerInfo.includes("too large") || lowerInfo.includes("size")) {
+        return ProtocolError.SIZE_TOO_BIG;
+    }
+    // Decoding errors
+    if (lowerInfo.includes("decode") ||
+        lowerInfo.includes("invalid") ||
+        lowerInfo.includes("malformed")) {
+        return ProtocolError.DECODE_FAILED;
+    }
+    // Empty payload
+    if (lowerInfo.includes("empty") && lowerInfo.includes("payload")) {
+        return ProtocolError.EMPTY_PAYLOAD;
+    }
+    // Default case
+    return ProtocolError.REMOTE_PEER_REJECTED;
+}
+
+const log$5 = new Logger("light-push");
+const LightPushCodec = "/vac/waku/lightpush/2.0.0-beta1";
+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);
+            // Use pattern matching to determine the appropriate error type
+            const error = mapInfoToProtocolError(response.info);
+            return {
+                success: null,
+                failure: {
+                    error: error,
+                    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;
+    }
+}
+
+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 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");
+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) {
@@ -2601,7 +2843,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) {
@@ -2642,7 +2884,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,
@@ -2658,10 +2899,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: {
@@ -2671,7 +2912,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: {
@@ -2680,7 +2921,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,
@@ -2690,12 +2961,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
                 }
             };
@@ -2704,11 +2977,71 @@ 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,
     LightPushCore: LightPushCore,
-    get PushResponse () { return PushResponse; }
+    LightPushCoreV2: LightPushCoreV2,
+    LightPushCoreV3: LightPushCoreV3,
+    get LightPushStatusCode () { return LightPushStatusCode; },
+    get PushResponse () { return PushResponse; },
+    PushRpcV3: PushRpcV3,
+    getLightPushStatusDescription: getLightPushStatusDescription,
+    getLightPushStatusDescriptionV3: getLightPushStatusDescriptionV3,
+    isSuccessStatusCode: isSuccessStatusCode,
+    lightPushStatusCodeToProtocolError: lightPushStatusCodeToProtocolError,
+    lightPushStatusCodeToProtocolErrorV3: lightPushStatusCodeToProtocolErrorV3,
+    lightPushStatusDescriptions: lightPushStatusDescriptions,
+    lightPushStatusDescriptionsV3: lightPushStatusDescriptionsV3
 });
 
 const EmptyMessage = {
@@ -4424,7 +4757,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"
      * ]);
      * ```
      *
@@ -4973,4 +5306,4 @@ function messageHashStr(pubsubTopic, message) {
     return hashStr;
 }
 
-export { ConnectionManager, FilterCodecs, FilterCore, LightPushCodec, LightPushCore, MetadataCodec, StoreCodec, StoreCore, createEncoder, index$3 as message, messageHash, messageHashStr, wakuMetadata, index$2 as waku_filter, index$1 as waku_light_push, index as waku_store };
+export { ConnectionManager, FilterCodecs, FilterCore, LightPushCodec, LightPushCodecV2, LightPushCore, LightPushCoreV2, LightPushCoreV3, MetadataCodec, StoreCodec, StoreCore, createEncoder, index$3 as message, messageHash, messageHashStr, wakuMetadata, index$2 as waku_filter, index$1 as waku_light_push, index as waku_store };

package/bundle/lib/base_protocol.js

@@ -1,2 +1,2 @@
-export { B as BaseProtocol } from '../base_protocol-DvQrudwy.js';
-import '../index-CTo1my9M.js';
+export { B as BaseProtocol } from '../base_protocol-DbwKyDLW.js';
+import '../index-JnhMR9ZE.js';