@waku/core 0.0.24 → 0.0.25

package/bundle/index.js

@@ -1,8 +1,9 @@
-import { c as coerce$1, e as equals$2, b as base32, a as base58btc, d as allocUnsafe, f as asUint8Array, t as toString$1, g as bases, h as fromString, u as utf8ToBytes$1, T as Tags, E as EPeersByDiscoveryEvents, P as Protocols, i as alloc, B as BaseProtocol, S as SendError, j as concat$1 } from './base_protocol-2a0c882e.js';
-export { k as StreamManager } from './base_protocol-2a0c882e.js';
-import { c as commonjsGlobal, g as getAugmentedNamespace, d as debug, a as getDefaultExportFromCjs } from './browser-90197c87.js';
-import { e as enumeration, m as message, a as encodeMessage, d as decodeMessage, c as createEncoder, v as version_0, M as MessagePush, F as FilterSubscribeRequest, b as FilterSubscribeResponse$1, D as DefaultPubSubTopic, P as PushRpc$1, f as PushResponse, H as HistoryRpc$1, g as PagingInfo, h as HistoryResponse } from './version_0-f4afd324.js';
-export { i as createDecoder } from './version_0-f4afd324.js';
+import { c as coerce$1, e as equals$2, b as base32, a as base58btc, d as allocUnsafe, f as asUint8Array, t as toString$1, g as bases, h as fromString, u as utf8ToBytes$1, T as Tags, E as EPeersByDiscoveryEvents, P as Protocols, i as alloc, B as BaseProtocol, S as SendError, j as concat$1 } from './base_protocol-4bcf7514.js';
+export { k as StreamManager } from './base_protocol-4bcf7514.js';
+import { L as Logger } from './index-27b91e3b.js';
+import { c as commonjsGlobal, g as getAugmentedNamespace, a as getDefaultExportFromCjs } from './browser-90197c87.js';
+import { e as enumeration, m as message, a as encodeMessage, d as decodeMessage, c as createEncoder, v as version_0, M as MessagePush, F as FilterSubscribeRequest, b as FilterSubscribeResponse$1, D as DefaultPubSubTopic, P as PushRpc$1, f as PushResponse, H as HistoryRpc$1, g as PagingInfo, h as HistoryResponse } from './version_0-2f1176e3.js';
+export { i as createDecoder } from './version_0-2f1176e3.js';
 
 const symbol$2 = Symbol.for('@libp2p/peer-id');
 function isPeerId(other) {
@@ -2099,6 +2100,100 @@ function multiaddr(addr) {
     return new DefaultMultiaddr(addr);
 }
 
+function isDefined(value) {
+    return Boolean(value);
+}
+
+function groupByContentTopic(values) {
+    const groupedDecoders = new Map();
+    values.forEach((value) => {
+        let decs = groupedDecoders.get(value.contentTopic);
+        if (!decs) {
+            groupedDecoders.set(value.contentTopic, []);
+            decs = groupedDecoders.get(value.contentTopic);
+        }
+        decs.push(value);
+    });
+    return groupedDecoders;
+}
+
+const FRAME_RATE = 60;
+/**
+ * Function that transforms IReceiver subscription to iterable stream of data.
+ * @param receiver - object that allows to be subscribed to;
+ * @param decoder - parameter to be passed to receiver for subscription;
+ * @param options - options for receiver for subscription;
+ * @param iteratorOptions - optional configuration for iterator;
+ * @returns iterator and stop function to terminate it.
+ */
+async function toAsyncIterator(receiver, decoder, iteratorOptions) {
+    const iteratorDelay = iteratorOptions?.iteratorDelay ?? FRAME_RATE;
+    const messages = [];
+    let unsubscribe;
+    unsubscribe = await receiver.subscribe(decoder, (message) => {
+        messages.push(message);
+    });
+    const isWithTimeout = Number.isInteger(iteratorOptions?.timeoutMs);
+    const timeoutMs = iteratorOptions?.timeoutMs ?? 0;
+    const startTime = Date.now();
+    async function* iterator() {
+        while (true) {
+            if (isWithTimeout && Date.now() - startTime >= timeoutMs) {
+                return;
+            }
+            await wait(iteratorDelay);
+            const message = messages.shift();
+            if (!unsubscribe && messages.length === 0) {
+                return message;
+            }
+            if (!message && unsubscribe) {
+                continue;
+            }
+            yield message;
+        }
+    }
+    return {
+        iterator: iterator(),
+        async stop() {
+            if (unsubscribe) {
+                await unsubscribe();
+                unsubscribe = undefined;
+            }
+        }
+    };
+}
+function wait(ms) {
+    return new Promise((resolve) => {
+        setTimeout(resolve, ms);
+    });
+}
+
+const MB = 1024 ** 2;
+const SIZE_CAP_IN_MB = 1;
+/**
+ * Return whether the size of the message is under the upper limit for the network.
+ * This performs a protobuf encoding! If you have access to the fully encoded message,
+ * use {@link isSizeUnderCapBuf} instead.
+ * @param message
+ * @param encoder
+ */
+async function isMessageSizeUnderCap(encoder, message) {
+    const buf = await encoder.toWire(message);
+    if (!buf)
+        return false;
+    return isWireSizeUnderCap(buf);
+}
+const isWireSizeUnderCap = (buf) => buf.length / MB <= SIZE_CAP_IN_MB;
+
+const shardInfoToPubSubTopics = (shardInfo) => {
+    return shardInfo.indexList.map((index) => `/waku/2/rs/${shardInfo.cluster}/${index}`);
+};
+function ensurePubsubTopicIsConfigured(pubsubTopic, configuredTopics) {
+    if (!configuredTopics.includes(pubsubTopic)) {
+        throw new Error(`PubSub topic ${pubsubTopic} has not been configured on this instance. Configured topics are: ${configuredTopics}. Please update your configuration by passing in the topic during Waku node instantiation.`);
+    }
+}
+
 /**
  * Adds types to the EventTarget class. Hopefully this won't be necessary forever.
  *
@@ -19848,7 +19943,7 @@ const decodeRelayShard = (bytes) => {
     return { cluster, indexList };
 };
 
-debug("waku:enr");
+new Logger("enr");
 var TransportProtocol;
 (function (TransportProtocol) {
     TransportProtocol["TCP"] = "tcp";
@@ -19862,94 +19957,10 @@ var TransportProtocolPerIpVersion;
     TransportProtocolPerIpVersion["UDP6"] = "udp6";
 })(TransportProtocolPerIpVersion || (TransportProtocolPerIpVersion = {}));
 
-function isDefined(value) {
-    return Boolean(value);
-}
-
-function groupByContentTopic(values) {
-    const groupedDecoders = new Map();
-    values.forEach((value) => {
-        let decs = groupedDecoders.get(value.contentTopic);
-        if (!decs) {
-            groupedDecoders.set(value.contentTopic, []);
-            decs = groupedDecoders.get(value.contentTopic);
-        }
-        decs.push(value);
-    });
-    return groupedDecoders;
-}
-
-const FRAME_RATE = 60;
-/**
- * Function that transforms IReceiver subscription to iterable stream of data.
- * @param receiver - object that allows to be subscribed to;
- * @param decoder - parameter to be passed to receiver for subscription;
- * @param options - options for receiver for subscription;
- * @param iteratorOptions - optional configuration for iterator;
- * @returns iterator and stop function to terminate it.
- */
-async function toAsyncIterator(receiver, decoder, iteratorOptions) {
-    const iteratorDelay = iteratorOptions?.iteratorDelay ?? FRAME_RATE;
-    const messages = [];
-    let unsubscribe;
-    unsubscribe = await receiver.subscribe(decoder, (message) => {
-        messages.push(message);
-    });
-    const isWithTimeout = Number.isInteger(iteratorOptions?.timeoutMs);
-    const timeoutMs = iteratorOptions?.timeoutMs ?? 0;
-    const startTime = Date.now();
-    async function* iterator() {
-        while (true) {
-            if (isWithTimeout && Date.now() - startTime >= timeoutMs) {
-                return;
-            }
-            await wait(iteratorDelay);
-            const message = messages.shift();
-            if (!unsubscribe && messages.length === 0) {
-                return message;
-            }
-            if (!message && unsubscribe) {
-                continue;
-            }
-            yield message;
-        }
-    }
-    return {
-        iterator: iterator(),
-        async stop() {
-            if (unsubscribe) {
-                await unsubscribe();
-                unsubscribe = undefined;
-            }
-        }
-    };
-}
-function wait(ms) {
-    return new Promise((resolve) => {
-        setTimeout(resolve, ms);
-    });
-}
-
-const MB = 1024 ** 2;
-const SIZE_CAP = 1; // 1 MB
-const isSizeValid = (payload) => {
-    if (payload.length / MB > SIZE_CAP) {
-        return false;
-    }
-    return true;
-};
-
-const shardInfoToPubSubTopics = (shardInfo) => {
-    return shardInfo.indexList.map((index) => `/waku/2/rs/${shardInfo.cluster}/${index}`);
-};
-function ensurePubsubTopicIsConfigured(pubsubTopic, configuredTopics) {
-    if (!configuredTopics.includes(pubsubTopic)) {
-        throw new Error(`PubSub topic ${pubsubTopic} has not been configured on this instance. Configured topics are: ${configuredTopics}. Please update your configuration by passing in the topic during Waku node instantiation.`);
-    }
-}
+new Logger("enr:decoder");
 
 const RelayPingContentTopic = "/relay-ping/1/ping/null";
-const log$6 = debug("waku:keep-alive");
+const log$6 = new Logger("keep-alive");
 class KeepAliveManager {
     pingKeepAliveTimers;
     relayKeepAliveTimers;
@@ -19977,10 +19988,10 @@ class KeepAliveManager {
                         // also update the peer store with the latency
                         try {
                             ping = await libp2pPing.ping(peerId);
-                            log$6(`Ping succeeded (${peerIdStr})`, ping);
+                            log$6.info(`Ping succeeded (${peerIdStr})`, ping);
                         }
                         catch (error) {
-                            log$6(`Ping failed for peer (${peerIdStr}).
+                            log$6.error(`Ping failed for peer (${peerIdStr}).
                 Next ping will be attempted in ${pingPeriodSecs} seconds.
               `);
                             return;
@@ -19993,11 +20004,11 @@ class KeepAliveManager {
                             });
                         }
                         catch (e) {
-                            log$6("Failed to update ping", e);
+                            log$6.error("Failed to update ping", e);
                         }
                     }
                     catch (e) {
-                        log$6(`Ping failed (${peerIdStr})`, e);
+                        log$6.error(`Ping failed (${peerIdStr})`, e);
                     }
                 })();
             }, pingPeriodSecs * 1000);
@@ -20043,10 +20054,10 @@ class KeepAliveManager {
                 ephemeral: true
             });
             const interval = setInterval(() => {
-                log$6("Sending Waku Relay ping message");
+                log$6.info("Sending Waku Relay ping message");
                 relay
                     .send(encoder, { payload: new Uint8Array([1]) })
-                    .catch((e) => log$6("Failed to send relay ping", e));
+                    .catch((e) => log$6.error("Failed to send relay ping", e));
             }, relayPeriodSecs * 1000);
             intervals.push(interval);
         }
@@ -20054,7 +20065,7 @@ class KeepAliveManager {
     }
 }
 
-const log$5 = debug("waku:connection-manager");
+const log$5 = new Logger("connection-manager");
 const DEFAULT_MAX_BOOTSTRAP_PEERS_ALLOWED = 1;
 const DEFAULT_MAX_DIAL_ATTEMPTS_FOR_PEER = 3;
 const DEFAULT_MAX_PARALLEL_DIALS = 3;
@@ -20066,7 +20077,7 @@ class ConnectionManager extends EventEmitter {
     libp2p;
     dialAttemptsForPeer = new Map();
     dialErrorsForPeer = new Map();
-    currentActiveDialCount = 0;
+    currentActiveParallelDialCount = 0;
     pendingPeerDialQueue = [];
     static create(peerId, libp2p, keepAliveOptions, pubsubTopics, relay, options) {
         let instance = ConnectionManager.instances.get(peerId);
@@ -20128,12 +20139,12 @@ class ConnectionManager extends EventEmitter {
         };
         this.keepAliveManager = new KeepAliveManager(keepAliveOptions, relay);
         this.run()
-            .then(() => log$5(`Connection Manager is now running`))
-            .catch((error) => log$5(`Unexpected error while running service`, error));
+            .then(() => log$5.info(`Connection Manager is now running`))
+            .catch((error) => log$5.error(`Unexpected error while running service`, error));
         // libp2p emits `peer:discovery` events during its initialization
         // which means that before the ConnectionManager is initialized, some peers may have been discovered
         // we will dial the peers in peerStore ONCE before we start to listen to the `peer:discovery` events within the ConnectionManager
-        this.dialPeerStorePeers().catch((error) => log$5(`Unexpected error while dialing peer store peers`, error));
+        this.dialPeerStorePeers().catch((error) => log$5.error(`Unexpected error while dialing peer store peers`, error));
     }
     async dialPeerStorePeers() {
         const peerInfos = await this.libp2p.peerStore.all();
@@ -20147,7 +20158,7 @@ class ConnectionManager extends EventEmitter {
             await Promise.all(dialPromises);
         }
         catch (error) {
-            log$5(`Unexpected error while dialing peer store peers`, error);
+            log$5.error(`Unexpected error while dialing peer store peers`, error);
         }
     }
     async run() {
@@ -20163,11 +20174,11 @@ class ConnectionManager extends EventEmitter {
         this.libp2p.removeEventListener("peer:discovery", this.onEventHandlers["peer:discovery"]);
     }
     async dialPeer(peerId) {
-        this.currentActiveDialCount += 1;
+        this.currentActiveParallelDialCount += 1;
         let dialAttempt = 0;
         while (dialAttempt < this.options.maxDialAttemptsForPeer) {
             try {
-                log$5(`Dialing peer ${peerId.toString()} on attempt ${dialAttempt + 1}`);
+                log$5.info(`Dialing peer ${peerId.toString()} on attempt ${dialAttempt + 1}`);
                 await this.libp2p.dial(peerId);
                 const tags = await this.getTagNamesForPeer(peerId);
                 // add tag to connection describing discovery mechanism
@@ -20175,18 +20186,20 @@ class ConnectionManager extends EventEmitter {
                 this.libp2p.getConnections(peerId).forEach((conn) => {
                     conn.tags = Array.from(new Set([...conn.tags, ...tags]));
                 });
-                this.dialAttemptsForPeer.delete(peerId.toString());
+                // instead of deleting the peer from the peer store, we set the dial attempt to -1
+                // this helps us keep track of peers that have been dialed before
+                this.dialAttemptsForPeer.set(peerId.toString(), -1);
                 // Dialing succeeded, break the loop
                 break;
             }
             catch (error) {
                 if (error instanceof AggregateError) {
                     // Handle AggregateError
-                    log$5(`Error dialing peer ${peerId.toString()} - ${error.errors}`);
+                    log$5.error(`Error dialing peer ${peerId.toString()} - ${error.errors}`);
                 }
                 else {
                     // Handle generic error
-                    log$5(`Error dialing peer ${peerId.toString()} - ${error.message}`);
+                    log$5.error(`Error dialing peer ${peerId.toString()} - ${error.message}`);
                 }
                 this.dialErrorsForPeer.set(peerId.toString(), error);
                 dialAttempt++;
@@ -20194,7 +20207,7 @@ class ConnectionManager extends EventEmitter {
             }
         }
         // Always decrease the active dial count and process the dial queue
-        this.currentActiveDialCount--;
+        this.currentActiveParallelDialCount--;
         this.processDialQueue();
         // If max dial attempts reached and dialing failed, delete the peer
         if (dialAttempt === this.options.maxDialAttemptsForPeer) {
@@ -20204,10 +20217,10 @@ class ConnectionManager extends EventEmitter {
                     let errorMessage;
                     if (error instanceof AggregateError) {
                         if (!error.errors) {
-                            log$5(`No errors array found for AggregateError`);
+                            log$5.warn(`No errors array found for AggregateError`);
                         }
                         else if (error.errors.length === 0) {
-                            log$5(`Errors array is empty for AggregateError`);
+                            log$5.warn(`Errors array is empty for AggregateError`);
                         }
                         else {
                             errorMessage = JSON.stringify(error.errors[0]);
@@ -20216,7 +20229,7 @@ class ConnectionManager extends EventEmitter {
                     else {
                         errorMessage = error.message;
                     }
-                    log$5(`Deleting undialable peer ${peerId.toString()} from peer store. Error: ${errorMessage}`);
+                    log$5.info(`Deleting undialable peer ${peerId.toString()} from peer store. Reason: ${errorMessage}`);
                 }
                 this.dialErrorsForPeer.delete(peerId.toString());
                 await this.libp2p.peerStore.delete(peerId);
@@ -20230,20 +20243,20 @@ class ConnectionManager extends EventEmitter {
         try {
             this.keepAliveManager.stop(peerId);
             await this.libp2p.hangUp(peerId);
-            log$5(`Dropped connection with peer ${peerId.toString()}`);
+            log$5.info(`Dropped connection with peer ${peerId.toString()}`);
         }
         catch (error) {
-            log$5(`Error dropping connection with peer ${peerId.toString()} - ${error}`);
+            log$5.error(`Error dropping connection with peer ${peerId.toString()} - ${error}`);
         }
     }
     processDialQueue() {
         if (this.pendingPeerDialQueue.length > 0 &&
-            this.currentActiveDialCount < this.options.maxParallelDials) {
+            this.currentActiveParallelDialCount < this.options.maxParallelDials) {
             const peerId = this.pendingPeerDialQueue.shift();
             if (!peerId)
                 return;
             this.attemptDial(peerId).catch((error) => {
-                log$5(error);
+                log$5.error(error);
             });
         }
     }
@@ -20271,12 +20284,12 @@ class ConnectionManager extends EventEmitter {
     async attemptDial(peerId) {
         if (!(await this.shouldDialPeer(peerId)))
             return;
-        if (this.currentActiveDialCount >= this.options.maxParallelDials) {
+        if (this.currentActiveParallelDialCount >= this.options.maxParallelDials) {
             this.pendingPeerDialQueue.push(peerId);
             return;
         }
         this.dialPeer(peerId).catch((err) => {
-            log$5(`Error dialing peer ${peerId.toString()} : ${err}`);
+            log$5.error(`Error dialing peer ${peerId.toString()} : ${err}`);
         });
     }
     onEventHandlers = {
@@ -20288,7 +20301,7 @@ class ConnectionManager extends EventEmitter {
                     await this.attemptDial(peerId);
                 }
                 catch (error) {
-                    log$5(`Error dialing peer ${peerId.toString()} : ${error}`);
+                    log$5.error(`Error dialing peer ${peerId.toString()} : ${error}`);
                 }
             })();
         },
@@ -20329,25 +20342,31 @@ class ConnectionManager extends EventEmitter {
      * 1. If the peer is already connected, don't dial
      * 2. If the peer is not part of any of the configured pubsub topics, don't dial
      * 3. If the peer is not dialable based on bootstrap status, don't dial
+     * 4. If the peer is already has an active dial attempt, or has been dialed before, don't dial it
      * @returns true if the peer should be dialed, false otherwise
      */
     async shouldDialPeer(peerId) {
         // if we're already connected to the peer, don't dial
         const isConnected = this.libp2p.getConnections(peerId).length > 0;
         if (isConnected) {
-            log$5(`Already connected to peer ${peerId.toString()}. Not dialing.`);
+            log$5.warn(`Already connected to peer ${peerId.toString()}. Not dialing.`);
             return false;
         }
         // if the peer is not part of any of the configured pubsub topics, don't dial
         if (!(await this.isPeerTopicConfigured(peerId))) {
             const shardInfo = await this.getPeerShardInfo(peerId, this.libp2p.peerStore);
-            log$5(`Discovered peer ${peerId.toString()} with ShardInfo ${shardInfo} is not part of any of the configured pubsub topics (${this.configuredPubSubTopics}). 
+            log$5.warn(`Discovered peer ${peerId.toString()} with ShardInfo ${shardInfo} is not part of any of the configured pubsub topics (${this.configuredPubSubTopics}). 
             Not dialing.`);
             return false;
         }
         // if the peer is not dialable based on bootstrap status, don't dial
         if (!(await this.isPeerDialableBasedOnBootstrapStatus(peerId))) {
-            log$5(`Peer ${peerId.toString()} is not dialable based on bootstrap status. Not dialing.`);
+            log$5.warn(`Peer ${peerId.toString()} is not dialable based on bootstrap status. Not dialing.`);
+            return false;
+        }
+        // If the peer is already already has an active dial attempt, or has been dialed before, don't dial it
+        if (this.dialAttemptsForPeer.has(peerId.toString())) {
+            log$5.warn(`Peer ${peerId.toString()} has already been attempted dial before, or already has a dial attempt in progress, skipping dial`);
             return false;
         }
         return true;
@@ -20391,7 +20410,7 @@ class ConnectionManager extends EventEmitter {
             return Array.from(peer.tags.keys());
         }
         catch (error) {
-            log$5(`Failed to get peer ${peerId}, error: ${error}`);
+            log$5.error(`Failed to get peer ${peerId}, error: ${error}`);
             return [];
         }
     }
@@ -20416,7 +20435,7 @@ class ConnectionManager extends EventEmitter {
 const DefaultPingKeepAliveValueSecs = 5 * 60;
 const DefaultRelayKeepAliveValueSecs = 5 * 60;
 const DefaultUserAgent = "js-waku";
-const log$4 = debug("waku:waku");
+const log$4 = new Logger("waku");
 class WakuNode {
     pubsubTopics;
     libp2p;
@@ -20446,7 +20465,7 @@ class WakuNode {
             : 0;
         const peerId = this.libp2p.peerId.toString();
         this.connectionManager = ConnectionManager.create(peerId, libp2p, { pingKeepAlive, relayKeepAlive }, pubsubTopics, this.relay);
-        log$4("Waku node created", peerId, `relay: ${!!this.relay}, store: ${!!this.store}, light push: ${!!this
+        log$4.info("Waku node created", peerId, `relay: ${!!this.relay}, store: ${!!this.store}, light push: ${!!this
             .lightPush}, filter: ${!!this.filter}`);
     }
     /**
@@ -20470,7 +20489,7 @@ class WakuNode {
                 this.relay.gossipSub.multicodecs.forEach((codec) => codecs.push(codec));
             }
             else {
-                log$4("Relay codec not included in dial codec: protocol not mounted locally");
+                log$4.error("Relay codec not included in dial codec: protocol not mounted locally");
             }
         }
         if (_protocols.includes(Protocols.Store)) {
@@ -20478,7 +20497,7 @@ class WakuNode {
                 codecs.push(this.store.multicodec);
             }
             else {
-                log$4("Store codec not included in dial codec: protocol not mounted locally");
+                log$4.error("Store codec not included in dial codec: protocol not mounted locally");
             }
         }
         if (_protocols.includes(Protocols.LightPush)) {
@@ -20486,7 +20505,7 @@ class WakuNode {
                 codecs.push(this.lightPush.multicodec);
             }
             else {
-                log$4("Light Push codec not included in dial codec: protocol not mounted locally");
+                log$4.error("Light Push codec not included in dial codec: protocol not mounted locally");
             }
         }
         if (_protocols.includes(Protocols.Filter)) {
@@ -20494,10 +20513,10 @@ class WakuNode {
                 codecs.push(this.filter.multicodec);
             }
             else {
-                log$4("Filter codec not included in dial codec: protocol not mounted locally");
+                log$4.error("Filter codec not included in dial codec: protocol not mounted locally");
             }
         }
-        log$4(`Dialing to ${peerId.toString()} with protocols ${_protocols}`);
+        log$4.info(`Dialing to ${peerId.toString()} with protocols ${_protocols}`);
         return this.libp2p.dialProtocol(peerId, codecs);
     }
     async start() {
@@ -21919,7 +21938,7 @@ class FilterSubscribeResponse {
     }
 }
 
-const log$3 = debug("waku:filter:v2");
+const log$3 = new Logger("filter:v2");
 const FilterCodecs = {
     SUBSCRIBE: "/vac/waku/filter-subscribe/2.0.0-beta1",
     PUSH: "/vac/waku/filter-push/2.0.0-beta1"
@@ -21937,6 +21956,12 @@ class Subscription {
     }
     async subscribe(decoders, callback) {
         const decodersArray = Array.isArray(decoders) ? decoders : [decoders];
+        // check that all decoders are configured for the same pubsub topic as this subscription
+        decodersArray.forEach((decoder) => {
+            if (decoder.pubsubTopic !== this.pubsubTopic) {
+                throw new Error(`Pubsub topic not configured: decoder is configured for pubsub topic ${decoder.pubsubTopic} but this subscription is for pubsub topic ${this.pubsubTopic}. Please create a new Subscription for the different pubsub topic.`);
+            }
+        });
         const decodersGroupedByCT = groupByContentTopic(decodersArray);
         const contentTopics = Array.from(decodersGroupedByCT.keys());
         const stream = await this.newStream(this.peer);
@@ -21950,7 +21975,7 @@ class Subscription {
             if (statusCode < 200 || statusCode >= 300) {
                 throw new Error(`Filter subscribe request ${requestId} failed with status code ${statusCode}: ${statusDesc}`);
             }
-            log$3("Subscribed to peer ", this.peer.id.toString(), "for content topics", contentTopics);
+            log$3.info("Subscribed to peer ", this.peer.id.toString(), "for content topics", contentTopics);
         }
         catch (e) {
             throw new Error("Error subscribing to peer: " +
@@ -21993,14 +22018,17 @@ class Subscription {
         const request = FilterSubscribeRpc.createSubscriberPingRequest();
         try {
             const res = await pipe([request.encode()], encode, stream, decode, async (source) => await all(source));
+            if (!res || !res.length) {
+                throw Error(`No response received for request ${request.requestId}: ${res}`);
+            }
             const { statusCode, requestId, statusDesc } = FilterSubscribeResponse.decode(res[0].slice());
             if (statusCode < 200 || statusCode >= 300) {
                 throw new Error(`Filter ping request ${requestId} failed with status code ${statusCode}: ${statusDesc}`);
             }
-            log$3("Ping successful");
+            log$3.info("Ping successful");
         }
         catch (error) {
-            log$3("Error pinging: ", error);
+            log$3.error("Error pinging: ", error);
             throw new Error("Error pinging: " + error);
         }
     }
@@ -22009,12 +22037,15 @@ class Subscription {
         const request = FilterSubscribeRpc.createUnsubscribeAllRequest(this.pubsubTopic);
         try {
             const res = await pipe([request.encode()], encode, stream, decode, async (source) => await all(source));
+            if (!res || !res.length) {
+                throw Error(`No response received for request ${request.requestId}: ${res}`);
+            }
             const { statusCode, requestId, statusDesc } = FilterSubscribeResponse.decode(res[0].slice());
             if (statusCode < 200 || statusCode >= 300) {
                 throw new Error(`Filter unsubscribe all request ${requestId} failed with status code ${statusCode}: ${statusDesc}`);
             }
             this.subscriptionCallbacks.clear();
-            log$3("Unsubscribed from all content topics");
+            log$3.info("Unsubscribed from all content topics");
         }
         catch (error) {
             throw new Error("Error unsubscribing from all content topics: " + error);
@@ -22024,7 +22055,7 @@ class Subscription {
         const contentTopic = message.contentTopic;
         const subscriptionCallback = this.subscriptionCallbacks.get(contentTopic);
         if (!subscriptionCallback) {
-            log$3("No subscription callback available for ", contentTopic);
+            log$3.error("No subscription callback available for ", contentTopic);
             return;
         }
         await pushMessage(subscriptionCallback, this.pubsubTopic, message);
@@ -22045,7 +22076,7 @@ class Filter extends BaseProtocol {
         super(FilterCodecs.SUBSCRIBE, libp2p.components);
         this.pubsubTopics = options?.pubsubTopics || [DefaultPubSubTopic];
         libp2p.handle(FilterCodecs.PUSH, this.onRequest.bind(this)).catch((e) => {
-            log$3("Failed to register ", FilterCodecs.PUSH, e);
+            log$3.error("Failed to register ", FilterCodecs.PUSH, e);
         });
         this.activeSubscriptions = new Map();
     }
@@ -22088,36 +22119,35 @@ class Filter extends BaseProtocol {
         };
     }
     onRequest(streamData) {
-        log$3("Receiving message push");
         try {
             pipe(streamData.stream, decode, async (source) => {
                 for await (const bytes of source) {
                     const response = FilterPushRpc.decode(bytes.slice());
                     const { pubsubTopic, wakuMessage } = response;
                     if (!wakuMessage) {
-                        log$3("Received empty message");
+                        log$3.error("Received empty message");
                         return;
                     }
                     if (!pubsubTopic) {
-                        log$3("PubSub topic missing from push message");
+                        log$3.error("PubSub topic missing from push message");
                         return;
                     }
                     const peerIdStr = streamData.connection.remotePeer.toString();
                     const subscription = this.getActiveSubscription(pubsubTopic, peerIdStr);
                     if (!subscription) {
-                        log$3(`No subscription locally registered for topic ${pubsubTopic}`);
+                        log$3.error(`No subscription locally registered for topic ${pubsubTopic}`);
                         return;
                     }
                     await subscription.processMessage(wakuMessage);
                 }
             }).then(() => {
-                log$3("Receiving pipe closed.");
+                log$3.info("Receiving pipe closed.");
             }, (e) => {
-                log$3("Error with receiving pipe", e);
+                log$3.error("Error with receiving pipe", e);
             });
         }
         catch (e) {
-            log$3("Error decoding message", e);
+            log$3.error("Error decoding message", e);
         }
     }
 }
@@ -22128,7 +22158,7 @@ async function pushMessage(subscriptionCallback, pubsubTopic, message) {
     const { decoders, callback } = subscriptionCallback;
     const { contentTopic } = message;
     if (!contentTopic) {
-        log$3("Message has no content topic, skipping");
+        log$3.warn("Message has no content topic, skipping");
         return;
     }
     try {
@@ -22139,7 +22169,7 @@ async function pushMessage(subscriptionCallback, pubsubTopic, message) {
         await callback(decodedMessage);
     }
     catch (e) {
-        log$3("Error decoding message", e);
+        log$3.error("Error decoding message", e);
     }
 }
 
@@ -22179,7 +22209,7 @@ class PushRpc {
     }
 }
 
-const log$2 = debug("waku:light-push");
+const log$2 = 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/).
@@ -22193,13 +22223,17 @@ class LightPush extends BaseProtocol {
     }
     async preparePushMessage(encoder, message, pubsubTopic) {
         try {
-            if (!isSizeValid(message.payload)) {
-                log$2("Failed to send waku light push: message is bigger than 1MB");
+            if (!message.payload || message.payload.length === 0) {
+                log$2.error("Failed to send waku light push: payload is empty");
+                return { query: null, error: SendError.EMPTY_PAYLOAD };
+            }
+            if (!(await isMessageSizeUnderCap(encoder, message))) {
+                log$2.error("Failed to send waku light push: message is bigger than 1MB");
                 return { query: null, error: SendError.SIZE_TOO_BIG };
             }
             const protoMessage = await encoder.toProtoObj(message);
             if (!protoMessage) {
-                log$2("Failed to encode to protoMessage, aborting push");
+                log$2.error("Failed to encode to protoMessage, aborting push");
                 return {
                     query: null,
                     error: SendError.ENCODE_FAILED
@@ -22209,7 +22243,7 @@ class LightPush extends BaseProtocol {
             return { query, error: null };
         }
         catch (error) {
-            log$2("Failed to prepare push message", error);
+            log$2.error("Failed to prepare push message", error);
             return {
                 query: null,
                 error: SendError.GENERIC_FAIL
@@ -22244,7 +22278,7 @@ class LightPush extends BaseProtocol {
                 stream = await this.getStream(peer);
             }
             catch (err) {
-                log$2(`Failed to get a stream for remote peer${peer.id.toString()}`, err);
+                log$2.error(`Failed to get a stream for remote peer${peer.id.toString()}`, err);
                 return { recipients, error: SendError.REMOTE_PEER_FAULT };
             }
             let res;
@@ -22252,7 +22286,7 @@ class LightPush extends BaseProtocol {
                 res = await pipe([query.encode()], encode, stream, decode, async (source) => await all(source));
             }
             catch (err) {
-                log$2("Failed to send waku light push request", err);
+                log$2.error("Failed to send waku light push request", err);
                 return { recipients, error: SendError.GENERIC_FAIL };
             }
             const bytes = new Uint8ArrayList();
@@ -22264,15 +22298,15 @@ class LightPush extends BaseProtocol {
                 response = PushRpc.decode(bytes).response;
             }
             catch (err) {
-                log$2("Failed to decode push reply", err);
+                log$2.error("Failed to decode push reply", err);
                 return { recipients, error: SendError.DECODE_FAILED };
             }
             if (!response) {
-                log$2("Remote peer fault: No response in PushRPC");
+                log$2.error("Remote peer fault: No response in PushRPC");
                 return { recipients, error: SendError.REMOTE_PEER_FAULT };
             }
             if (!response.isSuccess) {
-                log$2("Remote peer rejected the message: ", response.info);
+                log$2.error("Remote peer rejected the message: ", response.info);
                 return { recipients, error: SendError.REMOTE_PEER_REJECTED };
             }
             recipients.some((recipient) => recipient.equals(peer.id)) ||
@@ -22678,7 +22712,7 @@ function directionToProto(pageDirection) {
 }
 
 var HistoryError = HistoryResponse.HistoryError;
-const log$1 = debug("waku:store");
+const log$1 = new Logger("store");
 const StoreCodec = "/vac/waku/store/2.0.0-beta4";
 const DefaultPageSize = 10;
 /**
@@ -22841,7 +22875,6 @@ class Store extends BaseProtocol {
             pageDirection: PageDirection.BACKWARD,
             pageSize: DefaultPageSize
         }, options, { contentTopics, startTime, endTime });
-        log$1("Querying history with the following options", options);
         const peer = (await this.getPeers({
             numPeers: this.NUM_PEERS_PROTOCOL,
             maxBootstrapPeers: 1
@@ -22860,7 +22893,7 @@ async function* paginate(streamFactory, queryOpts, decoders, cursor) {
     while (true) {
         queryOpts.cursor = currentCursor;
         const historyRpcQuery = HistoryRpc.createQuery(queryOpts);
-        log$1("Querying store peer", `for (${queryOpts.pubsubTopic})`, queryOpts.contentTopics);
+        log$1.info("Querying store peer", `for (${queryOpts.pubsubTopic})`, queryOpts.contentTopics);
         const stream = await streamFactory();
         const res = await pipe([historyRpcQuery.encode()], encode, stream, decode, async (source) => await all(source));
         const bytes = new Uint8ArrayList();
@@ -22869,7 +22902,7 @@ async function* paginate(streamFactory, queryOpts, decoders, cursor) {
         });
         const reply = historyRpcQuery.decode(bytes);
         if (!reply.response) {
-            log$1("Stopping pagination due to store `response` field missing");
+            log$1.warn("Stopping pagination due to store `response` field missing");
             break;
         }
         const response = reply.response;
@@ -22877,10 +22910,10 @@ async function* paginate(streamFactory, queryOpts, decoders, cursor) {
             throw "History response contains an Error: " + response.error;
         }
         if (!response.messages || !response.messages.length) {
-            log$1("Stopping pagination due to store `response.messages` field missing or empty");
+            log$1.warn("Stopping pagination due to store `response.messages` field missing or empty");
             break;
         }
-        log$1(`${response.messages.length} messages retrieved from store`);
+        log$1.error(`${response.messages.length} messages retrieved from store`);
         yield response.messages.map((protoMsg) => {
             const contentTopic = protoMsg.contentTopic;
             if (typeof contentTopic !== "undefined") {
@@ -22895,7 +22928,7 @@ async function* paginate(streamFactory, queryOpts, decoders, cursor) {
         if (typeof nextCursor === "undefined") {
             // If the server does not return cursor then there is an issue,
             // Need to abort, or we end up in an infinite loop
-            log$1("Stopping pagination due to `response.pagingInfo.cursor` missing from store response");
+            log$1.warn("Stopping pagination due to `response.pagingInfo.cursor` missing from store response");
             break;
         }
         currentCursor = nextCursor;
@@ -23172,7 +23205,7 @@ function pEvent(emitter, event, options) {
 	return promise;
 }
 
-const log = debug("waku:wait-for-remote-peer");
+const log = new Logger("wait-for-remote-peer");
 /**
  * Wait for a remote peer to be ready given the passed protocols.
  * Must be used after attempting to connect to nodes, using
@@ -23231,13 +23264,12 @@ async function waitForConnectedPeer(protocol) {
     const codec = protocol.multicodec;
     const peers = await protocol.peers();
     if (peers.length) {
-        log(`${codec} peer found: `, peers[0].id.toString());
+        log.info(`${codec} peer found: `, peers[0].id.toString());
         return;
     }
     await new Promise((resolve) => {
         const cb = (evt) => {
             if (evt.detail?.protocols?.includes(codec)) {
-                log("Resolving for", codec, evt.detail.protocols);
                 protocol.removeLibp2pEventListener("peer:identify", cb);
                 resolve();
             }