@peerbit/pubsub 1.1.12 → 2.0.1

package/lib/esm/index.js

@@ -1,13 +1,12 @@
 import { logger as logFn } from "@peerbit/logger";
-import { DataMessage } from "@peerbit/stream-interface";
+import { AcknowledgeDelivery, AnyWhere, DataMessage, MessageHeader, SeekDelivery, SilentDelivery } from "@peerbit/stream-interface";
 import { DirectStream } from "@peerbit/stream";
-import { CodeError } from "@libp2p/interface/errors";
-import { PubSubMessage, Subscribe, PubSubData, toUint8Array, Unsubscribe, GetSubscribers, Subscription, UnsubcriptionEvent, SubscriptionEvent, DataEvent, SubscriptionData } from "@peerbit/pubsub-interface";
+import { CodeError } from "@libp2p/interface";
+import { PubSubMessage, Subscribe, PubSubData, toUint8Array, Unsubscribe, GetSubscribers, UnsubcriptionEvent, SubscriptionEvent, DataEvent, SubscriptionData, PublishEvent } from "@peerbit/pubsub-interface";
 import { getPublicKeyFromPeerId, PublicSignKey } from "@peerbit/crypto";
-import { CustomEvent } from "@libp2p/interface/events";
-import { waitFor } from "@peerbit/time";
-import { equals, startsWith } from "@peerbit/uint8arrays";
-export const logger = logFn({ module: "direct-sub", level: "warn" });
+import { CustomEvent } from "@libp2p/interface";
+export const logger = logFn({ module: "lazysub", level: "warn" });
+const logError = (e) => logger.error(e?.message);
 export class DirectSub extends DirectStream {
     topics; // topic -> peers --> Uint8Array subscription metadata (the latest received)
     peerToTopic; // peer -> topics
@@ -15,7 +14,7 @@ export class DirectSub extends DirectStream {
     subscriptions; // topic -> subscription ids
     lastSubscriptionMessages = new Map();
     constructor(components, props) {
-        super(components, ["pubsub/0.0.0"], props);
+        super(components, ["/lazysub/0.0.0"], props);
         this.subscriptions = new Map();
         this.topics = new Map();
         this.topicsToPeers = new Map();
@@ -28,15 +27,6 @@ export class DirectSub extends DirectStream {
         this.topicsToPeers.clear();
         return super.stop();
     }
-    async onPeerReachable(publicKey) {
-        // Aggregate subscribers for my topics through this new peer because if we don't do this we might end up with a situtation where
-        // we act as a relay and relay messages for a topic, but don't forward it to this new peer because we never learned about their subscriptions
-        await this.requestSubscribers([...this.topics.keys()], publicKey);
-        return super.onPeerReachable(publicKey);
-    }
-    async onPeerDisconnected(peerId, conn) {
-        return super.onPeerDisconnected(peerId, conn);
-    }
     initializeTopic(topic) {
         this.topics.get(topic) || this.topics.set(topic, new Map());
         this.topicsToPeers.get(topic) || this.topicsToPeers.set(topic, new Set());
@@ -48,43 +38,30 @@ export class DirectSub extends DirectStream {
     /**
      * Subscribes to a given topic.
      */
-    /**
-     * @param topic,
-     * @param data, metadata associated with the subscription, shared with peers
-     */
-    async subscribe(topic, options) {
+    async subscribe(topic) {
         if (!this.started) {
             throw new Error("Pubsub has not started");
         }
-        topic = typeof topic === "string" ? [topic] : topic;
         const newTopicsForTopicData = [];
-        for (const t of topic) {
-            const prev = this.subscriptions.get(t);
-            if (prev) {
-                const difference = !!prev.data != !!options?.data ||
-                    (prev.data && options?.data && !equals(prev.data, options?.data));
-                prev.counter += 1;
-                if (difference) {
-                    prev.data = options?.data;
-                    newTopicsForTopicData.push(t);
-                }
-            }
-            else {
-                this.subscriptions.set(t, {
-                    counter: 1,
-                    data: options?.data
-                });
-                newTopicsForTopicData.push(t);
-                this.listenForSubscribers(t);
-            }
+        const prev = this.subscriptions.get(topic);
+        if (prev) {
+            prev.counter += 1;
+        }
+        else {
+            this.subscriptions.set(topic, {
+                counter: 1
+            });
+            newTopicsForTopicData.push(topic);
+            this.listenForSubscribers(topic);
         }
         if (newTopicsForTopicData.length > 0) {
             const message = new DataMessage({
                 data: toUint8Array(new Subscribe({
-                    subscriptions: newTopicsForTopicData.map((x) => new Subscription(x, options?.data))
-                }).bytes())
+                    topics: newTopicsForTopicData
+                }).bytes()),
+                header: new MessageHeader({ mode: new SeekDelivery({ redundancy: 2 }) })
             });
-            await this.publishMessage(this.components.peerId, await message.sign(this.sign));
+            await this.publishMessage(this.publicKey, await message.sign(this.sign));
         }
     }
     /**
@@ -109,53 +86,40 @@ export class DirectSub extends DirectStream {
             }
         }
         if (!subscriptions?.counter || options?.force) {
+            await this.publishMessage(this.publicKey, await new DataMessage({
+                header: new MessageHeader({
+                    mode: new AnyWhere( /* {
+                        redundancy: 2,
+                        to: [...this.getPeersOnTopics([topic])]
+                    } */)
+                }),
+                data: toUint8Array(new Unsubscribe({ topics: [topic] }).bytes())
+            }).sign(this.sign));
             this.subscriptions.delete(topic);
             this.topics.delete(topic);
             this.topicsToPeers.delete(topic);
-            await this.publishMessage(this.components.peerId, await new DataMessage({
-                data: toUint8Array(new Unsubscribe({ topics: [topic] }).bytes())
-            }).sign(this.sign));
             return true;
         }
         return false;
     }
     getSubscribers(topic) {
-        if (!this.started) {
-            throw new CodeError("not started yet", "ERR_NOT_STARTED_YET");
+        const remote = this.topics.get(topic.toString());
+        if (!remote) {
+            return undefined;
         }
-        if (topic == null) {
-            throw new CodeError("topic is required", "ERR_NOT_VALID_TOPIC");
+        const ret = [];
+        for (const v of remote.values()) {
+            ret.push(v.publicKey);
         }
-        return this.topics.get(topic.toString());
-    }
-    getSubscribersWithData(topic, data, options) {
-        const map = this.topics.get(topic);
-        if (map) {
-            const results = [];
-            for (const [peer, info] of map.entries()) {
-                if (!info.data) {
-                    continue;
-                }
-                if (options?.prefix) {
-                    if (!startsWith(info.data, data)) {
-                        continue;
-                    }
-                }
-                else {
-                    if (!equals(info.data, data)) {
-                        continue;
-                    }
-                }
-                results.push(peer);
-            }
-            return results;
+        if (this.subscriptions.get(topic)) {
+            ret.push(this.publicKey);
         }
-        return;
+        return ret;
     }
     listenForSubscribers(topic) {
         this.initializeTopic(topic);
     }
-    async requestSubscribers(topic, from) {
+    async requestSubscribers(topic, to) {
         if (!this.started) {
             throw new CodeError("not started yet", "ERR_NOT_STARTED_YET");
         }
@@ -169,24 +133,29 @@ export class DirectSub extends DirectStream {
         for (const topic of topics) {
             this.listenForSubscribers(topic);
         }
-        return this.publishMessage(this.components.peerId, await new DataMessage({
-            to: from ? [from.hashcode()] : [],
-            data: toUint8Array(new GetSubscribers({ topics }).bytes())
+        return this.publishMessage(this.publicKey, await new DataMessage({
+            data: toUint8Array(new GetSubscribers({ topics }).bytes()),
+            header: new MessageHeader({
+                mode: new SeekDelivery({
+                    to: to ? [to.hashcode()] : [],
+                    redundancy: 2
+                })
+            })
         }).sign(this.sign));
     }
-    getPeersWithTopics(topics, otherPeers) {
-        const peers = otherPeers ? new Set(otherPeers) : new Set();
+    getPeersOnTopics(topics) {
+        const newPeers = new Set();
         if (topics?.length) {
             for (const topic of topics) {
                 const peersOnTopic = this.topicsToPeers.get(topic.toString());
                 if (peersOnTopic) {
                     peersOnTopic.forEach((peer) => {
-                        peers.add(peer);
+                        newPeers.add(peer);
                     });
                 }
             }
         }
-        return peers;
+        return newPeers;
     }
     /* getStreamsWithTopics(topics: string[], otherPeers?: string[]): PeerStreams[] {
         const peers = this.getNeighboursWithTopics(topics, otherPeers);
@@ -203,22 +172,28 @@ export class DirectSub extends DirectStream {
             ? x.hashcode()
             : typeof x === "string"
                 ? x
-                : getPublicKeyFromPeerId(x).hashcode()) || this.getPeersWithTopics(topics);
+                : getPublicKeyFromPeerId(x).hashcode()) || this.getPeersOnTopics(topics);
         // Embedd topic info before the data so that peers/relays can also use topic info to route messages efficiently
-        const dataMessage = new PubSubData({
-            topics: topics.map((x) => x.toString()),
-            data,
-            strict: options.strict
-        });
-        const bytes = dataMessage.bytes();
+        const dataMessage = data
+            ? new PubSubData({
+                topics: topics.map((x) => x.toString()),
+                data,
+                strict: !!options?.to
+            })
+            : undefined;
+        const bytes = dataMessage?.bytes();
         const message = await this.createMessage(bytes, { ...options, to: tos });
-        if (this.emitSelf) {
-            super.dispatchEvent(new CustomEvent("data", {
-                detail: new DataEvent(dataMessage, message)
+        if (dataMessage) {
+            this.dispatchEvent(new CustomEvent("publish", {
+                detail: new PublishEvent({
+                    client: options?.client,
+                    data: dataMessage,
+                    message
+                })
             }));
         }
         // send to all the other peers
-        await this.publishMessage(this.components.peerId, message, undefined);
+        await this.publishMessage(this.publicKey, message, undefined);
         return message.id;
     }
     deletePeerFromTopic(topic, publicKeyHash) {
@@ -235,28 +210,48 @@ export class DirectSub extends DirectStream {
         this.topicsToPeers.get(topic)?.delete(publicKeyHash);
         return change;
     }
-    onPeerUnreachable(publicKey) {
-        super.onPeerUnreachable(publicKey);
-        const publicKeyHash = publicKey.hashcode();
+    async onPeerReachable(publicKey) {
+        // Aggregate subscribers for my topics through this new peer because if we don't do this we might end up with a situtation where
+        // we act as a relay and relay messages for a topic, but don't forward it to this new peer because we never learned about their subscriptions
+        /* await this.requestSubscribers([...this.topics.keys()], publicKey); */
+        const resp = super.onPeerReachable(publicKey);
+        const stream = this.peers.get(publicKey.hashcode());
+        if (stream && this.subscriptions.size > 0) {
+            // is new neighbour
+            // tell the peer about all topics we subscribe to
+            this.publishMessage(this.publicKey, await new DataMessage({
+                data: toUint8Array(new Subscribe({
+                    topics: [...this.subscriptions.keys()]
+                }).bytes()),
+                header: new MessageHeader({
+                    mode: new SeekDelivery({ redundancy: 2 })
+                })
+            }).sign(this.sign)),
+                [stream];
+        }
+        return resp;
+    }
+    onPeerUnreachable(publicKeyHash) {
+        super.onPeerUnreachable(publicKeyHash);
         const peerTopics = this.peerToTopic.get(publicKeyHash);
         const changed = [];
         if (peerTopics) {
             for (const topic of peerTopics) {
                 const change = this.deletePeerFromTopic(topic, publicKeyHash);
                 if (change) {
-                    changed.push(new Subscription(topic, change.data));
+                    changed.push(topic);
                 }
             }
         }
         this.lastSubscriptionMessages.delete(publicKeyHash);
         if (changed.length > 0) {
             this.dispatchEvent(new CustomEvent("unsubscribe", {
-                detail: new UnsubcriptionEvent(publicKey, changed)
+                detail: new UnsubcriptionEvent(this.peerKeyHashToPublicKey.get(publicKeyHash), changed)
             }));
         }
     }
     subscriptionMessageIsLatest(message, pubsubMessage) {
-        const subscriber = message.signatures.signatures[0].publicKey;
+        const subscriber = message.header.signatures.signatures[0].publicKey;
         const subscriberKey = subscriber.hashcode(); // Assume first signature is the one who is signing
         for (const topic of pubsubMessage.topics) {
             const lastTimestamp = this.lastSubscriptionMessages
@@ -274,167 +269,204 @@ export class DirectSub extends DirectStream {
         }
         return true;
     }
-    async onDataMessage(from, stream, message) {
+    addPeersOnTopic(message, topics) {
+        const existingPeers = new Set(message.header.mode.to);
+        const allPeersOnTopic = this.getPeersOnTopics(topics);
+        for (const existing of existingPeers) {
+            allPeersOnTopic.add(existing);
+        }
+        allPeersOnTopic.delete(this.publicKeyHash);
+        message.header.mode.to = [...allPeersOnTopic];
+    }
+    async onDataMessage(from, stream, message, seenBefore) {
+        if (!message.data || message.data.length === 0) {
+            return super.onDataMessage(from, stream, message, seenBefore);
+        }
+        if (this.shouldIgnore(message, seenBefore)) {
+            return false;
+        }
         const pubsubMessage = PubSubMessage.from(message.data);
         if (pubsubMessage instanceof PubSubData) {
+            if (message.header.mode instanceof AnyWhere) {
+                throw new Error("Unexpected mode for PubSubData messages");
+            }
             /**
              * See if we know more subscribers of the message topics. If so, add aditional end receivers of the message
              */
-            let verified = undefined;
-            const isFromSelf = this.components.peerId.equals(from);
-            if (!isFromSelf || this.emitSelf) {
-                let isForMe;
-                if (pubsubMessage.strict) {
-                    isForMe =
-                        !!pubsubMessage.topics.find((topic) => this.subscriptions.has(topic)) && !!message.to.find((x) => this.publicKeyHash === x);
-                }
-                else {
-                    isForMe =
-                        !!pubsubMessage.topics.find((topic) => this.subscriptions.has(topic)) ||
-                            (pubsubMessage.topics.length === 0 &&
-                                !!message.to.find((x) => this.publicKeyHash === x));
+            let isForMe;
+            if (pubsubMessage.strict) {
+                isForMe =
+                    !!pubsubMessage.topics.find((topic) => this.subscriptions.has(topic)) && !!message.header.mode.to?.find((x) => this.publicKeyHash === x);
+            }
+            else {
+                isForMe =
+                    !!pubsubMessage.topics.find((topic) => this.subscriptions.has(topic)) ||
+                        (pubsubMessage.topics.length === 0 &&
+                            !!message.header.mode.to?.find((x) => this.publicKeyHash === x));
+            }
+            if (isForMe) {
+                if ((await this.maybeVerifyMessage(message)) === false) {
+                    logger.warn("Recieved message that did not verify PubSubData");
+                    return false;
                 }
-                if (isForMe) {
-                    if (verified === undefined) {
-                        verified = await message.verify(this.signaturePolicy === "StictSign" ? true : false);
-                    }
-                    if (!verified) {
-                        logger.warn("Recieved message that did not verify PubSubData");
-                        return false;
-                    }
+                await this.acknowledgeMessage(stream, message, seenBefore);
+                if (seenBefore === 0) {
                     this.dispatchEvent(new CustomEvent("data", {
-                        detail: new DataEvent(pubsubMessage, message)
+                        detail: new DataEvent({
+                            data: pubsubMessage,
+                            message
+                        })
                     }));
                 }
             }
+            if (message.header.mode.to) {
+                message.header.mode.to = message.header.mode.to.filter((x) => x !== this.publicKeyHash);
+            }
             // Forward
             if (!pubsubMessage.strict) {
-                const newTos = this.getPeersWithTopics(pubsubMessage.topics, message.to);
-                newTos.delete(this.publicKeyHash);
-                message.to = [...newTos];
+                this.addPeersOnTopic(message, pubsubMessage.topics);
             }
             // Only relay if we got additional receivers
             // or we are NOT subscribing ourselves (if we are not subscribing ourselves we are)
             // If we are not subscribing ourselves, then we don't have enough information to "stop" message propagation here
-            if (message.to.length > 0 ||
-                !pubsubMessage.topics.find((topic) => this.topics.has(topic))) {
-                await this.relayMessage(from, message);
+            if (message.header.mode.to?.length ||
+                0 > 0 ||
+                !pubsubMessage.topics.find((topic) => this.topics.has(topic)) ||
+                message.header.mode instanceof SeekDelivery) {
+                // DONT await this since it might introduce a dead-lock
+                this.relayMessage(from, message).catch(logError);
             }
         }
-        else if (pubsubMessage instanceof Subscribe) {
+        else {
             if (!(await message.verify(true))) {
-                logger.warn("Recieved message that did not verify Subscribe");
+                logger.warn("Recieved message that did not verify Unsubscribe");
                 return false;
             }
-            if (message.signatures.signatures.length === 0) {
+            if (message.header.signatures.signatures.length === 0) {
                 logger.warn("Recieved subscription message with no signers");
                 return false;
             }
-            if (pubsubMessage.subscriptions.length === 0) {
-                logger.info("Recieved subscription message with no topics");
-                return false;
-            }
-            if (!this.subscriptionMessageIsLatest(message, pubsubMessage)) {
-                logger.trace("Recieved old subscription message");
-                return false;
-            }
-            const subscriber = message.signatures.signatures[0].publicKey;
-            const subscriberKey = subscriber.hashcode(); // Assume first signature is the one who is signing
-            this.initializePeer(subscriber);
-            const changed = [];
-            pubsubMessage.subscriptions.forEach((subscription) => {
-                const peers = this.topics.get(subscription.topic);
-                if (peers == null) {
-                    return;
+            await this.acknowledgeMessage(stream, message, seenBefore);
+            const sender = message.header.signatures.signatures[0].publicKey;
+            const senderKey = sender.hashcode(); // Assume first signature is the one who is signing
+            if (pubsubMessage instanceof Subscribe) {
+                if (pubsubMessage.topics.length === 0) {
+                    logger.info("Recieved subscription message with no topics");
+                    return false;
                 }
-                // if no subscription data, or new subscription has data (and is newer) then overwrite it.
-                // subscription where data is undefined is not intended to replace existing data
-                const existingSubscription = peers.get(subscriberKey);
-                if (!existingSubscription ||
-                    (existingSubscription.timestamp < message.header.timetamp &&
-                        subscription.data)) {
-                    peers.set(subscriberKey, new SubscriptionData({
-                        timestamp: message.header.timetamp,
-                        data: subscription.data,
-                        publicKey: subscriber
+                if (!this.subscriptionMessageIsLatest(message, pubsubMessage)) {
+                    logger.trace("Recieved old subscription message");
+                    return false;
+                }
+                this.initializePeer(sender);
+                const changed = [];
+                pubsubMessage.topics.forEach((topic) => {
+                    const peers = this.topics.get(topic);
+                    if (peers == null) {
+                        return;
+                    }
+                    // if no subscription data, or new subscription has data (and is newer) then overwrite it.
+                    // subscription where data is undefined is not intended to replace existing data
+                    const existingSubscription = peers.get(senderKey);
+                    if (!existingSubscription ||
+                        existingSubscription.timestamp < message.header.timetamp) {
+                        peers.set(senderKey, new SubscriptionData({
+                            timestamp: message.header.timetamp, // TODO update timestamps on all messages?
+                            publicKey: sender
+                        }));
+                        if (!existingSubscription) {
+                            changed.push(topic);
+                        }
+                    }
+                    this.topicsToPeers.get(topic)?.add(senderKey);
+                    this.peerToTopic.get(senderKey)?.add(topic);
+                });
+                if (changed.length > 0) {
+                    this.dispatchEvent(new CustomEvent("subscribe", {
+                        detail: new SubscriptionEvent(sender, changed)
                     }));
-                    if (!existingSubscription?.data ||
-                        !equals(existingSubscription.data, subscription.data)) {
-                        changed.push(subscription);
+                    // also send back a message telling the remote whether we are subsbscring
+                    if (message.header.mode instanceof SeekDelivery) {
+                        // only if Subscribe message is of 'seek' type we will respond with our subscriptions
+                        const mySubscriptions = changed
+                            .map((x) => {
+                            const subscription = this.subscriptions.get(x);
+                            return subscription ? x : undefined;
+                        })
+                            .filter((x) => !!x);
+                        if (mySubscriptions.length > 0) {
+                            const response = new DataMessage({
+                                data: toUint8Array(new Subscribe({
+                                    topics: mySubscriptions
+                                }).bytes()),
+                                // needs to be Ack or Silent else we will run into a infite message loop
+                                header: new MessageHeader({
+                                    mode: new AcknowledgeDelivery({
+                                        redundancy: 2,
+                                        to: [sender.hashcode()]
+                                    })
+                                })
+                            });
+                            await this.publishMessage(this.publicKey, await response.sign(this.sign));
+                        }
                     }
                 }
-                this.topicsToPeers.get(subscription.topic)?.add(subscriberKey);
-                this.peerToTopic.get(subscriberKey)?.add(subscription.topic);
-            });
-            if (changed.length > 0) {
-                this.dispatchEvent(new CustomEvent("subscribe", {
-                    detail: new SubscriptionEvent(subscriber, changed)
-                }));
-            }
-            // Forward
-            await this.relayMessage(from, message);
-        }
-        else if (pubsubMessage instanceof Unsubscribe) {
-            if (!(await message.verify(true))) {
-                logger.warn("Recieved message that did not verify Unsubscribe");
-                return false;
-            }
-            if (message.signatures.signatures.length === 0) {
-                logger.warn("Recieved subscription message with no signers");
-                return false;
-            }
-            if (!this.subscriptionMessageIsLatest(message, pubsubMessage)) {
-                logger.trace("Recieved old subscription message");
-                return false;
+                // Forward
+                // DONT await this since it might introduce a dead-lock
+                this.relayMessage(from, message).catch(logError);
             }
-            const changed = [];
-            const subscriber = message.signatures.signatures[0].publicKey;
-            const subscriberKey = subscriber.hashcode(); // Assume first signature is the one who is signing
-            for (const unsubscription of pubsubMessage.unsubscriptions) {
-                const change = this.deletePeerFromTopic(unsubscription.topic, subscriberKey);
-                if (change) {
-                    changed.push(new Subscription(unsubscription.topic, change.data));
+            else if (pubsubMessage instanceof Unsubscribe) {
+                if (!this.subscriptionMessageIsLatest(message, pubsubMessage)) {
+                    logger.trace("Recieved old subscription message");
+                    return false;
                 }
-            }
-            if (changed.length > 0) {
-                this.dispatchEvent(new CustomEvent("unsubscribe", {
-                    detail: new UnsubcriptionEvent(subscriber, changed)
-                }));
-            }
-            // Forward
-            await this.relayMessage(from, message);
-        }
-        else if (pubsubMessage instanceof GetSubscribers) {
-            if (!(await message.verify(true))) {
-                logger.warn("Recieved message that did not verify GetSubscribers");
-                return false;
-            }
-            const subscriptionsToSend = [];
-            for (const topic of pubsubMessage.topics) {
-                const subscription = this.subscriptions.get(topic);
-                if (subscription) {
-                    subscriptionsToSend.push(new Subscription(topic, subscription.data));
+                const changed = [];
+                for (const unsubscription of pubsubMessage.topics) {
+                    const change = this.deletePeerFromTopic(unsubscription, senderKey);
+                    if (change) {
+                        changed.push(unsubscription);
+                    }
+                }
+                if (changed.length > 0) {
+                    this.dispatchEvent(new CustomEvent("unsubscribe", {
+                        detail: new UnsubcriptionEvent(sender, changed)
+                    }));
+                }
+                // Forward
+                if (message.header.mode instanceof SeekDelivery ||
+                    message.header.mode instanceof SilentDelivery ||
+                    message.header.mode instanceof AcknowledgeDelivery) {
+                    this.addPeersOnTopic(message, pubsubMessage.topics);
                 }
+                // DONT await this since it might introduce a dead-lock
+                this.relayMessage(from, message).catch(logError);
             }
-            if (subscriptionsToSend.length > 0) {
-                // respond
-                if (!stream.isWritable) {
-                    try {
-                        await waitFor(() => stream.isWritable);
-                    }
-                    catch (error) {
-                        logger.warn(`Failed to respond to GetSubscribers request to ${from.toString()} stream is not writable`);
-                        return false;
+            else if (pubsubMessage instanceof GetSubscribers) {
+                const subscriptionsToSend = [];
+                for (const topic of pubsubMessage.topics) {
+                    const subscription = this.subscriptions.get(topic);
+                    if (subscription) {
+                        subscriptionsToSend.push(topic);
                     }
                 }
-                this.publishMessage(this.components.peerId, await new DataMessage({
-                    data: toUint8Array(new Subscribe({
-                        subscriptions: subscriptionsToSend
-                    }).bytes())
-                }).sign(this.sign), [stream]); // send back to same stream
+                if (subscriptionsToSend.length > 0) {
+                    // respond
+                    this.publishMessage(this.publicKey, await new DataMessage({
+                        data: toUint8Array(new Subscribe({
+                            topics: subscriptionsToSend
+                        }).bytes()),
+                        header: new MessageHeader({
+                            mode: new SilentDelivery({
+                                redundancy: 2,
+                                to: [sender.hashcode()]
+                            })
+                        })
+                    }).sign(this.sign), [stream]); // send back to same stream
+                }
+                // Forward
+                // DONT await this since it might introduce a dead-lock
+                this.relayMessage(from, message).catch(logError);
             }
-            // Forward
-            await this.relayMessage(from, message);
         }
         return true;
     }
@@ -455,7 +487,7 @@ export const waitForSubscribers = async (libp2p, peersToWait, topic) => {
             ? id.hashcode()
             : getPublicKeyFromPeerId(id).hashcode();
     });
-    await libp2p.services.pubsub.requestSubscribers(topic);
+    // await libp2p.services.pubsub.requestSubscribers(topic);
     return new Promise((resolve, reject) => {
         let counter = 0;
         const interval = setInterval(async () => {
@@ -465,7 +497,7 @@ export const waitForSubscribers = async (libp2p, peersToWait, topic) => {
                 reject(new Error("Failed to find expected subscribers for topic: " + topic));
             }
             try {
-                const peers = await libp2p.services.pubsub.getSubscribers(topic);
+                const peers = await libp2p.services.pubsub.topics.get(topic);
                 const hasAllPeers = peerIdsToWait
                     .map((e) => peers && peers.has(e))
                     .filter((e) => e === false).length === 0;