@waku/core 0.0.38 → 0.0.39-8866516.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, B as BASES, f as fromString, 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, p as enumeration, q as message, r as encodeMessage, s as decodeMessage, t as bases, u as base64url, w as encodeUint8Array, W as WakuMetadataRequest, x as WakuMetadataResponse } from './version_0-CGLjyYN6.js';
-export { y as createDecoder } from './version_0-CGLjyYN6.js';
+import { e as equals$2, c as coerce, b as base32, a as base58btc, d as base36, B as BASES, f as fromString, 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, q as enumeration, r as message, s as encodeMessage, t as decodeMessage, u as bases, w as base64url, x as encodeUint8Array, W as WakuMetadataRequest, y as WakuMetadataResponse } from './version_0-C6zxTApZ.js';
+export { z as createDecoder } from './version_0-C6zxTApZ.js';
 
 /* eslint-disable */
 var encode_1 = encode$2;
@@ -1540,6 +1540,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";
@@ -1547,87 +1573,71 @@ 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 = {}));
 
@@ -3505,7 +3515,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"
@@ -3513,7 +3523,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);
@@ -3522,7 +3532,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) {
@@ -3531,7 +3541,7 @@ class FilterCore {
             return {
                 success: null,
                 failure: {
-                    error: ProtocolError.NO_STREAM_AVAILABLE,
+                    error: FilterError.NO_STREAM_AVAILABLE,
                     peerId: peerId
                 }
             };
@@ -3545,21 +3555,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
@@ -3573,11 +3583,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
                 }
             };
@@ -3587,11 +3597,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
                 }
             };
@@ -3604,11 +3614,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
                 }
             };
@@ -3618,7 +3628,7 @@ class FilterCore {
         if (!res || !res.length) {
             return {
                 failure: {
-                    error: ProtocolError.NO_RESPONSE,
+                    error: FilterError.NO_RESPONSE,
                     peerId: peerId
                 },
                 success: null
@@ -3626,10 +3636,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
@@ -3643,11 +3653,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
                 }
             };
@@ -3658,11 +3668,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
                 }
             };
@@ -3671,18 +3681,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
                 }
             };
@@ -3695,30 +3705,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);
         }
     }
 }
@@ -3729,13 +3739,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,
@@ -3746,7 +3756,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);
@@ -3759,6 +3769,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
@@ -3777,140 +3921,240 @@ 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) {
+        this.libp2p = libp2p;
+        this.streamManager = new StreamManager(CODECS.v3, libp2p.components);
+        this.streamManagerV2 = new StreamManager(CODECS.v2, 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 (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: 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: ProtocolError.RLN_PROOF_GENERATION,
+                    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 = {
@@ -4009,7 +4253,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);
     }
@@ -10188,7 +10432,7 @@ class Metadata {
     streamManager;
     libp2pComponents;
     handshakesConfirmed = new Map();
-    multicodec = MetadataCodec;
+    multicodec = [MetadataCodec];
     constructor(clusterId, libp2p) {
         this.clusterId = clusterId;
         this.streamManager = new StreamManager(MetadataCodec, libp2p);
@@ -10378,4 +10622,4 @@ function messageHashStr(pubsubTopic, message) {
     return hashStr;
 }
 
-export { ConnectionManager, FilterCodecs, FilterCore, LightPushCodec, LightPushCore, MetadataCodec, StoreCodec, StoreCore, StreamManager, 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, MetadataCodec, StoreCodec, StoreCore, StreamManager, createEncoder, index$3 as message, messageHash, messageHashStr, wakuMetadata, index$2 as waku_filter, index$1 as waku_light_push, index as waku_store };