@peerbit/pubsub 1.1.12 → 2.0.1

package/src/index.ts

@@ -1,15 +1,22 @@
 import type { PeerId as Libp2pPeerId } from "@libp2p/interface/peer-id";
 import { logger as logFn } from "@peerbit/logger";
-
-import { DataMessage } from "@peerbit/stream-interface";
+import {
+	AcknowledgeDelivery,
+	AnyWhere,
+	DataMessage,
+	DeliveryMode,
+	Message,
+	MessageHeader,
+	SeekDelivery,
+	SilentDelivery
+} from "@peerbit/stream-interface";
 import {
 	DirectStream,
 	DirectStreamComponents,
 	DirectStreamOptions,
 	PeerStreams
 } from "@peerbit/stream";
-
-import { CodeError } from "@libp2p/interface/errors";
+import { CodeError } from "@libp2p/interface";
 import {
 	PubSubMessage,
 	Subscribe,
@@ -17,21 +24,19 @@ import {
 	toUint8Array,
 	Unsubscribe,
 	GetSubscribers,
-	Subscription,
 	UnsubcriptionEvent,
 	SubscriptionEvent,
 	PubSub,
 	DataEvent,
-	SubscriptionData
+	SubscriptionData,
+	PublishEvent
 } from "@peerbit/pubsub-interface";
 import { getPublicKeyFromPeerId, PublicSignKey } from "@peerbit/crypto";
-import { CustomEvent } from "@libp2p/interface/events";
-import { waitFor } from "@peerbit/time";
-import { Connection } from "@libp2p/interface/connection";
-import { equals, startsWith } from "@peerbit/uint8arrays";
+import { CustomEvent } from "@libp2p/interface";
 import { PubSubEvents } from "@peerbit/pubsub-interface";
 
-export const logger = logFn({ module: "direct-sub", level: "warn" });
+export const logger = logFn({ module: "lazysub", level: "warn" });
+const logError = (e?: { message: string }) => logger.error(e?.message);
 
 export interface PeerStreamsInit {
 	id: Libp2pPeerId;
@@ -50,12 +55,12 @@ export class DirectSub extends DirectStream<PubSubEvents> implements PubSub {
 	public topics: Map<string, Map<string, SubscriptionData>>; // topic -> peers --> Uint8Array subscription metadata (the latest received)
 	public peerToTopic: Map<string, Set<string>>; // peer -> topics
 	public topicsToPeers: Map<string, Set<string>>; // topic -> peers
-	public subscriptions: Map<string, { counter: number; data?: Uint8Array }>; // topic -> subscription ids
+	public subscriptions: Map<string, { counter: number }>; // topic -> subscription ids
 	public lastSubscriptionMessages: Map<string, Map<string, DataMessage>> =
 		new Map();
 
 	constructor(components: DirectSubComponents, props?: DirectStreamOptions) {
-		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();
@@ -70,17 +75,6 @@ export class DirectSub extends DirectStream<PubSubEvents> implements PubSub {
 		return super.stop();
 	}
 
-	public async onPeerReachable(publicKey: PublicSignKey) {
-		// 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);
-	}
-
-	public async onPeerDisconnected(peerId: Libp2pPeerId, conn?: Connection) {
-		return super.onPeerDisconnected(peerId, conn);
-	}
-
 	private initializeTopic(topic: string) {
 		this.topics.get(topic) || this.topics.set(topic, new Map());
 		this.topicsToPeers.get(topic) || this.topicsToPeers.set(topic, new Set());
@@ -94,56 +88,35 @@ export class DirectSub extends DirectStream<PubSubEvents> implements PubSub {
 	/**
 	 * Subscribes to a given topic.
 	 */
-	/**
-	 * @param topic,
-	 * @param data, metadata associated with the subscription, shared with peers
-	 */
-	async subscribe(topic: string | string[], options?: { data?: Uint8Array }) {
+	async subscribe(topic: string) {
 		if (!this.started) {
 			throw new Error("Pubsub has not started");
 		}
 
-		topic = typeof topic === "string" ? [topic] : topic;
-
 		const newTopicsForTopicData: string[] = [];
-		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
-				});
+		const prev = this.subscriptions.get(topic);
+		if (prev) {
+			prev.counter += 1;
+		} else {
+			this.subscriptions.set(topic, {
+				counter: 1
+			});
 
-				newTopicsForTopicData.push(t);
-				this.listenForSubscribers(t);
-			}
+			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)
-						)
+						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));
 		}
 	}
 
@@ -178,68 +151,51 @@ export class DirectSub extends DirectStream<PubSubEvents> implements PubSub {
 			}
 		}
 		if (!subscriptions?.counter || options?.force) {
-			this.subscriptions.delete(topic);
-			this.topics.delete(topic);
-			this.topicsToPeers.delete(topic);
-
 			await this.publishMessage(
-				this.components.peerId,
+				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);
+
 			return true;
 		}
 		return false;
 	}
 
-	getSubscribers(topic: string): Map<string, SubscriptionData> | undefined {
-		if (!this.started) {
-			throw new CodeError("not started yet", "ERR_NOT_STARTED_YET");
-		}
+	getSubscribers(topic: string): PublicSignKey[] | undefined {
+		const remote = this.topics.get(topic.toString());
 
-		if (topic == null) {
-			throw new CodeError("topic is required", "ERR_NOT_VALID_TOPIC");
+		if (!remote) {
+			return undefined;
 		}
-
-		return this.topics.get(topic.toString());
-	}
-
-	getSubscribersWithData(
-		topic: string,
-		data: Uint8Array,
-		options?: { prefix: boolean }
-	): string[] | undefined {
-		const map = this.topics.get(topic);
-		if (map) {
-			const results: string[] = [];
-			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;
+		const ret: PublicSignKey[] = [];
+		for (const v of remote.values()) {
+			ret.push(v.publicKey);
 		}
-		return;
+		if (this.subscriptions.get(topic)) {
+			ret.push(this.publicKey);
+		}
+		return ret;
 	}
 
-	listenForSubscribers(topic: string) {
+	private listenForSubscribers(topic: string) {
 		this.initializeTopic(topic);
 	}
 
 	async requestSubscribers(
 		topic: string | string[],
-		from?: PublicSignKey
+		to?: PublicSignKey
 	): Promise<void> {
 		if (!this.started) {
 			throw new CodeError("not started yet", "ERR_NOT_STARTED_YET");
@@ -259,27 +215,32 @@ export class DirectSub extends DirectStream<PubSubEvents> implements PubSub {
 		}
 
 		return this.publishMessage(
-			this.components.peerId,
+			this.publicKey,
 			await new DataMessage({
-				to: from ? [from.hashcode()] : [],
-				data: toUint8Array(new GetSubscribers({ topics }).bytes())
+				data: toUint8Array(new GetSubscribers({ topics }).bytes()),
+				header: new MessageHeader({
+					mode: new SeekDelivery({
+						to: to ? [to.hashcode()] : [],
+						redundancy: 2
+					})
+				})
 			}).sign(this.sign)
 		);
 	}
 
-	getPeersWithTopics(topics: string[], otherPeers?: string[]): Set<string> {
-		const peers: Set<string> = otherPeers ? new Set(otherPeers) : new Set();
+	getPeersOnTopics(topics: string[]): Set<string> {
+		const newPeers: Set<string> = 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[] {
@@ -290,18 +251,17 @@ export class DirectSub extends DirectStream<PubSubEvents> implements PubSub {
 	} */
 
 	async publish(
-		data: Uint8Array,
-		options:
+		data: Uint8Array | undefined,
+		options?: (
 			| {
-					topics?: string[];
-					to?: (string | PeerId)[];
-					strict?: false;
+					topics: string[];
+					to?: (string | PublicSignKey | PeerId)[];
 			  }
 			| {
 					topics: string[];
-					to: (string | PeerId)[];
-					strict: true;
+					mode?: SilentDelivery | SeekDelivery | AcknowledgeDelivery;
 			  }
+		) & { client?: string }
 	): Promise<Uint8Array> {
 		if (!this.started) {
 			throw new Error("Not started");
@@ -309,36 +269,43 @@ export class DirectSub extends DirectStream<PubSubEvents> implements PubSub {
 
 		const topics =
 			(options as { topics: string[] }).topics?.map((x) => x.toString()) || [];
+
 		const tos =
-			options?.to?.map((x) =>
+			(options as { to: (string | PublicSignKey | PeerId)[] })?.to?.map((x) =>
 				x instanceof PublicSignKey
 					? x.hashcode()
 					: typeof x === "string"
-					? x
-					: getPublicKeyFromPeerId(x).hashcode()
-			) || this.getPeersWithTopics(topics);
+						? x
+						: 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 as { to: string[] })?.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;
 	}
 
@@ -360,18 +327,48 @@ export class DirectSub extends DirectStream<PubSubEvents> implements PubSub {
 
 		return change;
 	}
-	public onPeerUnreachable(publicKey: PublicSignKey) {
-		super.onPeerUnreachable(publicKey);
 
-		const publicKeyHash = publicKey.hashcode();
+	public async onPeerReachable(publicKey: PublicSignKey) {
+		// 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;
+	}
+
+	public onPeerUnreachable(publicKeyHash: string) {
+		super.onPeerUnreachable(publicKeyHash);
+
 		const peerTopics = this.peerToTopic.get(publicKeyHash);
 
-		const changed: Subscription[] = [];
+		const changed: string[] = [];
 		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);
 				}
 			}
 		}
@@ -380,7 +377,10 @@ export class DirectSub extends DirectStream<PubSubEvents> implements PubSub {
 		if (changed.length > 0) {
 			this.dispatchEvent(
 				new CustomEvent<UnsubcriptionEvent>("unsubscribe", {
-					detail: new UnsubcriptionEvent(publicKey, changed)
+					detail: new UnsubcriptionEvent(
+						this.peerKeyHashToPublicKey.get(publicKeyHash)!,
+						changed
+					)
 				})
 			);
 		}
@@ -390,7 +390,7 @@ export class DirectSub extends DirectStream<PubSubEvents> implements PubSub {
 		message: DataMessage,
 		pubsubMessage: Subscribe | Unsubscribe
 	) {
-		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) {
@@ -411,223 +411,283 @@ export class DirectSub extends DirectStream<PubSubEvents> implements PubSub {
 		return true;
 	}
 
+	private addPeersOnTopic(
+		message: DataMessage<AcknowledgeDelivery | SilentDelivery | SeekDelivery>,
+		topics: string[]
+	) {
+		const existingPeers: Set<string> = 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: Libp2pPeerId,
+		from: PublicSignKey,
 		stream: PeerStreams,
-		message: DataMessage
+		message: DataMessage,
+		seenBefore: number
 	) {
+		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: boolean | undefined = undefined;
-
-			const isFromSelf = this.components.peerId.equals(from);
-			if (!isFromSelf || this.emitSelf) {
-				let isForMe: boolean;
-				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: boolean;
+			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
+				this.addPeersOnTopic(
+					message as DataMessage<
+						SeekDelivery | SilentDelivery | AcknowledgeDelivery
+					>,
+					pubsubMessage.topics
 				);
-				newTos.delete(this.publicKeyHash);
-				message.to = [...newTos];
 			}
 
 			// 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))
+				message.header.mode.to?.length ||
+				0 > 0 ||
+				!pubsubMessage.topics.find((topic) => this.topics.has(topic)) ||
+				message.header.mode instanceof SeekDelivery
 			) {
-				await this.relayMessage(from, message);
+				// 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;
-			}
+			await this.acknowledgeMessage(stream, message, seenBefore);
 
-			const subscriber = message.signatures.signatures[0].publicKey!;
-			const subscriberKey = subscriber.hashcode(); // Assume first signature is the one who is signing
+			const sender = message.header.signatures!.signatures[0].publicKey!;
+			const senderKey = sender.hashcode(); // Assume first signature is the one who is signing
 
-			this.initializePeer(subscriber);
+			if (pubsubMessage instanceof Subscribe) {
+				if (pubsubMessage.topics.length === 0) {
+					logger.info("Recieved subscription message with no topics");
+					return false;
+				}
 
-			const changed: Subscription[] = [];
-			pubsubMessage.subscriptions.forEach((subscription) => {
-				const peers = this.topics.get(subscription.topic);
-				if (peers == null) {
-					return;
+				if (!this.subscriptionMessageIsLatest(message, pubsubMessage)) {
+					logger.trace("Recieved old subscription message");
+					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);
+				this.initializePeer(sender);
+
+				const changed: string[] = [];
+				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 &&
-						subscription.data)
-				) {
-					peers.set(
-						subscriberKey,
-						new SubscriptionData({
-							timestamp: message.header.timetamp, // TODO update timestamps on all messages?
-							data: subscription.data,
-							publicKey: subscriber
-						})
-					);
 					if (
-						!existingSubscription?.data ||
-						!equals(existingSubscription.data, subscription.data)
+						!existingSubscription ||
+						existingSubscription.timestamp < message.header.timetamp
 					) {
-						changed.push(subscription);
+						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(subscription.topic)?.add(subscriberKey);
-				this.peerToTopic.get(subscriberKey)?.add(subscription.topic);
-			});
-			if (changed.length > 0) {
-				this.dispatchEvent(
-					new CustomEvent<SubscriptionEvent>("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;
-			}
+					this.topicsToPeers.get(topic)?.add(senderKey);
+					this.peerToTopic.get(senderKey)?.add(topic);
+				});
+				if (changed.length > 0) {
+					this.dispatchEvent(
+						new CustomEvent<SubscriptionEvent>("subscribe", {
+							detail: new SubscriptionEvent(sender, changed)
+						})
+					);
 
-			if (message.signatures.signatures.length === 0) {
-				logger.warn("Recieved subscription message with no signers");
-				return false;
-			}
+					// 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) as string[];
+
+						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)
+							);
+						}
+					}
+				}
 
-			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);
+			} else if (pubsubMessage instanceof Unsubscribe) {
+				if (!this.subscriptionMessageIsLatest(message, pubsubMessage)) {
+					logger.trace("Recieved old subscription message");
+					return false;
+				}
 
-			const changed: Subscription[] = [];
-			const subscriber = message.signatures.signatures[0].publicKey!;
-			const subscriberKey = subscriber.hashcode(); // Assume first signature is the one who is signing
+				const changed: string[] = [];
 
-			for (const unsubscription of pubsubMessage.unsubscriptions) {
-				const change = this.deletePeerFromTopic(
-					unsubscription.topic,
-					subscriberKey
-				);
-				if (change) {
-					changed.push(new Subscription(unsubscription.topic, change.data));
+				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<UnsubcriptionEvent>("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;
-			}
+				if (changed.length > 0) {
+					this.dispatchEvent(
+						new CustomEvent<UnsubcriptionEvent>("unsubscribe", {
+							detail: new UnsubcriptionEvent(sender, changed)
+						})
+					);
+				}
 
-			const subscriptionsToSend: Subscription[] = [];
-			for (const topic of pubsubMessage.topics) {
-				const subscription = this.subscriptions.get(topic);
-				if (subscription) {
-					subscriptionsToSend.push(new Subscription(topic, subscription.data));
+				// Forward
+				if (
+					message.header.mode instanceof SeekDelivery ||
+					message.header.mode instanceof SilentDelivery ||
+					message.header.mode instanceof AcknowledgeDelivery
+				) {
+					this.addPeersOnTopic(
+						message as DataMessage<
+							SeekDelivery | SilentDelivery | AcknowledgeDelivery
+						>,
+						pubsubMessage.topics
+					);
 				}
-			}
 
-			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;
+				// DONT await this since it might introduce a dead-lock
+				this.relayMessage(from, message).catch(logError);
+			} else if (pubsubMessage instanceof GetSubscribers) {
+				const subscriptionsToSend: string[] = [];
+				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
-			}
 
-			// Forward
-			await this.relayMessage(from, message);
+				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);
+			}
 		}
 		return true;
 	}
@@ -661,7 +721,7 @@ export const waitForSubscribers = async (
 			: getPublicKeyFromPeerId(id).hashcode();
 	});
 
-	await libp2p.services.pubsub.requestSubscribers(topic);
+	// await libp2p.services.pubsub.requestSubscribers(topic);
 	return new Promise<void>((resolve, reject) => {
 		let counter = 0;
 		const interval = setInterval(async () => {
@@ -673,7 +733,7 @@ export const waitForSubscribers = async (
 				);
 			}
 			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))