@waku/core 0.0.36-b0a2e39.0 → 0.0.36-b4748fd.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, 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';
+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';
 
 /* eslint-disable */
 var encode_1 = encode$1;
@@ -2298,7 +2298,7 @@ class FilterSubscribeResponse {
     }
 }
 
-const log$7 = new Logger("filter:v2");
+const log$5 = 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$7.error("Previous FilterCore incoming message handler failed ", e);
+                    log$5.error("Previous FilterCore incoming message handler failed ", e);
                 }
                 try {
                     await handleIncomingMessage(pubsubTopic, message, peerIdStr);
                 }
                 catch (e) {
-                    log$7.error("Present FilterCore incoming message handler failed ", e);
+                    log$5.error("Present FilterCore incoming message handler failed ", e);
                 }
                 return;
             };
@@ -2333,7 +2333,7 @@ class FilterCore extends BaseProtocol {
             maxInboundStreams: 100
         })
             .catch((e) => {
-            log$7.error("Failed to register ", FilterCodecs.PUSH, e);
+            log$5.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$7.error("Failed to send subscribe request", error);
+            log$5.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$7.error(`Filter subscribe request ${requestId} failed with status code ${statusCode}: ${statusDesc}`);
+            log$5.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$7.error(`Failed to get a stream for remote peer${peerId.toString()}`, error);
+            log$5.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$7.error("Failed to send unsubscribe request", error);
+            log$5.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$7.error(`Filter unsubscribe all request ${requestId} failed with status code ${statusCode}: ${statusDesc}`);
+            log$5.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$7.error(`Failed to get a stream for remote peer${peerId.toString()}`, error);
+            log$5.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$7.error("Failed to send ping request", error);
+            log$5.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$7.error(`Filter ping request ${requestId} failed with status code ${statusCode}: ${statusDesc}`);
+            log$5.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$7.info(`Received message from ${remotePeer.toString()}`);
+        log$5.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$7.error("Received empty message");
+                        log$5.error("Received empty message");
                         return;
                     }
                     if (!pubsubTopic) {
-                        log$7.error("Pubsub topic missing from push message");
+                        log$5.error("Pubsub topic missing from push message");
                         return;
                     }
                     await FilterCore.handleIncomingMessage?.(pubsubTopic, wakuMessage, connection.remotePeer.toString());
                 }
             }).then(() => {
-                log$7.info("Receiving pipe closed.");
+                log$5.info("Receiving pipe closed.");
             }, async (e) => {
-                log$7.error(`Error with receiving pipe on peer:${connection.remotePeer.toString()} -- stream:${stream.id} -- protocol:${stream.protocol}: `, e);
+                log$5.error(`Error with receiving pipe on peer:${connection.remotePeer.toString()} -- stream:${stream.id} -- protocol:${stream.protocol}: `, e);
             });
         }
         catch (e) {
-            log$7.error("Error decoding message", e);
+            log$5.error("Error decoding message", e);
         }
     }
 }
@@ -2524,13 +2524,13 @@ var index$2 = /*#__PURE__*/Object.freeze({
     FilterCore: FilterCore
 });
 
-class PushRpcV2 {
+class PushRpc {
     proto;
     constructor(proto) {
         this.proto = proto;
     }
     static createRequest(message, pubsubTopic) {
-        return new PushRpcV2({
+        return new PushRpc({
             requestId: v4(),
             request: {
                 message: message,
@@ -2540,11 +2540,11 @@ class PushRpcV2 {
         });
     }
     static decode(bytes) {
-        const res = PushRpc.decode(bytes);
-        return new PushRpcV2(res);
+        const res = PushRpc$1.decode(bytes);
+        return new PushRpc(res);
     }
     encode() {
-        return PushRpc.encode(this.proto);
+        return PushRpc$1.encode(this.proto);
     }
     get query() {
         return this.proto.request;
@@ -2554,22 +2554,6 @@ class PushRpcV2 {
     }
 }
 
-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
@@ -2587,61 +2571,12 @@ const isRLNResponseError = (info) => {
         info.includes(RLN_MESSAGE_ID_PREFIX_ERROR) ||
         info.includes(RLN_REMOTE_VALIDATION));
 };
-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;
-}
-/**
- * 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 log$4 = new Logger("light-push");
 const LightPushCodec = "/vac/waku/lightpush/2.0.0-beta1";
+/**
+ * Implements the [Waku v2 Light Push protocol](https://rfc.vac.dev/spec/19/).
+ */
 class LightPushCore extends BaseProtocol {
     pubsubTopics;
     constructor(pubsubTopics, libp2p) {
@@ -2650,23 +2585,27 @@ class LightPushCore extends BaseProtocol {
     }
     async preparePushMessage(encoder, message) {
         try {
-            const validationError = await validateMessage(message, encoder);
-            if (validationError) {
-                return { query: null, error: validationError };
+            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 protoMessage = await encoder.toProtoObj(message);
             if (!protoMessage) {
-                log$5.error("Failed to encode to protoMessage, aborting push");
+                log$4.error("Failed to encode to protoMessage, aborting push");
                 return {
                     query: null,
                     error: ProtocolError.ENCODE_FAILED
                 };
             }
-            const query = PushRpcV2.createRequest(protoMessage, encoder.pubsubTopic);
+            const query = PushRpc.createRequest(protoMessage, encoder.pubsubTopic);
             return { query, error: null };
         }
         catch (error) {
-            log$5.error("Failed to prepare push message", error);
+            log$4.error("Failed to prepare push message", error);
             return {
                 query: null,
                 error: ProtocolError.GENERIC_FAIL
@@ -2689,7 +2628,7 @@ class LightPushCore extends BaseProtocol {
             stream = await this.getStream(peerId);
         }
         catch (error) {
-            log$5.error("Failed to get stream", error);
+            log$4.error("Failed to get stream", error);
             return {
                 success: null,
                 failure: {
@@ -2703,7 +2642,8 @@ class LightPushCore extends BaseProtocol {
             res = await pipe([query.encode()], encode, stream, decode, async (source) => await all(source));
         }
         catch (err) {
-            log$5.error("Failed to send waku light push request", err);
+            // can fail only because of `stream` abortion
+            log$4.error("Failed to send waku light push request", err);
             return {
                 success: null,
                 failure: {
@@ -2712,16 +2652,16 @@ class LightPushCore extends BaseProtocol {
                 }
             };
         }
-        const bytes = res.reduce((acc, chunk) => {
-            acc.append(chunk);
-            return acc;
-        }, new Uint8ArrayList());
+        const bytes = new Uint8ArrayList();
+        res.forEach((chunk) => {
+            bytes.append(chunk);
+        });
         let response;
         try {
-            response = PushRpcV2.decode(bytes).response;
+            response = PushRpc.decode(bytes).response;
         }
         catch (err) {
-            log$5.error("Failed to decode push reply", err);
+            log$4.error("Failed to decode push reply", err);
             return {
                 success: null,
                 failure: {
@@ -2731,7 +2671,7 @@ class LightPushCore extends BaseProtocol {
             };
         }
         if (!response) {
-            log$5.error("Remote peer fault: No response in PushRPC");
+            log$4.error("Remote peer fault: No response in PushRPC");
             return {
                 success: null,
                 failure: {
@@ -2740,229 +2680,27 @@ class LightPushCore extends BaseProtocol {
                 }
             };
         }
-        if (!response.isSuccess) {
-            const errorMessage = response.info || "Message rejected";
-            log$5.error("Remote peer rejected the message: ", errorMessage);
-            const error = mapInfoToProtocolError(response.info);
+        if (isRLNResponseError(response.info)) {
+            log$4.error("Remote peer fault: RLN generation");
             return {
                 success: null,
                 failure: {
-                    error: error,
+                    error: ProtocolError.RLN_PROOF_GENERATION,
                     peerId: peerId
                 }
             };
         }
-        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);
+        if (!response.isSuccess) {
+            log$4.error("Remote peer rejected the message: ", response.info);
+            return {
+                success: null,
+                failure: {
+                    error: ProtocolError.REMOTE_PEER_REJECTED,
+                    peerId: peerId
+                }
+            };
         }
+        return { success: peerId, failure: null };
     }
 }
 
@@ -2970,7 +2708,7 @@ var index$1 = /*#__PURE__*/Object.freeze({
     __proto__: null,
     LightPushCodec: LightPushCodec,
     LightPushCore: LightPushCore,
-    LightPushCoreV3: LightPushCoreV3
+    get PushResponse () { return PushResponse; }
 });
 
 const EmptyMessage = {
@@ -4686,7 +4424,7 @@ class ConnectionManager extends TypedEventEmitter {
      * // Dial using multiaddr with specific protocols
      * await connectionManager.dialPeer(multiaddr, [
      *   "/vac/waku/relay/2.0.0",
-     *   "/vac/waku/lightpush/3.0.0"
+     *   "/vac/waku/lightpush/2.0.0-beta1"
      * ]);
      * ```
      *
@@ -5235,4 +4973,4 @@ function messageHashStr(pubsubTopic, message) {
     return hashStr;
 }
 
-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 };
+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 };

package/bundle/lib/base_protocol.js

@@ -1,2 +1,2 @@
-export { B as BaseProtocol } from '../base_protocol-DEDdl6tx.js';
-import '../index-DckUzRoN.js';
+export { B as BaseProtocol } from '../base_protocol-DvQrudwy.js';
+import '../index-CTo1my9M.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-DyRL7WVV.js';
-import '../../index-DckUzRoN.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-CyeTW0Vr.js';
+import '../../index-CTo1my9M.js';