@waku/core 0.0.36-acc9100.0 → 0.0.36-b0a2e39.0

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, 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-DyRL7WVV.js';
+export { x as createDecoder } from './version_0-DyRL7WVV.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 LightPushCodecV3, g as LightPushStatusCodeV3, i as isSuccessStatusCodeV3, h as getLightPushStatusDescriptionV3, l as lightPushStatusCodeToProtocolErrorV3, T as Tags, E as EPeersByDiscoveryEvents, j as EConnectionStateEvents } from './index-DckUzRoN.js';
+import { B as BaseProtocol } from './base_protocol-DEDdl6tx.js';
+export { S as StreamManager } from './base_protocol-DEDdl6tx.js';
 
 /* eslint-disable */
 var encode_1 = encode$1;
@@ -2298,7 +2298,7 @@ class FilterSubscribeResponse {
     }
 }
 
-const log$5 = new Logger("filter:v2");
+const log$7 = 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$7.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$7.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$7.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$7.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$7.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$7.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$7.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$7.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$7.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$7.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$7.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$7.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$7.error("Received empty message");
                         return;
                     }
                     if (!pubsubTopic) {
-                        log$5.error("Pubsub topic missing from push message");
+                        log$7.error("Pubsub topic missing from push message");
                         return;
                     }
                     await FilterCore.handleIncomingMessage?.(pubsubTopic, wakuMessage, connection.remotePeer.toString());
                 }
             }).then(() => {
-                log$5.info("Receiving pipe closed.");
+                log$7.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$7.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$7.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;
@@ -2554,6 +2554,22 @@ class PushRpc {
     }
 }
 
+const log$6 = new Logger("waku:light-push:utils");
+const UUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+/**
+ * Validates a Light Push v3 request ID format.
+ * Request IDs should be valid UUIDs, with special handling for "N/A" when rate limited.
+ *
+ * @param requestId - The request ID to validate
+ * @returns true if the request ID is valid, false otherwise
+ */
+function isValidRequestId(requestId) {
+    if (!requestId)
+        return false;
+    if (requestId === "N/A")
+        return true; // Special case for rate-limited responses
+    return UUID_REGEX.test(requestId);
+}
 // 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
@@ -2571,12 +2587,61 @@ 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";
+function mapInfoToProtocolError(info) {
+    if (!info) {
+        return ProtocolError.REMOTE_PEER_REJECTED;
+    }
+    const lowerInfo = info.toLowerCase();
+    if (isRLNResponseError(info)) {
+        return ProtocolError.RLN_PROOF_GENERATION;
+    }
+    if (lowerInfo.includes("rate limit") ||
+        lowerInfo.includes("too many requests")) {
+        return ProtocolError.REMOTE_PEER_REJECTED;
+    }
+    if (lowerInfo.includes("topic") &&
+        (lowerInfo.includes("not found") || lowerInfo.includes("not configured"))) {
+        return ProtocolError.TOPIC_NOT_CONFIGURED;
+    }
+    if (lowerInfo.includes("too large") || lowerInfo.includes("size")) {
+        return ProtocolError.SIZE_TOO_BIG;
+    }
+    if (lowerInfo.includes("decode") ||
+        lowerInfo.includes("invalid") ||
+        lowerInfo.includes("malformed")) {
+        return ProtocolError.DECODE_FAILED;
+    }
+    if (lowerInfo.includes("empty") && lowerInfo.includes("payload")) {
+        return ProtocolError.EMPTY_PAYLOAD;
+    }
+    return ProtocolError.REMOTE_PEER_REJECTED;
+}
 /**
- * Implements the [Waku v2 Light Push protocol](https://rfc.vac.dev/spec/19/).
+ * Validates that a message conforms to Light Push protocol requirements.
+ *
+ * @param message - The message to validate
+ * @param encoder - The encoder to use for message size validation
+ * @returns A ProtocolError if validation fails, null if the message is valid
+ *
+ * @remarks
+ * This function performs the following validations:
+ * - Checks if the message payload exists and is not empty
+ * - Verifies the encoded message size is under the network cap (1MB)
  */
+async function validateMessage(message, encoder) {
+    if (!message.payload?.length) {
+        log$6.error("Failed to send waku light push: payload is empty");
+        return ProtocolError.EMPTY_PAYLOAD;
+    }
+    if (!(await isMessageSizeUnderCap(encoder, message))) {
+        log$6.error("Failed to send waku light push: message is bigger than 1MB");
+        return ProtocolError.SIZE_TOO_BIG;
+    }
+    return null;
+}
+
+const log$5 = new Logger("light-push");
+const LightPushCodec = "/vac/waku/lightpush/2.0.0-beta1";
 class LightPushCore extends BaseProtocol {
     pubsubTopics;
     constructor(pubsubTopics, libp2p) {
@@ -2585,27 +2650,23 @@ class LightPushCore extends BaseProtocol {
     }
     async preparePushMessage(encoder, message) {
         try {
-            if (!message.payload || message.payload.length === 0) {
-                log$4.error("Failed to send waku light push: payload is empty");
-                return { query: null, error: ProtocolError.EMPTY_PAYLOAD };
-            }
-            if (!(await isMessageSizeUnderCap(encoder, message))) {
-                log$4.error("Failed to send waku light push: message is bigger than 1MB");
-                return { query: null, error: ProtocolError.SIZE_TOO_BIG };
+            const validationError = await validateMessage(message, encoder);
+            if (validationError) {
+                return { query: null, error: validationError };
             }
             const protoMessage = await encoder.toProtoObj(message);
             if (!protoMessage) {
-                log$4.error("Failed to encode to protoMessage, aborting push");
+                log$5.error("Failed to encode to protoMessage, aborting push");
                 return {
                     query: null,
                     error: ProtocolError.ENCODE_FAILED
                 };
             }
-            const query = PushRpc.createRequest(protoMessage, encoder.pubsubTopic);
+            const query = PushRpcV2.createRequest(protoMessage, encoder.pubsubTopic);
             return { query, error: null };
         }
         catch (error) {
-            log$4.error("Failed to prepare push message", error);
+            log$5.error("Failed to prepare push message", error);
             return {
                 query: null,
                 error: ProtocolError.GENERIC_FAIL
@@ -2628,7 +2689,7 @@ class LightPushCore extends BaseProtocol {
             stream = await this.getStream(peerId);
         }
         catch (error) {
-            log$4.error("Failed to get stream", error);
+            log$5.error("Failed to get stream", error);
             return {
                 success: null,
                 failure: {
@@ -2642,8 +2703,7 @@ 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);
+            log$5.error("Failed to send waku light push request", err);
             return {
                 success: null,
                 failure: {
@@ -2652,16 +2712,16 @@ class LightPushCore extends BaseProtocol {
                 }
             };
         }
-        const bytes = new Uint8ArrayList();
-        res.forEach((chunk) => {
-            bytes.append(chunk);
-        });
+        const bytes = res.reduce((acc, chunk) => {
+            acc.append(chunk);
+            return acc;
+        }, new Uint8ArrayList());
         let response;
         try {
-            response = PushRpc.decode(bytes).response;
+            response = PushRpcV2.decode(bytes).response;
         }
         catch (err) {
-            log$4.error("Failed to decode push reply", err);
+            log$5.error("Failed to decode push reply", err);
             return {
                 success: null,
                 failure: {
@@ -2671,7 +2731,7 @@ class LightPushCore extends BaseProtocol {
             };
         }
         if (!response) {
-            log$4.error("Remote peer fault: No response in PushRPC");
+            log$5.error("Remote peer fault: No response in PushRPC");
             return {
                 success: null,
                 failure: {
@@ -2680,27 +2740,229 @@ class LightPushCore extends BaseProtocol {
                 }
             };
         }
-        if (isRLNResponseError(response.info)) {
-            log$4.error("Remote peer fault: RLN generation");
-            return {
-                success: null,
-                failure: {
-                    error: ProtocolError.RLN_PROOF_GENERATION,
-                    peerId: peerId
-                }
-            };
-        }
         if (!response.isSuccess) {
-            log$4.error("Remote peer rejected the message: ", response.info);
+            const errorMessage = response.info || "Message rejected";
+            log$5.error("Remote peer rejected the message: ", errorMessage);
+            const error = mapInfoToProtocolError(response.info);
             return {
                 success: null,
                 failure: {
-                    error: ProtocolError.REMOTE_PEER_REJECTED,
+                    error: error,
                     peerId: peerId
                 }
             };
         }
-        return { success: peerId, failure: null };
+        return {
+            success: peerId,
+            failure: null
+        };
+    }
+}
+
+class PushRpcV3 {
+    request;
+    response;
+    constructor(request, response) {
+        this.request = request;
+        this.response = response;
+    }
+    static createRequest(message, pubsubTopic) {
+        const request = {
+            requestId: v4(),
+            message: message,
+            ...(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 log$4 = new Logger("light-push-v3");
+const STREAM_TIMEOUT_MS = 30000;
+class LightPushError extends Error {
+    protocol;
+    peerId;
+    response;
+    constructor(protocol, peerId, response, message) {
+        super(message || protocol);
+        this.protocol = protocol;
+        this.peerId = peerId;
+        this.response = response;
+        this.name = "LightPushError";
+    }
+}
+function withTimeout(promise, timeoutMs) {
+    return Promise.race([
+        promise,
+        new Promise((_, reject) => setTimeout(() => reject(new Error("Stream operation timed out")), timeoutMs))
+    ]);
+}
+function createSuccessResult(peerId, response) {
+    return {
+        success: peerId,
+        failure: null,
+        requestId: response.requestId,
+        statusCode: response.statusCode,
+        statusDesc: response.statusDesc,
+        relayPeerCount: response.relayPeerCount
+    };
+}
+function createFailureResult(error) {
+    const result = {
+        success: null,
+        failure: {
+            error: error.protocol,
+            peerId: error.peerId
+        }
+    };
+    if (error.response) {
+        result.requestId = error.response.requestId;
+        result.statusCode = error.response.statusCode;
+        result.statusDesc = error.response.statusDesc;
+        result.relayPeerCount = error.response.relayPeerCount;
+    }
+    return result;
+}
+function validateResponseSemantics(response, query, peerId) {
+    if (!isValidRequestId(response.requestId)) {
+        log$4.error("Invalid request ID format", { received: response.requestId });
+        throw new LightPushError(ProtocolError.DECODE_FAILED, peerId, response, "Invalid request ID format");
+    }
+    if (response.requestId !== query.query?.requestId &&
+        response.statusCode !== LightPushStatusCodeV3.TOO_MANY_REQUESTS) {
+        log$4.error("Request ID mismatch", {
+            sent: query.query?.requestId,
+            received: response.requestId
+        });
+        throw new LightPushError(ProtocolError.GENERIC_FAIL, peerId, response, "Request ID mismatch");
+    }
+    if (response.statusDesc && isRLNResponseError(response.statusDesc)) {
+        log$4.error("Remote peer fault: RLN generation");
+        throw new LightPushError(ProtocolError.RLN_PROOF_GENERATION, peerId, response, "RLN proof generation failed");
+    }
+}
+function ensureSuccessStatus(response, peerId) {
+    if (!isSuccessStatusCodeV3(response.statusCode)) {
+        const errorMessage = getLightPushStatusDescriptionV3(response.statusCode, response.statusDesc);
+        log$4.error("Remote peer rejected the message:", errorMessage);
+        const protocolError = lightPushStatusCodeToProtocolErrorV3(response.statusCode);
+        throw new LightPushError(protocolError, peerId, response, errorMessage);
+    }
+}
+function logResponseInfo(response) {
+    if (response.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`);
+    }
+}
+class LightPushCoreV3 extends BaseProtocol {
+    pubsubTopics;
+    constructor(pubsubTopics, libp2p) {
+        super(LightPushCodecV3, libp2p.components, pubsubTopics);
+        this.pubsubTopics = pubsubTopics;
+    }
+    async send(encoder, message, peerId) {
+        try {
+            const validated = await this.validateAndPrepareMessage(encoder, message, peerId);
+            const streamResponse = await this.executeRequest(validated, peerId);
+            const finalResponse = this.processResponse(streamResponse, peerId);
+            logResponseInfo(finalResponse);
+            return createSuccessResult(peerId, finalResponse);
+        }
+        catch (error) {
+            if (error instanceof LightPushError) {
+                return createFailureResult(error);
+            }
+            log$4.error("Unexpected error in send", error);
+            return createFailureResult(new LightPushError(ProtocolError.GENERIC_FAIL, peerId));
+        }
+    }
+    async validateAndPrepareMessage(encoder, message, peerId) {
+        const validationError = await validateMessage(message, encoder);
+        if (validationError) {
+            throw new LightPushError(validationError, peerId);
+        }
+        const protoMessage = await encoder.toProtoObj(message);
+        if (!protoMessage) {
+            log$4.error("Failed to encode to protoMessage, aborting push");
+            throw new LightPushError(ProtocolError.ENCODE_FAILED, peerId);
+        }
+        const query = PushRpcV3.createRequest(protoMessage, encoder.pubsubTopic);
+        return { protoMessage: protoMessage, query };
+    }
+    async executeRequest(validated, peerId) {
+        const stream = await this.acquireStream(peerId);
+        try {
+            const rawResponse = await this.sendAndReceive(validated.query, stream);
+            const response = this.decodeResponse(rawResponse, peerId);
+            return { response, query: validated.query };
+        }
+        finally {
+            void stream.close();
+        }
+    }
+    processResponse(streamResponse, peerId) {
+        const { response, query } = streamResponse;
+        validateResponseSemantics(response, query, peerId);
+        ensureSuccessStatus(response, peerId);
+        return response;
+    }
+    async acquireStream(peerId) {
+        try {
+            return await this.getStream(peerId);
+        }
+        catch (error) {
+            log$4.error("Failed to get stream", error);
+            throw new LightPushError(ProtocolError.NO_STREAM_AVAILABLE, peerId);
+        }
+    }
+    async sendAndReceive(query, stream) {
+        try {
+            return await withTimeout(pipe([query.encode()], encode, stream, decode, async (source) => await all(source)), STREAM_TIMEOUT_MS);
+        }
+        catch (err) {
+            log$4.error("Failed to send waku light push request", err);
+            throw new Error("Stream operation failed");
+        }
+    }
+    decodeResponse(rawResponse, peerId) {
+        const bytes = rawResponse.reduce((acc, chunk) => {
+            acc.append(chunk);
+            return acc;
+        }, new Uint8ArrayList());
+        try {
+            const response = LightpushResponse.decode(bytes);
+            if (!response) {
+                log$4.error("Remote peer fault: No response received");
+                throw new LightPushError(ProtocolError.NO_RESPONSE, peerId);
+            }
+            return response;
+        }
+        catch (err) {
+            if (err instanceof LightPushError) {
+                throw err;
+            }
+            log$4.error("Failed to decode push response", err);
+            throw new LightPushError(ProtocolError.DECODE_FAILED, peerId);
+        }
     }
 }
 
@@ -2708,7 +2970,7 @@ var index$1 = /*#__PURE__*/Object.freeze({
     __proto__: null,
     LightPushCodec: LightPushCodec,
     LightPushCore: LightPushCore,
-    get PushResponse () { return PushResponse; }
+    LightPushCoreV3: LightPushCoreV3
 });
 
 const EmptyMessage = {
@@ -4424,7 +4686,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 +5235,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, LightPushCore, 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-DEDdl6tx.js';
+import '../index-DckUzRoN.js';

package/bundle/lib/message/version_0.js

@@ -1,2 +1,2 @@
-export { D as DecodedMessage, z as Decoder, E as Encoder, V as Version, x as createDecoder, k as createEncoder, y as proto } from '../../version_0-CyeTW0Vr.js';
-import '../../index-CTo1my9M.js';
+export { D as DecodedMessage, z as Decoder, E as Encoder, V as Version, x as createDecoder, k as createEncoder, y as proto } from '../../version_0-DyRL7WVV.js';
+import '../../index-DckUzRoN.js';