@waku/core 0.0.39-9684e7b.0 → 0.0.39-c0ee9ec.0

package/bundle/index.js

@@ -1,5 +1,5 @@
-import { e as equals$2, c as coerce, b as base32, a as base58btc, d as base36, s as sha256$1, f as concat$1, u as utf8ToBytes, v as version_0, g as allocUnsafe, h as alloc, i as encodingLength$1, j as encode$3, k as decode$4, L as Logger, F as FilterSubscribeRequest, l as FilterSubscribeResponse$1, M as MessagePush, P as PushRpc$1, m as PushResponse, S as StoreQueryRequest$1, n as StoreQueryResponse$1, o as createEncoder, t as toString, p as fromString, q as hexToBytes, r as isBytes, w as abytes, x as bytesToHex, y as concatBytes, z as anumber, A as randomBytes, B as sha512, C as enumeration, D as message, E as encodeMessage, G as decodeMessage, H as Hash, I as ahash, J as toBytes, K as clean, N as aexists, O as sha256$2, Q as bases, R as base64url, T as encodeUint8Array, U as bytesToUtf8, W as WakuMetadataRequest, V as WakuMetadataResponse } from './version_0-DV1Db0r-.js';
-export { X as createDecoder, Y as messageHash, Z as messageHashStr } from './version_0-DV1Db0r-.js';
+import { e as equals$2, c as coerce, b as base32, a as base58btc, d as base36, s as sha256$1, f as concat$1, u as utf8ToBytes, v as version_0, g as allocUnsafe, h as alloc, i as encodingLength$1, j as encode$3, k as decode$4, L as Logger, F as FilterSubscribeRequest, l as FilterSubscribeResponse$1, M as MessagePush, P as PushRpc$1, m as LightPushRequestV3, n as LightPushResponseV3, S as StoreQueryRequest$1, o as StoreQueryResponse$1, p as createEncoder, t as toString, q as fromString, r as hexToBytes, w as isBytes, x as abytes, y as bytesToHex, z as concatBytes, A as anumber, B as randomBytes, C as sha512, D as enumeration, E as message, G as encodeMessage, H as decodeMessage, I as Hash, J as ahash, K as toBytes, N as clean, O as aexists, Q as sha256$2, R as bases, T as base64url, U as encodeUint8Array, V as bytesToUtf8, W as WakuMetadataRequest, X as WakuMetadataResponse } from './version_0-DQUncDnb.js';
+export { Y as createDecoder, Z as messageHash, _ as messageHashStr } from './version_0-DQUncDnb.js';
 
 /* eslint-disable */
 var encode_1 = encode$2;
@@ -581,86 +581,6 @@ function isAutoSharding(config) {
     return "clusterId" in config && "numShardsInCluster" in config;
 }
 
-const formatPubsubTopic = (clusterId, shard) => {
-    return `/waku/2/rs/${clusterId}/${shard}`;
-};
-/**
- * @deprecated will be removed
- */
-const pubsubTopicToSingleShardInfo = (pubsubTopics) => {
-    const parts = pubsubTopics.split("/");
-    if (parts.length != 6 ||
-        parts[1] !== "waku" ||
-        parts[2] !== "2" ||
-        parts[3] !== "rs")
-        throw new Error("Invalid pubsub topic");
-    const clusterId = parseInt(parts[4]);
-    const shard = parseInt(parts[5]);
-    if (isNaN(clusterId) || isNaN(shard))
-        throw new Error("Invalid clusterId or shard");
-    return {
-        clusterId,
-        shard
-    };
-};
-/**
- * Given a string, will throw an error if it is not formatted as a valid content topic for autosharding based on https://rfc.vac.dev/spec/51/
- * @param contentTopic String to validate
- * @returns Object with each content topic field as an attribute
- */
-function ensureValidContentTopic(contentTopic) {
-    const parts = contentTopic.split("/");
-    if (parts.length < 5 || parts.length > 6) {
-        throw Error(`Content topic format is invalid: ${contentTopic}`);
-    }
-    // Validate generation field if present
-    let generation = 0;
-    if (parts.length == 6) {
-        generation = parseInt(parts[1]);
-        if (isNaN(generation)) {
-            throw new Error(`Invalid generation field in content topic: ${contentTopic}`);
-        }
-        if (generation > 0) {
-            throw new Error(`Generation greater than 0 is not supported: ${contentTopic}`);
-        }
-    }
-    // Validate remaining fields
-    const fields = parts.splice(-4);
-    // Validate application field
-    if (fields[0].length == 0) {
-        throw new Error(`Application field cannot be empty: ${contentTopic}`);
-    }
-    // Validate version field
-    if (fields[1].length == 0) {
-        throw new Error(`Version field cannot be empty: ${contentTopic}`);
-    }
-    // Validate topic name field
-    if (fields[2].length == 0) {
-        throw new Error(`Topic name field cannot be empty: ${contentTopic}`);
-    }
-    // Validate encoding field
-    if (fields[3].length == 0) {
-        throw new Error(`Encoding field cannot be empty: ${contentTopic}`);
-    }
-    return {
-        generation,
-        application: fields[0],
-        version: fields[1],
-        topicName: fields[2],
-        encoding: fields[3]
-    };
-}
-/**
- * Given a string, determines which autoshard index to use for its pubsub topic.
- * Based on the algorithm described in the RFC: https://rfc.vac.dev/spec/51//#algorithm
- */
-function contentTopicToShardIndex(contentTopic, numShardsInCluster) {
-    const { application, version } = ensureValidContentTopic(contentTopic);
-    const digest = sha256$1(concat$1([utf8ToBytes(application), utf8ToBytes(version)]));
-    const dataview = new DataView(digest.buffer.slice(-8));
-    return Number(dataview.getBigUint64(0, false) % BigInt(numShardsInCluster));
-}
-
 class BaseRoutingInfo {
     networkConfig;
     pubsubTopic;
@@ -771,6 +691,86 @@ function createRoutingInfo(networkConfig, options) {
     }
 }
 
+const formatPubsubTopic = (clusterId, shard) => {
+    return `/waku/2/rs/${clusterId}/${shard}`;
+};
+/**
+ * @deprecated will be removed
+ */
+const pubsubTopicToSingleShardInfo = (pubsubTopics) => {
+    const parts = pubsubTopics.split("/");
+    if (parts.length != 6 ||
+        parts[1] !== "waku" ||
+        parts[2] !== "2" ||
+        parts[3] !== "rs")
+        throw new Error("Invalid pubsub topic");
+    const clusterId = parseInt(parts[4]);
+    const shard = parseInt(parts[5]);
+    if (isNaN(clusterId) || isNaN(shard))
+        throw new Error("Invalid clusterId or shard");
+    return {
+        clusterId,
+        shard
+    };
+};
+/**
+ * Given a string, will throw an error if it is not formatted as a valid content topic for autosharding based on https://rfc.vac.dev/spec/51/
+ * @param contentTopic String to validate
+ * @returns Object with each content topic field as an attribute
+ */
+function ensureValidContentTopic(contentTopic) {
+    const parts = contentTopic.split("/");
+    if (parts.length < 5 || parts.length > 6) {
+        throw Error(`Content topic format is invalid: ${contentTopic}`);
+    }
+    // Validate generation field if present
+    let generation = 0;
+    if (parts.length == 6) {
+        generation = parseInt(parts[1]);
+        if (isNaN(generation)) {
+            throw new Error(`Invalid generation field in content topic: ${contentTopic}`);
+        }
+        if (generation > 0) {
+            throw new Error(`Generation greater than 0 is not supported: ${contentTopic}`);
+        }
+    }
+    // Validate remaining fields
+    const fields = parts.splice(-4);
+    // Validate application field
+    if (fields[0].length == 0) {
+        throw new Error(`Application field cannot be empty: ${contentTopic}`);
+    }
+    // Validate version field
+    if (fields[1].length == 0) {
+        throw new Error(`Version field cannot be empty: ${contentTopic}`);
+    }
+    // Validate topic name field
+    if (fields[2].length == 0) {
+        throw new Error(`Topic name field cannot be empty: ${contentTopic}`);
+    }
+    // Validate encoding field
+    if (fields[3].length == 0) {
+        throw new Error(`Encoding field cannot be empty: ${contentTopic}`);
+    }
+    return {
+        generation,
+        application: fields[0],
+        version: fields[1],
+        topicName: fields[2],
+        encoding: fields[3]
+    };
+}
+/**
+ * Given a string, determines which autoshard index to use for its pubsub topic.
+ * Based on the algorithm described in the RFC: https://rfc.vac.dev/spec/51//#algorithm
+ */
+function contentTopicToShardIndex(contentTopic, numShardsInCluster) {
+    const { application, version } = ensureValidContentTopic(contentTopic);
+    const digest = sha256$1(concat$1([utf8ToBytes(application), utf8ToBytes(version)]));
+    const dataview = new DataView(digest.buffer.slice(-8));
+    return Number(dataview.getBigUint64(0, false) % BigInt(numShardsInCluster));
+}
+
 const decodeRelayShard = (bytes) => {
     // explicitly converting to Uint8Array to avoid Buffer
     // https://github.com/libp2p/js-libp2p/issues/2146
@@ -830,6 +830,32 @@ var index$3 = /*#__PURE__*/Object.freeze({
     version_0: version_0
 });
 
+var LightPushStatusCode;
+(function (LightPushStatusCode) {
+    LightPushStatusCode[LightPushStatusCode["SUCCESS"] = 200] = "SUCCESS";
+    LightPushStatusCode[LightPushStatusCode["BAD_REQUEST"] = 400] = "BAD_REQUEST";
+    LightPushStatusCode[LightPushStatusCode["PAYLOAD_TOO_LARGE"] = 413] = "PAYLOAD_TOO_LARGE";
+    LightPushStatusCode[LightPushStatusCode["INVALID_MESSAGE"] = 420] = "INVALID_MESSAGE";
+    LightPushStatusCode[LightPushStatusCode["UNSUPPORTED_TOPIC"] = 421] = "UNSUPPORTED_TOPIC";
+    LightPushStatusCode[LightPushStatusCode["TOO_MANY_REQUESTS"] = 429] = "TOO_MANY_REQUESTS";
+    LightPushStatusCode[LightPushStatusCode["INTERNAL_ERROR"] = 500] = "INTERNAL_ERROR";
+    LightPushStatusCode[LightPushStatusCode["UNAVAILABLE"] = 503] = "UNAVAILABLE";
+    LightPushStatusCode[LightPushStatusCode["NO_RLN_PROOF"] = 504] = "NO_RLN_PROOF";
+    LightPushStatusCode[LightPushStatusCode["NO_PEERS"] = 505] = "NO_PEERS";
+})(LightPushStatusCode || (LightPushStatusCode = {}));
+({
+    [LightPushStatusCode.SUCCESS]: "Message sent successfully",
+    [LightPushStatusCode.BAD_REQUEST]: "Bad request format",
+    [LightPushStatusCode.PAYLOAD_TOO_LARGE]: "Message payload exceeds maximum size",
+    [LightPushStatusCode.INVALID_MESSAGE]: "Message validation failed",
+    [LightPushStatusCode.UNSUPPORTED_TOPIC]: "Unsupported pubsub topic",
+    [LightPushStatusCode.TOO_MANY_REQUESTS]: "Rate limit exceeded",
+    [LightPushStatusCode.INTERNAL_ERROR]: "Internal server error",
+    [LightPushStatusCode.UNAVAILABLE]: "Service temporarily unavailable",
+    [LightPushStatusCode.NO_RLN_PROOF]: "RLN proof generation failed",
+    [LightPushStatusCode.NO_PEERS]: "No relay peers available"
+});
+
 var Protocols;
 (function (Protocols) {
     Protocols["Relay"] = "relay";
@@ -837,96 +863,74 @@ var Protocols;
     Protocols["LightPush"] = "lightpush";
     Protocols["Filter"] = "filter";
 })(Protocols || (Protocols = {}));
+var LightPushError;
+(function (LightPushError) {
+    LightPushError["GENERIC_FAIL"] = "Generic error";
+    LightPushError["DECODE_FAILED"] = "Failed to decode";
+    LightPushError["NO_PEER_AVAILABLE"] = "No peer available";
+    LightPushError["NO_STREAM_AVAILABLE"] = "No stream available";
+    LightPushError["NO_RESPONSE"] = "No response received";
+    LightPushError["STREAM_ABORTED"] = "Stream aborted";
+    LightPushError["ENCODE_FAILED"] = "Failed to encode";
+    LightPushError["EMPTY_PAYLOAD"] = "Payload is empty";
+    LightPushError["SIZE_TOO_BIG"] = "Size is too big";
+    LightPushError["TOPIC_NOT_CONFIGURED"] = "Topic not configured";
+    LightPushError["RLN_PROOF_GENERATION"] = "Proof generation failed";
+    LightPushError["REMOTE_PEER_REJECTED"] = "Remote peer rejected";
+    LightPushError["BAD_REQUEST"] = "Bad request format";
+    LightPushError["PAYLOAD_TOO_LARGE"] = "Message payload exceeds maximum size";
+    LightPushError["INVALID_MESSAGE"] = "Message validation failed";
+    LightPushError["UNSUPPORTED_TOPIC"] = "Unsupported pubsub topic";
+    LightPushError["TOO_MANY_REQUESTS"] = "Rate limit exceeded";
+    LightPushError["INTERNAL_ERROR"] = "Internal server error";
+    LightPushError["UNAVAILABLE"] = "Service temporarily unavailable";
+    LightPushError["NO_RLN_PROOF"] = "RLN proof generation failed";
+    LightPushError["NO_PEERS"] = "No relay peers available";
+})(LightPushError || (LightPushError = {}));
+var FilterError;
+(function (FilterError) {
+    // General errors
+    FilterError["GENERIC_FAIL"] = "Generic error";
+    FilterError["DECODE_FAILED"] = "Failed to decode";
+    FilterError["NO_PEER_AVAILABLE"] = "No peer available";
+    FilterError["NO_STREAM_AVAILABLE"] = "No stream available";
+    FilterError["NO_RESPONSE"] = "No response received";
+    FilterError["STREAM_ABORTED"] = "Stream aborted";
+    // Filter specific errors
+    FilterError["REMOTE_PEER_REJECTED"] = "Remote peer rejected";
+    FilterError["TOPIC_NOT_CONFIGURED"] = "Topic not configured";
+    FilterError["SUBSCRIPTION_FAILED"] = "Subscription failed";
+    FilterError["UNSUBSCRIBE_FAILED"] = "Unsubscribe failed";
+    FilterError["PING_FAILED"] = "Ping failed";
+    FilterError["TOPIC_DECODER_MISMATCH"] = "Topic decoder mismatch";
+    FilterError["INVALID_DECODER_TOPICS"] = "Invalid decoder topics";
+    FilterError["SUBSCRIPTION_LIMIT_EXCEEDED"] = "Subscription limit exceeded";
+    FilterError["INVALID_CONTENT_TOPIC"] = "Invalid content topic";
+    FilterError["PUSH_MESSAGE_FAILED"] = "Push message failed";
+    FilterError["EMPTY_MESSAGE"] = "Empty message received";
+    FilterError["MISSING_PUBSUB_TOPIC"] = "Pubsub topic missing from push message";
+})(FilterError || (FilterError = {}));
+/**
+ * @deprecated Use LightPushError or FilterError instead
+ */
 var ProtocolError;
 (function (ProtocolError) {
-    //
-    // GENERAL ERRORS SECTION
-    //
-    /**
-     * Could not determine the origin of the fault. Best to check connectivity and try again
-     * */
     ProtocolError["GENERIC_FAIL"] = "Generic error";
-    /**
-     * The remote peer rejected the message. Information provided by the remote peer
-     * is logged. Review message validity, or mitigation for `NO_PEER_AVAILABLE`
-     * or `DECODE_FAILED` can be used.
-     */
     ProtocolError["REMOTE_PEER_REJECTED"] = "Remote peer rejected";
-    /**
-     * Failure to protobuf decode the message. May be due to a remote peer issue,
-     * ensuring that messages are sent via several peer enable mitigation of this error.
-     */
     ProtocolError["DECODE_FAILED"] = "Failed to decode";
-    /**
-     * Failure to find a peer with suitable protocols. This may due to a connection issue.
-     * Mitigation can be: retrying after a given time period, display connectivity issue
-     * to user or listening for `peer:connected:bootstrap` or `peer:connected:peer-exchange`
-     * on the connection manager before retrying.
-     */
     ProtocolError["NO_PEER_AVAILABLE"] = "No peer available";
-    /**
-     * Failure to find a stream to the peer. This may be because the connection with the peer is not still alive.
-     * Mitigation can be: retrying after a given time period, or mitigation for `NO_PEER_AVAILABLE` can be used.
-     */
     ProtocolError["NO_STREAM_AVAILABLE"] = "No stream available";
-    /**
-     * The remote peer did not behave as expected. Mitigation for `NO_PEER_AVAILABLE`
-     * or `DECODE_FAILED` can be used.
-     */
     ProtocolError["NO_RESPONSE"] = "No response received";
-    //
-    // SEND ERRORS SECTION
-    //
-    /**
-     * Failure to protobuf encode the message. This is not recoverable and needs
-     * further investigation.
-     */
     ProtocolError["ENCODE_FAILED"] = "Failed to encode";
-    /**
-     * The message payload is empty, making the message invalid. Ensure that a non-empty
-     * payload is set on the outgoing message.
-     */
     ProtocolError["EMPTY_PAYLOAD"] = "Payload is empty";
-    /**
-     * The message size is above the maximum message size allowed on the Waku Network.
-     * Compressing the message or using an alternative strategy for large messages is recommended.
-     */
     ProtocolError["SIZE_TOO_BIG"] = "Size is too big";
-    /**
-     * The PubsubTopic passed to the send function is not configured on the Waku node.
-     * Please ensure that the PubsubTopic is used when initializing the Waku node.
-     */
     ProtocolError["TOPIC_NOT_CONFIGURED"] = "Topic not configured";
-    /**
-     * Fails when
-     */
     ProtocolError["STREAM_ABORTED"] = "Stream aborted";
-    /**
-     * General proof generation error message.
-     * nwaku: https://github.com/waku-org/nwaku/blob/c3cb06ac6c03f0f382d3941ea53b330f6a8dd127/waku/waku_rln_relay/group_manager/group_manager_base.nim#L201C19-L201C42
-     */
     ProtocolError["RLN_PROOF_GENERATION"] = "Proof generation failed";
-    //
-    // RECEIVE ERRORS SECTION
-    //
-    /**
-     * The pubsub topic configured on the decoder does not match the pubsub topic setup on the protocol.
-     * Ensure that the pubsub topic used for decoder creation is the same as the one used for protocol.
-     */
     ProtocolError["TOPIC_DECODER_MISMATCH"] = "Topic decoder mismatch";
-    /**
-     * The topics passed in the decoders do not match each other, or don't exist at all.
-     * Ensure that all the pubsub topics used in the decoders are valid and match each other.
-     */
     ProtocolError["INVALID_DECODER_TOPICS"] = "Invalid decoder topics";
 })(ProtocolError || (ProtocolError = {}));
 
-var WakuEventType;
-(function (WakuEventType) {
-    WakuEventType["Connection"] = "waku:connection";
-    WakuEventType["Health"] = "waku:health";
-})(WakuEventType || (WakuEventType = {}));
-
 // Peer tags
 var Tags;
 (function (Tags) {
@@ -2801,7 +2805,7 @@ class FilterSubscribeResponse {
     }
 }
 
-const log$9 = new Logger("filter-core");
+const log$a = new Logger("filter-core");
 const FilterCodecs = {
     SUBSCRIBE: "/vac/waku/filter-subscribe/2.0.0-beta1",
     PUSH: "/vac/waku/filter-push/2.0.0-beta1"
@@ -2809,7 +2813,7 @@ const FilterCodecs = {
 class FilterCore {
     handleIncomingMessage;
     streamManager;
-    multicodec = FilterCodecs.SUBSCRIBE;
+    multicodec = [FilterCodecs.SUBSCRIBE];
     constructor(handleIncomingMessage, libp2p) {
         this.handleIncomingMessage = handleIncomingMessage;
         this.streamManager = new StreamManager(FilterCodecs.SUBSCRIBE, libp2p.components);
@@ -2818,7 +2822,7 @@ class FilterCore {
             maxInboundStreams: 100
         })
             .catch((e) => {
-            log$9.error("Failed to register ", FilterCodecs.PUSH, e);
+            log$a.error("Failed to register ", FilterCodecs.PUSH, e);
         });
     }
     async subscribe(pubsubTopic, peerId, contentTopics) {
@@ -2827,7 +2831,7 @@ class FilterCore {
             return {
                 success: null,
                 failure: {
-                    error: ProtocolError.NO_STREAM_AVAILABLE,
+                    error: FilterError.NO_STREAM_AVAILABLE,
                     peerId: peerId
                 }
             };
@@ -2841,21 +2845,21 @@ class FilterCore {
             }
         }
         catch (error) {
-            log$9.error("Failed to send subscribe request", error);
+            log$a.error("Failed to send subscribe request", error);
             return {
                 success: null,
                 failure: {
-                    error: ProtocolError.GENERIC_FAIL,
+                    error: FilterError.GENERIC_FAIL,
                     peerId: peerId
                 }
             };
         }
         const { statusCode, requestId, statusDesc } = FilterSubscribeResponse.decode(res[0].slice());
         if (statusCode < 200 || statusCode >= 300) {
-            log$9.error(`Filter subscribe request ${requestId} failed with status code ${statusCode}: ${statusDesc}`);
+            log$a.error(`Filter subscribe request ${requestId} failed with status code ${statusCode}: ${statusDesc}`);
             return {
                 failure: {
-                    error: ProtocolError.REMOTE_PEER_REJECTED,
+                    error: FilterError.REMOTE_PEER_REJECTED,
                     peerId: peerId
                 },
                 success: null
@@ -2869,11 +2873,11 @@ class FilterCore {
     async unsubscribe(pubsubTopic, peerId, contentTopics) {
         const stream = await this.streamManager.getStream(peerId);
         if (!stream) {
-            log$9.error(`Failed to get a stream for remote peer:${peerId.toString()}`);
+            log$a.error(`Failed to get a stream for remote peer:${peerId.toString()}`);
             return {
                 success: null,
                 failure: {
-                    error: ProtocolError.NO_STREAM_AVAILABLE,
+                    error: FilterError.NO_STREAM_AVAILABLE,
                     peerId: peerId
                 }
             };
@@ -2883,11 +2887,11 @@ class FilterCore {
             await pipe([unsubscribeRequest.encode()], encode, stream.sink);
         }
         catch (error) {
-            log$9.error("Failed to send unsubscribe request", error);
+            log$a.error("Failed to send unsubscribe request", error);
             return {
                 success: null,
                 failure: {
-                    error: ProtocolError.GENERIC_FAIL,
+                    error: FilterError.GENERIC_FAIL,
                     peerId: peerId
                 }
             };
@@ -2900,11 +2904,11 @@ class FilterCore {
     async unsubscribeAll(pubsubTopic, peerId) {
         const stream = await this.streamManager.getStream(peerId);
         if (!stream) {
-            log$9.error(`Failed to get a stream for remote peer:${peerId.toString()}`);
+            log$a.error(`Failed to get a stream for remote peer:${peerId.toString()}`);
             return {
                 success: null,
                 failure: {
-                    error: ProtocolError.NO_STREAM_AVAILABLE,
+                    error: FilterError.NO_STREAM_AVAILABLE,
                     peerId: peerId
                 }
             };
@@ -2914,7 +2918,7 @@ class FilterCore {
         if (!res || !res.length) {
             return {
                 failure: {
-                    error: ProtocolError.NO_RESPONSE,
+                    error: FilterError.NO_RESPONSE,
                     peerId: peerId
                 },
                 success: null
@@ -2922,10 +2926,10 @@ class FilterCore {
         }
         const { statusCode, requestId, statusDesc } = FilterSubscribeResponse.decode(res[0].slice());
         if (statusCode < 200 || statusCode >= 300) {
-            log$9.error(`Filter unsubscribe all request ${requestId} failed with status code ${statusCode}: ${statusDesc}`);
+            log$a.error(`Filter unsubscribe all request ${requestId} failed with status code ${statusCode}: ${statusDesc}`);
             return {
                 failure: {
-                    error: ProtocolError.REMOTE_PEER_REJECTED,
+                    error: FilterError.REMOTE_PEER_REJECTED,
                     peerId: peerId
                 },
                 success: null
@@ -2939,11 +2943,11 @@ class FilterCore {
     async ping(peerId) {
         const stream = await this.streamManager.getStream(peerId);
         if (!stream) {
-            log$9.error(`Failed to get a stream for remote peer:${peerId.toString()}`);
+            log$a.error(`Failed to get a stream for remote peer:${peerId.toString()}`);
             return {
                 success: null,
                 failure: {
-                    error: ProtocolError.NO_STREAM_AVAILABLE,
+                    error: FilterError.NO_STREAM_AVAILABLE,
                     peerId: peerId
                 }
             };
@@ -2954,11 +2958,11 @@ class FilterCore {
             res = await pipe([request.encode()], encode, stream, decode, async (source) => await all(source));
         }
         catch (error) {
-            log$9.error("Failed to send ping request", error);
+            log$a.error("Failed to send ping request", error);
             return {
                 success: null,
                 failure: {
-                    error: ProtocolError.GENERIC_FAIL,
+                    error: FilterError.GENERIC_FAIL,
                     peerId: peerId
                 }
             };
@@ -2967,18 +2971,18 @@ class FilterCore {
             return {
                 success: null,
                 failure: {
-                    error: ProtocolError.NO_RESPONSE,
+                    error: FilterError.NO_RESPONSE,
                     peerId: peerId
                 }
             };
         }
         const { statusCode, requestId, statusDesc } = FilterSubscribeResponse.decode(res[0].slice());
         if (statusCode < 200 || statusCode >= 300) {
-            log$9.error(`Filter ping request ${requestId} failed with status code ${statusCode}: ${statusDesc}`);
+            log$a.error(`Filter ping request ${requestId} failed with status code ${statusCode}: ${statusDesc}`);
             return {
                 success: null,
                 failure: {
-                    error: ProtocolError.REMOTE_PEER_REJECTED,
+                    error: FilterError.REMOTE_PEER_REJECTED,
                     peerId: peerId
                 }
             };
@@ -2991,30 +2995,30 @@ class FilterCore {
     onRequest(streamData) {
         const { connection, stream } = streamData;
         const { remotePeer } = connection;
-        log$9.info(`Received message from ${remotePeer.toString()}`);
+        log$a.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$9.error("Received empty message");
+                        log$a.error("Received empty message");
                         return;
                     }
                     if (!pubsubTopic) {
-                        log$9.error("Pubsub topic missing from push message");
+                        log$a.error("Pubsub topic missing from push message");
                         return;
                     }
                     await this.handleIncomingMessage(pubsubTopic, wakuMessage, connection.remotePeer.toString());
                 }
             }).then(() => {
-                log$9.info("Receiving pipe closed.");
+                log$a.info("Receiving pipe closed.");
             }, async (e) => {
-                log$9.error(`Error with receiving pipe on peer:${connection.remotePeer.toString()} -- stream:${stream.id} -- protocol:${stream.protocol}: `, e);
+                log$a.error(`Error with receiving pipe on peer:${connection.remotePeer.toString()} -- stream:${stream.id} -- protocol:${stream.protocol}: `, e);
             });
         }
         catch (e) {
-            log$9.error("Error decoding message", e);
+            log$a.error("Error decoding message", e);
         }
     }
 }
@@ -3025,13 +3029,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,
@@ -3042,7 +3046,7 @@ class PushRpc {
     }
     static decode(bytes) {
         const res = PushRpc$1.decode(bytes);
-        return new PushRpc(res);
+        return new PushRpcV2(res);
     }
     encode() {
         return PushRpc$1.encode(this.proto);
@@ -3055,6 +3059,140 @@ class PushRpc {
     }
 }
 
+/**
+ * LightPush v3 protocol RPC handler.
+ * Implements the v3 message format with correct field numbers:
+ * - requestId: 1
+ * - pubsubTopic: 20
+ * - message: 21
+ */
+class PushRpc {
+    proto;
+    constructor(proto) {
+        this.proto = proto;
+    }
+    /**
+     * Create a v3 request message with proper field numbering
+     */
+    static createRequest(message, pubsubTopic) {
+        return new PushRpc({
+            requestId: v4(),
+            pubsubTopic: pubsubTopic,
+            message: message
+        });
+    }
+    /**
+     * Create a v3 response message with status code handling
+     */
+    static createResponse(requestId, statusCode, statusDesc, relayPeerCount) {
+        return new PushRpc({
+            requestId,
+            statusCode,
+            statusDesc,
+            relayPeerCount
+        });
+    }
+    /**
+     * Decode v3 request message
+     */
+    static decodeRequest(bytes) {
+        const res = LightPushRequestV3.decode(bytes);
+        return new PushRpc(res);
+    }
+    /**
+     * Decode v3 response message
+     */
+    static decodeResponse(bytes) {
+        const res = LightPushResponseV3.decode(bytes);
+        return new PushRpc(res);
+    }
+    /**
+     * Encode message to bytes
+     */
+    encode() {
+        if (this.isRequest()) {
+            return LightPushRequestV3.encode(this.proto);
+        }
+        else {
+            return LightPushResponseV3.encode(this.proto);
+        }
+    }
+    /**
+     * Get request data (if this is a request message)
+     */
+    get request() {
+        return this.isRequest()
+            ? this.proto
+            : undefined;
+    }
+    /**
+     * Get response data (if this is a response message)
+     */
+    get response() {
+        return this.isResponse()
+            ? this.proto
+            : undefined;
+    }
+    /**
+     * Get the request ID
+     */
+    get requestId() {
+        return this.proto.requestId;
+    }
+    /**
+     * Get the pubsub topic (only available in requests)
+     */
+    get pubsubTopic() {
+        return this.isRequest()
+            ? this.proto.pubsubTopic
+            : undefined;
+    }
+    /**
+     * Get the message (only available in requests)
+     */
+    get message() {
+        return this.isRequest()
+            ? this.proto.message
+            : undefined;
+    }
+    /**
+     * Get the status code (only available in responses)
+     */
+    get statusCode() {
+        return this.isResponse()
+            ? this.proto.statusCode
+            : undefined;
+    }
+    /**
+     * Get the status description (only available in responses)
+     */
+    get statusDesc() {
+        return this.isResponse()
+            ? this.proto.statusDesc
+            : undefined;
+    }
+    /**
+     * Get the relay peer count (only available in responses)
+     */
+    get relayPeerCount() {
+        return this.isResponse()
+            ? this.proto.relayPeerCount
+            : undefined;
+    }
+    /**
+     * Check if this is a request message
+     */
+    isRequest() {
+        return "pubsubTopic" in this.proto && "message" in this.proto;
+    }
+    /**
+     * Check if this is a response message
+     */
+    isResponse() {
+        return "statusCode" in this.proto;
+    }
+}
+
 // should match nwaku
 // https://github.com/waku-org/nwaku/blob/c3cb06ac6c03f0f382d3941ea53b330f6a8dd127/waku/waku_rln_relay/rln_relay.nim#L309
 // https://github.com/waku-org/nwaku/blob/c3cb06ac6c03f0f382d3941ea53b330f6a8dd127/tests/waku_rln_relay/rln/waku_rln_relay_utils.nim#L20
@@ -3073,140 +3211,243 @@ const isRLNResponseError = (info) => {
         info.includes(RLN_REMOTE_VALIDATION));
 };
 
-const log$8 = 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/).
- */
-class LightPushCore {
-    streamManager;
-    multicodec = LightPushCodec;
-    constructor(libp2p) {
-        this.streamManager = new StreamManager(LightPushCodec, libp2p.components);
-    }
-    async preparePushMessage(encoder, message) {
+const CODECS = {
+    v2: "/vac/waku/lightpush/2.0.0-beta1",
+    v3: "/vac/waku/lightpush/3.0.0"
+};
+const log$9 = new Logger("light-push:protocol-handler");
+class ProtocolHandler {
+    static async preparePushMessage(encoder, message, protocol) {
         try {
             if (!message.payload || message.payload.length === 0) {
-                log$8.error("Failed to send waku light push: payload is empty");
-                return { query: null, error: ProtocolError.EMPTY_PAYLOAD };
+                log$9.error("Failed to send waku light push: payload is empty");
+                return { rpc: null, error: LightPushError.EMPTY_PAYLOAD };
             }
             if (!(await isMessageSizeUnderCap(encoder, message))) {
-                log$8.error("Failed to send waku light push: message is bigger than 1MB");
-                return { query: null, error: ProtocolError.SIZE_TOO_BIG };
+                log$9.error("Failed to send waku light push: message is bigger than 1MB");
+                return { rpc: null, error: LightPushError.SIZE_TOO_BIG };
             }
             const protoMessage = await encoder.toProtoObj(message);
             if (!protoMessage) {
-                log$8.error("Failed to encode to protoMessage, aborting push");
+                log$9.error("Failed to encode to protoMessage, aborting push");
+                return { rpc: null, error: LightPushError.ENCODE_FAILED };
+            }
+            // Select version implementation
+            if (protocol === CODECS.v3) {
+                log$9.info("Creating v3 RPC message");
                 return {
-                    query: null,
-                    error: ProtocolError.ENCODE_FAILED
+                    rpc: createV3Rpc(protoMessage, encoder.pubsubTopic),
+                    error: null
                 };
             }
-            const query = PushRpc.createRequest(protoMessage, encoder.pubsubTopic);
-            return { query, error: null };
+            // Default to v2
+            log$9.info("Creating v2 RPC message");
+            return {
+                rpc: createV2Rpc(protoMessage, encoder.pubsubTopic),
+                error: null
+            };
         }
-        catch (error) {
-            log$8.error("Failed to prepare push message", error);
+        catch (err) {
+            log$9.error("Failed to prepare push message", err);
+            return { rpc: null, error: LightPushError.GENERIC_FAIL };
+        }
+    }
+    /**
+     * Decode and evaluate a LightPush response according to the protocol version
+     */
+    static handleResponse(bytes, protocol, peerId) {
+        if (protocol === CODECS.v3) {
+            return ProtocolHandler.handleV3Response(bytes, peerId);
+        }
+        return ProtocolHandler.handleV2Response(bytes, peerId);
+    }
+    static handleV3Response(bytes, peerId) {
+        try {
+            const decodedRpcV3 = PushRpc.decodeResponse(bytes);
+            const statusCode = decodedRpcV3.statusCode;
+            const statusDesc = decodedRpcV3.statusDesc;
+            if (statusCode !== LightPushStatusCode.SUCCESS) {
+                const error = LightPushError.REMOTE_PEER_REJECTED;
+                log$9.error(`Remote peer rejected with v3 status code ${statusCode}: ${statusDesc}`);
+                return {
+                    success: null,
+                    failure: {
+                        error,
+                        peerId: peerId
+                    }
+                };
+            }
+            if (decodedRpcV3.relayPeerCount !== undefined) {
+                log$9.info(`Message relayed to ${decodedRpcV3.relayPeerCount} peers`);
+            }
+            return { success: peerId, failure: null };
+        }
+        catch (err) {
             return {
-                query: null,
-                error: ProtocolError.GENERIC_FAIL
+                success: null,
+                failure: {
+                    error: LightPushError.DECODE_FAILED,
+                    peerId: peerId
+                }
             };
         }
     }
-    async send(encoder, message, peerId) {
-        const { query, error: preparationError } = await this.preparePushMessage(encoder, message);
-        if (preparationError || !query) {
+    static handleV2Response(bytes, peerId) {
+        let response;
+        try {
+            const decodedRpc = PushRpcV2.decode(bytes);
+            response = decodedRpc.response;
+        }
+        catch (err) {
             return {
                 success: null,
                 failure: {
-                    error: preparationError,
-                    peerId
+                    error: LightPushError.DECODE_FAILED,
+                    peerId: peerId
                 }
             };
         }
-        const stream = await this.streamManager.getStream(peerId);
-        if (!stream) {
-            log$8.error(`Failed to get a stream for remote peer:${peerId.toString()}`);
+        if (!response) {
             return {
                 success: null,
                 failure: {
-                    error: ProtocolError.NO_STREAM_AVAILABLE,
+                    error: LightPushError.NO_RESPONSE,
                     peerId: peerId
                 }
             };
         }
-        let res;
-        try {
-            res = await pipe([query.encode()], encode, stream, decode, async (source) => await all(source));
+        if (isRLNResponseError(response.info)) {
+            log$9.error("Remote peer fault: RLN generation");
+            return {
+                success: null,
+                failure: {
+                    error: LightPushError.RLN_PROOF_GENERATION,
+                    peerId: peerId
+                }
+            };
         }
-        catch (err) {
-            // can fail only because of `stream` abortion
-            log$8.error("Failed to send waku light push request", err);
+        if (!response.isSuccess) {
+            log$9.error("Remote peer rejected the message: ", response.info);
             return {
                 success: null,
                 failure: {
-                    error: ProtocolError.STREAM_ABORTED,
+                    error: LightPushError.REMOTE_PEER_REJECTED,
                     peerId: peerId
                 }
             };
         }
-        const bytes = new Uint8ArrayList();
-        res.forEach((chunk) => {
-            bytes.append(chunk);
-        });
-        let response;
+        return { success: peerId, failure: null };
+    }
+}
+function createV2Rpc(message, pubsubTopic) {
+    const v2Rpc = PushRpcV2.createRequest(message, pubsubTopic);
+    return Object.assign(v2Rpc, { version: "v2" });
+}
+function createV3Rpc(message, pubsubTopic) {
+    if (!message.timestamp) {
+        message.timestamp = BigInt(Date.now()) * BigInt(1_000_000);
+    }
+    const v3Rpc = PushRpc.createRequest(message, pubsubTopic);
+    return Object.assign(v3Rpc, { version: "v3" });
+}
+
+const log$8 = new Logger("light-push");
+const LightPushCodec = CODECS.v3;
+const LightPushCodecV2 = CODECS.v2;
+/**
+ * Implements the [Waku v2 Light Push protocol](https://rfc.vac.dev/spec/19/).
+ */
+class LightPushCore {
+    libp2p;
+    streamManager;
+    streamManagerV2;
+    multicodec = [CODECS.v3, CODECS.v2];
+    constructor(libp2p, legacy) {
+        this.libp2p = libp2p;
+        this.streamManagerV2 = new StreamManager(CODECS.v2, libp2p.components);
+        this.streamManager = legacy
+            ? this.streamManagerV2
+            : new StreamManager(CODECS.v3, libp2p.components);
+    }
+    async send(encoder, message, peerId) {
+        let stream;
+        let protocol;
         try {
-            response = PushRpc.decode(bytes).response;
+            const peer = await this.libp2p.peerStore.get(peerId);
+            if (this.streamManager.multicodec === CODECS.v3 &&
+                peer.protocols.includes(CODECS.v3)) {
+                stream = await this.streamManager.getStream(peerId);
+                protocol = CODECS.v3;
+            }
+            else {
+                stream = await this.streamManagerV2.getStream(peerId);
+                protocol = CODECS.v2;
+            }
         }
-        catch (err) {
-            log$8.error("Failed to decode push reply", err);
+        catch (error) {
+            log$8.error("Failed to get stream", error);
             return {
                 success: null,
                 failure: {
-                    error: ProtocolError.DECODE_FAILED,
-                    peerId: peerId
+                    error: LightPushError.GENERIC_FAIL,
+                    peerId
                 }
             };
         }
-        if (!response) {
-            log$8.error("Remote peer fault: No response in PushRPC");
+        if (!stream) {
+            log$8.error(`Failed to get a stream for remote peer:${peerId.toString()}`);
             return {
                 success: null,
                 failure: {
-                    error: ProtocolError.NO_RESPONSE,
+                    error: LightPushError.NO_STREAM_AVAILABLE,
                     peerId: peerId
                 }
             };
         }
-        if (isRLNResponseError(response.info)) {
-            log$8.error("Remote peer fault: RLN generation");
+        const { rpc, error: prepError } = await ProtocolHandler.preparePushMessage(encoder, message, protocol);
+        if (prepError || !rpc) {
             return {
                 success: null,
                 failure: {
-                    error: ProtocolError.RLN_PROOF_GENERATION,
+                    error: prepError ?? LightPushError.GENERIC_FAIL,
+                    peerId
+                }
+            };
+        }
+        let res;
+        try {
+            res = await pipe([rpc.encode()], encode, stream, decode, async (source) => await all(source));
+        }
+        catch (err) {
+            log$8.error("Failed to send waku light push request", err);
+            return {
+                success: null,
+                failure: {
+                    error: LightPushError.STREAM_ABORTED,
                     peerId: peerId
                 }
             };
         }
-        if (!response.isSuccess) {
-            log$8.error("Remote peer rejected the message: ", response.info);
+        const bytes = new Uint8ArrayList();
+        res.forEach((chunk) => bytes.append(chunk));
+        if (bytes.length === 0) {
             return {
                 success: null,
                 failure: {
-                    error: ProtocolError.REMOTE_PEER_REJECTED,
+                    error: LightPushError.NO_RESPONSE,
                     peerId: peerId
                 }
             };
         }
-        return { success: peerId, failure: null };
+        return ProtocolHandler.handleResponse(bytes, protocol, peerId);
     }
 }
 
 var index$1 = /*#__PURE__*/Object.freeze({
     __proto__: null,
     LightPushCodec: LightPushCodec,
-    LightPushCore: LightPushCore,
-    get PushResponse () { return PushResponse; }
+    LightPushCodecV2: LightPushCodecV2,
+    LightPushCore: LightPushCore
 });
 
 const EmptyMessage = {
@@ -3305,7 +3546,7 @@ const log$7 = new Logger("store");
 const StoreCodec = "/vac/waku/store-query/3.0.0";
 class StoreCore {
     streamManager;
-    multicodec = StoreCodec;
+    multicodec = [StoreCodec];
     constructor(libp2p) {
         this.streamManager = new StreamManager(StoreCodec, libp2p.components);
     }
@@ -3428,7 +3669,7 @@ class ConnectionLimiter {
             this.connectionMonitorInterval === null) {
             this.connectionMonitorInterval = setInterval(() => void this.maintainConnections(), DEFAULT_CONNECTION_MONITOR_INTERVAL);
         }
-        this.events.addEventListener(WakuEventType.Connection, this.onWakuConnectionEvent);
+        this.events.addEventListener("waku:connection", this.onWakuConnectionEvent);
         /**
          * NOTE: Event is not being emitted on closing nor losing a connection.
          * @see https://github.com/libp2p/js-libp2p/issues/939
@@ -3443,7 +3684,7 @@ class ConnectionLimiter {
         this.libp2p.addEventListener("peer:disconnect", this.onDisconnectedEvent);
     }
     stop() {
-        this.events.removeEventListener(WakuEventType.Connection, this.onWakuConnectionEvent);
+        this.events.removeEventListener("waku:connection", this.onWakuConnectionEvent);
         this.libp2p.removeEventListener("peer:disconnect", this.onDisconnectedEvent);
         if (this.connectionMonitorInterval) {
             clearInterval(this.connectionMonitorInterval);
@@ -4000,7 +4241,7 @@ class NetworkMonitor {
         }
     }
     dispatchNetworkEvent() {
-        this.events.dispatchEvent(new CustomEvent(WakuEventType.Connection, {
+        this.events.dispatchEvent(new CustomEvent("waku:connection", {
             detail: this.isConnected()
         }));
     }
@@ -9484,7 +9725,7 @@ class Metadata {
     streamManager;
     libp2pComponents;
     handshakesConfirmed = new Map();
-    multicodec = MetadataCodec;
+    multicodec = [MetadataCodec];
     constructor(clusterId, libp2p) {
         this.clusterId = clusterId;
         this.streamManager = new StreamManager(MetadataCodec, libp2p);
@@ -9593,4 +9834,4 @@ function wakuMetadata(clusterId) {
     return (components) => new Metadata(clusterId, components);
 }
 
-export { ConnectionManager, FilterCodecs, FilterCore, LightPushCodec, LightPushCore, MetadataCodec, StoreCodec, StoreCore, StreamManager, createEncoder, index$3 as message, wakuMetadata, index$2 as waku_filter, index$1 as waku_light_push, index as waku_store };
+export { ConnectionManager, FilterCodecs, FilterCore, LightPushCodec, LightPushCodecV2, LightPushCore, MetadataCodec, StoreCodec, StoreCore, StreamManager, createEncoder, index$3 as message, wakuMetadata, index$2 as waku_filter, index$1 as waku_light_push, index as waku_store };