@peerbit/stream 1.0.20 → 2.0.1

package/src/index.ts

@@ -1,4 +1,4 @@
-import { EventEmitter, CustomEvent } from "@libp2p/interface/events";
+import { TypedEventEmitter, CustomEvent } from "@libp2p/interface";
 import { pipe } from "it-pipe";
 import Queue from "p-queue";
 import type { PeerId } from "@libp2p/interface/peer-id";
@@ -9,9 +9,7 @@ import type { Stream } from "@libp2p/interface/connection";
 import { Uint8ArrayList } from "uint8arraylist";
 import { abortableSource } from "abortable-iterator";
 import * as lp from "it-length-prefixed";
-import { Routes } from "./routes.js";
-import { multiaddr } from "@multiformats/multiaddr";
-import { PeerMap } from "./peer-map.js";
+import { MAX_ROUTE_DISTANCE, Routes } from "./routes.js";
 import type {
 	IncomingStreamData,
 	Registrar
@@ -20,39 +18,62 @@ import type { AddressManager } from "@libp2p/interface-internal/address-manager"
 import type { ConnectionManager } from "@libp2p/interface-internal/connection-manager";
 
 import { PeerStore } from "@libp2p/interface/peer-store";
+import pDefer from "p-defer";
+
+import { AbortError, delay, TimeoutError, waitFor } from "@peerbit/time";
 
-import { delay, TimeoutError, waitFor, waitForAsync } from "@peerbit/time";
 import {
-	Ed25519PublicKey,
 	getKeypairFromPeerId,
 	getPublicKeyFromPeerId,
 	PublicSignKey,
-	SignatureWithKey
+	sha256Base64,
+	SignatureWithKey,
+	toBase64
 } from "@peerbit/crypto";
 
+import { multiaddr } from "@multiformats/multiaddr";
+import { Components } from "libp2p/components";
+import type { TypedEventTarget } from "@libp2p/interface";
+
 export type SignaturePolicy = "StictSign" | "StrictNoSign";
+
 import { logger } from "./logger.js";
-import { Cache } from "@peerbit/cache";
+
 export { logger };
+
+import { Cache } from "@peerbit/cache";
 import type { Libp2pEvents } from "@libp2p/interface";
+import { ready } from "@peerbit/crypto";
 import {
-	PeerEvents,
 	Message as Message,
-	Goodbye,
-	Hello,
 	DataMessage,
-	Ping,
-	PingPong,
-	Pong,
 	getMsgId,
-	WaitForPeer
+	WaitForPeer,
+	ACK,
+	SeekDelivery,
+	AcknowledgeDelivery,
+	SilentDelivery,
+	MessageHeader,
+	Goodbye,
+	StreamEvents,
+	TracedDelivery,
+	AnyWhere
 } from "@peerbit/stream-interface";
+
+import { MultiAddrinfo } from "@peerbit/stream-interface";
+import { MovingAverageTracker } from "./metrics.js";
+
+const logError = (e?: { message: string }) => {
+	return logger.error(e?.message);
+};
 export interface PeerStreamsInit {
 	peerId: PeerId;
 	publicKey: PublicSignKey;
 	protocol: string;
 	connId: string;
 }
+const DEFAULT_SEEK_MESSAGE_REDUDANCY = 2;
+const DEFAULT_SILENT_MESSAGE_REDUDANCY = 1;
 
 const isWebsocketConnection = (c: Connection) =>
 	c.remoteAddr.protoNames().find((x) => x === "ws" || x === "wss");
@@ -62,10 +83,30 @@ export interface PeerStreamEvents {
 	"stream:outbound": CustomEvent<never>;
 	close: CustomEvent<never>;
 }
+
+const SEEK_DELIVERY_TIMEOUT = 15e3;
+const MAX_DATA_LENGTH = 1e7 + 1000; // 10 mb and some metadata
+const MAX_QUEUED_BYTES = MAX_DATA_LENGTH * 50;
+
+const DEFAULT_PRUNE_CONNECTIONS_INTERVAL = 2e4;
+const DEFAULT_MIN_CONNECTIONS = 2;
+const DEFAULT_MAX_CONNECTIONS = 300;
+
+const DEFAULT_PRUNED_CONNNECTIONS_TIMEOUT = 30 * 1000;
+
+const ROUTE_UPDATE_DELAY_FACTOR = 3e4;
+
+type WithTo = {
+	to?: (string | PublicSignKey | PeerId)[] | Set<string>;
+};
+
+type WithMode = {
+	mode?: SilentDelivery | SeekDelivery | AcknowledgeDelivery | AnyWhere;
+};
 /**
  * Thin wrapper around a peer's inbound / outbound pubsub streams
  */
-export class PeerStreams extends EventEmitter<PeerStreamEvents> {
+export class PeerStreams extends TypedEventEmitter<PeerStreamEvents> {
 	public counter = 0;
 	public readonly peerId: PeerId;
 	public readonly publicKey: PublicSignKey;
@@ -73,7 +114,7 @@ export class PeerStreams extends EventEmitter<PeerStreamEvents> {
 	/**
 	 * Write stream - it's preferable to use the write method
 	 */
-	public outboundStream?: Pushable<Uint8ArrayList>;
+	public outboundStream?: Pushable<Uint8Array>;
 	/**
 	 * Read stream
 	 */
@@ -93,10 +134,11 @@ export class PeerStreams extends EventEmitter<PeerStreamEvents> {
 
 	private closed: boolean;
 
-	public pingJob: { resolve: () => void; abort: () => void };
-	public pingLatency: number | undefined;
-
 	public connId: string;
+
+	public seekedOnce: boolean;
+
+	private usedBandWidthTracker: MovingAverageTracker;
 	constructor(init: PeerStreamsInit) {
 		super();
 
@@ -107,6 +149,7 @@ export class PeerStreams extends EventEmitter<PeerStreamEvents> {
 		this.closed = false;
 		this.connId = init.connId;
 		this.counter = 1;
+		this.usedBandWidthTracker = new MovingAverageTracker();
 	}
 
 	/**
@@ -123,6 +166,10 @@ export class PeerStreams extends EventEmitter<PeerStreamEvents> {
 		return Boolean(this.outboundStream);
 	}
 
+	get usedBandwidth() {
+		return this.usedBandWidthTracker.value;
+	}
+
 	/**
 	 * Send a message to this peer.
 	 * Throws if there is no `stream` to write to available.
@@ -132,12 +179,20 @@ export class PeerStreams extends EventEmitter<PeerStreamEvents> {
 			logger.error("No writable connection to " + this.peerId.toString());
 			throw new Error("No writable connection to " + this.peerId.toString());
 		}
+
+		this.usedBandWidthTracker.add(data.byteLength);
+
 		this.outboundStream.push(
-			data instanceof Uint8Array ? new Uint8ArrayList(data) : data
+			data instanceof Uint8Array ? data : data.subarray()
 		);
 	}
 
 	async waitForWrite(bytes: Uint8Array | Uint8ArrayList) {
+		if (this.closed) {
+			logger.error("Failed to send to stream: " + this.peerId + ". Closed");
+			return;
+		}
+
 		if (!this.isWritable) {
 			// Catch the event where the outbound stream is attach, but also abort if we shut down
 			const outboundPromise = new Promise<void>((rs, rj) => {
@@ -197,7 +252,7 @@ export class PeerStreams extends EventEmitter<PeerStreamEvents> {
 		this._rawInboundStream = stream;
 		this.inboundStream = abortableSource(
 			pipe(this._rawInboundStream, (source) =>
-				lp.decode(source, { maxDataLength: 100001000 })
+				lp.decode(source, { maxDataLength: MAX_DATA_LENGTH })
 			),
 			this.inboundAbortController.signal,
 			{
@@ -221,10 +276,8 @@ export class PeerStreams extends EventEmitter<PeerStreamEvents> {
 		const _prevStream = this.outboundStream;
 
 		this._rawOutboundStream = stream;
-		this.pingJob?.abort();
-
-		this.outboundStream = pushable<Uint8ArrayList>({
-			objectMode: true,
+		this.outboundStream = pushable<Uint8Array>({
+			objectMode: false,
 			onEnd: () => {
 				return stream.close().then(() => {
 					if (this._rawOutboundStream === stream) {
@@ -240,9 +293,7 @@ export class PeerStreams extends EventEmitter<PeerStreamEvents> {
 			this.outboundStream,
 			(source) => lp.encode(source),
 			this._rawOutboundStream
-		).catch((err: Error) => {
-			logger.error(err);
-		});
+		).catch(logError);
 
 		// Emit if the connection is new
 		this.dispatchEvent(new CustomEvent("stream:outbound"));
@@ -275,59 +326,65 @@ export class PeerStreams extends EventEmitter<PeerStreamEvents> {
 			await this._rawInboundStream?.close();
 		}
 
-		this.pingJob?.abort();
-		this.pingLatency = undefined;
-
-		//this.dispatchEvent(new CustomEvent('close'))
+		this.dispatchEvent(new CustomEvent("close"));
 		this._rawOutboundStream = undefined;
 		this.outboundStream = undefined;
+
 		this._rawInboundStream = undefined;
 		this.inboundStream = undefined;
 	}
 }
 
-export interface MessageEvents {
-	message: CustomEvent<Message>;
-}
-
-export interface StreamEvents extends PeerEvents, MessageEvents {
-	data: CustomEvent<DataMessage>;
-}
-
-export type ConnectionManagerOptions = {
-	autoDial?: boolean;
-	retryDelay?: number;
+type DialerOptions = {
+	retryDelay: number;
+};
+type PrunerOptions = {
+	interval: number; // how often to check for pruning
+	bandwidth?: number; // Mbps, unlimited if unset
+	maxBuffer?: number; // max queued bytes until pruning
+	connectionTimeout: number; // how long a pruned connection should be treated as non wanted
 };
+type ConnectionManagerOptions = {
+	minConnections: number;
+	maxConnections: number;
+	dialer?: DialerOptions;
+	pruner?: PrunerOptions;
+};
+
 export type DirectStreamOptions = {
 	canRelayMessage?: boolean;
-	emitSelf?: boolean;
 	messageProcessingConcurrency?: number;
 	maxInboundStreams?: number;
 	maxOutboundStreams?: number;
 	signaturePolicy?: SignaturePolicy;
-	pingInterval?: number | null;
-	connectionManager?: ConnectionManagerOptions;
+	connectionManager?: ConnectionManagerArguments;
+	routeSeekInterval?: number;
+	seekTimeout?: number;
 };
 
-import { Components } from "libp2p/components";
-
 export interface DirectStreamComponents extends Components {
 	peerId: PeerId;
 	addressManager: AddressManager;
 	registrar: Registrar;
 	connectionManager: ConnectionManager;
 	peerStore: PeerStore;
-	events: EventEmitter<Libp2pEvents>;
+	events: TypedEventTarget<Libp2pEvents>;
 }
 
+export type ConnectionManagerArguments =
+	| (Partial<Pick<ConnectionManagerOptions, "minConnections">> &
+			Partial<Pick<ConnectionManagerOptions, "maxConnections">> & {
+				pruner?: Partial<PrunerOptions> | false;
+			} & { dialer?: Partial<DialerOptions> | false })
+	| false;
+
 export abstract class DirectStream<
 		Events extends { [s: string]: any } = StreamEvents
 	>
-	extends EventEmitter<Events>
+	extends TypedEventEmitter<Events>
 	implements WaitForPeer
 {
 	public peerId: PeerId;
-	public peerIdStr: string;
 	public publicKey: PublicSignKey;
 	public publicKeyHash: string;
 	public sign: (bytes: Uint8Array) => Promise<SignatureWithKey>;
@@ -337,9 +394,8 @@ export abstract class DirectStream<
 	/**
 	 * Map of peer streams
 	 */
-	public peers: PeerMap<PeerStreams>;
+	public peers: Map<string, PeerStreams>;
 	public peerKeyHashToPublicKey: Map<string, PublicSignKey>;
-	public peerIdToPublicKey: Map<string, PublicSignKey>;
 	public routes: Routes;
 	/**
 	 * If router can relay received messages, even if not subscribed
@@ -350,22 +406,32 @@ export abstract class DirectStream<
 	 */
 
 	public signaturePolicy: SignaturePolicy;
-	public emitSelf: boolean;
 	public queue: Queue;
 	public multicodecs: string[];
-	public seenCache: Cache;
-	public earlyGoodbyes: Map<string, Goodbye>;
-	public helloMap: Map<string, Map<string, Hello>>; // key is hash of publicKey, value is map whey key is hash of signature bytes, and value is latest Hello
-	public multiaddrsMap: Map<string, string[]>;
+	public seenCache: Cache<number>;
 	private _registrarTopologyIds: string[] | undefined;
 	private readonly maxInboundStreams?: number;
 	private readonly maxOutboundStreams?: number;
-	private topology: any;
-	private pingJobPromise: any;
-	private pingJob: any;
-	private pingInterval: number | null;
-	private connectionManagerOptions: ConnectionManagerOptions;
-	private recentDials: Cache<string>;
+	connectionManagerOptions: ConnectionManagerOptions;
+	private recentDials?: Cache<string>;
+	private healthChecks: Map<string, ReturnType<typeof setTimeout>>;
+	private pruneConnectionsTimeout: ReturnType<typeof setInterval>;
+	private prunedConnectionsCache?: Cache<string>;
+	routeSeekInterval: number;
+	seekTimeout: number;
+	closeController: AbortController;
+	private _ackCallbacks: Map<
+		string,
+		{
+			promise: Promise<void>;
+			callback: (
+				ack: ACK,
+				messageThrough: PeerStreams,
+				messageFrom?: PeerStreams
+			) => void;
+			timeout: ReturnType<typeof setTimeout>;
+		}
+	> = new Map();
 
 	constructor(
 		readonly components: DirectStreamComponents,
@@ -375,46 +441,82 @@ export abstract class DirectStream<
 		super();
 		const {
 			canRelayMessage = false,
-			emitSelf = false,
 			messageProcessingConcurrency = 10,
-			pingInterval = 10 * 1000,
 			maxInboundStreams,
 			maxOutboundStreams,
 			signaturePolicy = "StictSign",
-			connectionManager = { autoDial: true }
+			connectionManager,
+			routeSeekInterval = ROUTE_UPDATE_DELAY_FACTOR,
+			seekTimeout = SEEK_DELIVERY_TIMEOUT
 		} = options || {};
 
 		const signKey = getKeypairFromPeerId(components.peerId);
+		this.seekTimeout = seekTimeout;
 		this.sign = signKey.sign.bind(signKey);
 		this.peerId = components.peerId;
-		this.peerIdStr = components.peerId.toString();
 		this.publicKey = signKey.publicKey;
 		this.publicKeyHash = signKey.publicKey.hashcode();
 		this.multicodecs = multicodecs;
 		this.started = false;
 		this.peers = new Map<string, PeerStreams>();
-		this.helloMap = new Map();
-		this.multiaddrsMap = new Map();
 		this.routes = new Routes(this.publicKeyHash);
 		this.canRelayMessage = canRelayMessage;
-		this.emitSelf = emitSelf;
+		this.healthChecks = new Map();
+		this.routeSeekInterval = routeSeekInterval;
 		this.queue = new Queue({ concurrency: messageProcessingConcurrency });
-		this.earlyGoodbyes = new Map();
 		this.maxInboundStreams = maxInboundStreams;
 		this.maxOutboundStreams = maxOutboundStreams;
-		this.seenCache = new Cache({ max: 1e3, ttl: 10 * 60 * 1e3 });
+		this.seenCache = new Cache({ max: 1e6, ttl: 10 * 60 * 1e3 });
+
 		this.peerKeyHashToPublicKey = new Map();
-		this.peerIdToPublicKey = new Map();
-		this.pingInterval = pingInterval;
 		this._onIncomingStream = this._onIncomingStream.bind(this);
 		this.onPeerConnected = this.onPeerConnected.bind(this);
 		this.onPeerDisconnected = this.onPeerDisconnected.bind(this);
 		this.signaturePolicy = signaturePolicy;
-		this.connectionManagerOptions = connectionManager;
-		this.recentDials = new Cache({
-			ttl: connectionManager.retryDelay || 60 * 1000,
-			max: 1e3
-		});
+
+		if (connectionManager === false || connectionManager === null) {
+			this.connectionManagerOptions = {
+				maxConnections: Number.MAX_SAFE_INTEGER,
+				minConnections: 0,
+				dialer: undefined,
+				pruner: undefined
+			};
+		} else {
+			this.connectionManagerOptions = {
+				maxConnections: DEFAULT_MAX_CONNECTIONS,
+				minConnections: DEFAULT_MIN_CONNECTIONS,
+				...connectionManager,
+				dialer:
+					connectionManager?.dialer !== false &&
+					connectionManager?.dialer !== null
+						? { retryDelay: 60 * 1000, ...connectionManager?.dialer }
+						: undefined,
+				pruner:
+					connectionManager?.pruner !== false &&
+					connectionManager?.pruner !== null
+						? {
+								connectionTimeout: DEFAULT_PRUNED_CONNNECTIONS_TIMEOUT,
+								interval: DEFAULT_PRUNE_CONNECTIONS_INTERVAL,
+								maxBuffer: MAX_QUEUED_BYTES,
+								...connectionManager?.pruner
+							}
+						: undefined
+			};
+		}
+
+		this.recentDials = this.connectionManagerOptions.dialer
+			? new Cache({
+					ttl: this.connectionManagerOptions.dialer.retryDelay,
+					max: 1e3
+				})
+			: undefined;
+
+		this.prunedConnectionsCache = this.connectionManagerOptions.pruner
+			? new Cache({
+					max: 1e6,
+					ttl: this.connectionManagerOptions.pruner.connectionTimeout
+				})
+			: undefined;
 	}
 
 	async start() {
@@ -422,18 +524,12 @@ export abstract class DirectStream<
 			return;
 		}
 
-		logger.debug("starting");
+		await ready;
 
-		// register protocol with topology
-		// Topology callbacks called on connection manager changes
-		this._registrarTopologyIds = await Promise.all(
-			this.multicodecs.map((multicodec) =>
-				this.components.registrar.register(multicodec, {
-					onConnect: this.onPeerConnected.bind(this),
-					onDisconnect: this.onPeerDisconnected.bind(this)
-				})
-			)
-		);
+		this.closeController = new AbortController();
+		this.started = true;
+
+		logger.debug("starting");
 
 		// Incoming streams
 		// Called after a peer dials us
@@ -441,19 +537,23 @@ export abstract class DirectStream<
 			this.multicodecs.map((multicodec) =>
 				this.components.registrar.handle(multicodec, this._onIncomingStream, {
 					maxInboundStreams: this.maxInboundStreams,
-					maxOutboundStreams: this.maxOutboundStreams
+					maxOutboundStreams: this.maxOutboundStreams,
+					runOnTransientConnection: false
 				})
 			)
 		);
 
-		// TODO remove/modify when https://github.com/libp2p/js-libp2p/issues/2036 is resolved
-		this.components.events.addEventListener("connection:open", (e) => {
-			if (e.detail.multiplexer === "/webrtc") {
-				this.onPeerConnected(e.detail.remotePeer, e.detail);
-			}
-		});
-
-		this.started = true;
+		// register protocol with topology
+		// Topology callbacks called on connection manager changes
+		this._registrarTopologyIds = await Promise.all(
+			this.multicodecs.map((multicodec) =>
+				this.components.registrar.register(multicodec, {
+					onConnect: this.onPeerConnected.bind(this),
+					onDisconnect: this.onPeerDisconnected.bind(this),
+					notifyOnTransient: false
+				})
+			)
+		);
 
 		// All existing connections are like new ones for us. To deduplication on remotes so we only resuse one connection for this protocol (we could be connected with many connections)
 		const peerToConnections: Map<string, Connection[]> = new Map();
@@ -476,37 +576,24 @@ export abstract class DirectStream<
 				}
 			}
 
-			await this.onPeerConnected(conn.remotePeer, conn, { fromExisting: true });
+			await this.onPeerConnected(conn.remotePeer, conn);
 		}
-
-		const pingJob = async () => {
-			// TODO don't use setInterval but waitFor previous done to be done
-			await this.pingJobPromise;
-			const promises: Promise<any>[] = [];
-			this.peers.forEach((peer) => {
-				promises.push(
-					this.ping(peer).catch((e) => {
-						if (e instanceof TimeoutError) {
-							// Ignore
-						} else {
-							logger.error(e);
+		if (this.connectionManagerOptions.pruner) {
+			const pruneConnectionsLoop = () => {
+				if (!this.connectionManagerOptions.pruner) {
+					return;
+				}
+				this.pruneConnectionsTimeout = setTimeout(() => {
+					this.maybePruneConnections().finally(() => {
+						if (!this.started) {
+							return;
 						}
-					})
-				);
-			});
-			promises.push(this.hello()); // Repetedly say hello to everyone to create traces in the network to measure latencies
-			this.pingJobPromise = Promise.all(promises)
-				.catch((e) => {
-					logger.error(e?.message);
-				})
-				.finally(() => {
-					if (!this.started || !this.pingInterval) {
-						return;
-					}
-					this.pingJob = setTimeout(pingJob, this.pingInterval);
-				});
-		};
-		pingJob();
+						pruneConnectionsLoop();
+					});
+				}, this.connectionManagerOptions.pruner.interval);
+			};
+			pruneConnectionsLoop();
+		}
 	}
 
 	/**
@@ -517,9 +604,9 @@ export abstract class DirectStream<
 			return;
 		}
 		this.started = false;
+		this.closeController.abort();
 
-		clearTimeout(this.pingJob);
-		await this.pingJobPromise;
+		clearTimeout(this.pruneConnectionsTimeout);
 
 		await Promise.all(
 			this.multicodecs.map((x) => this.components.registrar.unhandle(x))
@@ -529,6 +616,11 @@ export abstract class DirectStream<
 		for (const peerStreams of this.peers.values()) {
 			await peerStreams.close();
 		}
+		for (const [k, v] of this.healthChecks) {
+			clearTimeout(v);
+		}
+		this.healthChecks.clear();
+		this.prunedConnectionsCache?.clear();
 
 		// unregister protocol and handlers
 		if (this._registrarTopologyIds != null) {
@@ -538,14 +630,15 @@ export abstract class DirectStream<
 		}
 
 		this.queue.clear();
-		this.helloMap.clear();
-		this.multiaddrsMap.clear();
-		this.earlyGoodbyes.clear();
 		this.peers.clear();
 		this.seenCache.clear();
 		this.routes.clear();
 		this.peerKeyHashToPublicKey.clear();
-		this.peerIdToPublicKey.clear();
+
+		for (const [k, v] of this._ackCallbacks) {
+			clearTimeout(v.timeout);
+		}
+		this._ackCallbacks.clear();
 		logger.debug("stopped");
 	}
 
@@ -570,6 +663,13 @@ export abstract class DirectStream<
 		}
 
 		const publicKey = getPublicKeyFromPeerId(peerId);
+
+		if (this.prunedConnectionsCache?.has(publicKey.hashcode())) {
+			await connection.close();
+			await this.components.peerStore.delete(peerId);
+			return;
+		}
+
 		const peer = this.addPeer(
 			peerId,
 			publicKey,
@@ -577,76 +677,30 @@ export abstract class DirectStream<
 			connection.id
 		);
 		const inboundStream = peer.attachInboundStream(stream);
-		this.processMessages(peerId, inboundStream, peer).catch((err) => {
-			logger.error(err);
-		});
+		this.processMessages(peer.publicKey, inboundStream, peer).catch(logError);
 	}
 
 	/**
 	 * Registrar notifies an established connection with protocol
 	 */
-	public async onPeerConnected(
-		peerId: PeerId,
-		conn: Connection,
-		properties?: { fromExisting?: boolean }
-	) {
-		if (conn.transient) {
+	public async onPeerConnected(peerId: PeerId, connection: Connection) {
+		if (
+			!this.isStarted() ||
+			connection.transient ||
+			connection.status !== "open"
+		) {
 			return;
 		}
+		const peerKey = getPublicKeyFromPeerId(peerId);
 
-		if (!this.isStarted() || conn.status !== "open") {
-			return;
+		if (this.prunedConnectionsCache?.has(peerKey.hashcode())) {
+			await connection.close();
+			await this.components.peerStore.delete(peerId);
+			return; // we recently pruned this connect, dont allow it to connect for a while
 		}
 
 		try {
-			// TODO remove/modify when https://github.com/libp2p/js-libp2p/issues/2036 is resolved
-
-			let closeFn: (() => void) | undefined = undefined;
-			const close = () => {
-				closeFn?.();
-			};
-			this.addEventListener("close", close);
-			const result = await waitForAsync(
-				async () => {
-					try {
-						const hasProtocol = await this.components.peerStore
-							.get(peerId)
-							.then((x) =>
-								this.multicodecs.find((y) => x.protocols.includes(y))
-							);
-						if (!hasProtocol) {
-							return;
-						}
-					} catch (error: any) {
-						if (error.code === "ERR_NOT_FOUND") {
-							return;
-						}
-						throw error;
-					}
-
-					return true;
-				},
-				{
-					delayInterval: 100,
-					timeout: 1e4,
-					stopperCallback: (cb) => {
-						closeFn = cb;
-					}
-				}
-			).finally(() => {
-				this.removeEventListener("close", close);
-			});
-			if (!result) {
-				return;
-			}
-		} catch (error) {
-			return;
-		}
-		try {
-			const peerKey = getPublicKeyFromPeerId(peerId);
-			const peerKeyHash = peerKey.hashcode();
-
-			for (const existingStreams of conn.streams) {
+			for (const existingStreams of connection.streams) {
 				if (
 					existingStreams.protocol &&
 					this.multicodecs.includes(existingStreams.protocol) &&
@@ -670,29 +724,13 @@ export abstract class DirectStream<
 				}
 
 				try {
-					stream = await conn.newStream(this.multicodecs);
+					stream = await connection.newStream(this.multicodecs);
 					if (stream.protocol == null) {
 						stream.abort(new Error("Stream was not multiplexed"));
 						return;
 					}
-					peer = this.addPeer(peerId, peerKey, stream.protocol!, conn.id); // TODO types
+					peer = this.addPeer(peerId, peerKey, stream.protocol!, connection.id); // TODO types
 					await peer.attachOutboundStream(stream);
-
-					// TODO do we want to do this?
-					/* if (!peer.inboundStream) {
-						const inboundStream = conn.streams.find(
-							(x) =>
-								x.stat.protocol &&
-								this.multicodecs.includes(x.stat.protocol) &&
-								x.stat.direction === "inbound"
-						);
-						if (inboundStream) {
-							this._onIncomingStream({
-								connection: conn,
-								stream: inboundStream,
-							});
-						}
-					} */
 				} catch (error: any) {
 					if (error.code === "ERR_UNSUPPORTED_PROTOCOL") {
 						await delay(100);
@@ -700,7 +738,7 @@ export abstract class DirectStream<
 					}
 
 					if (
-						conn.status !== "open" ||
+						connection.status !== "open" ||
 						error?.message === "Muxer already closed" ||
 						error.code === "ERR_STREAM_RESET"
 					) {
@@ -715,110 +753,18 @@ export abstract class DirectStream<
 				return;
 			}
 
-			if (properties?.fromExisting) {
-				return; // we return here because we will enter this method once more once the protocol has been registered for the remote peer
-			}
-
-			// Add connection with assumed large latency
-			this.peerIdToPublicKey.set(peerId.toString(), peerKey);
-			const promises: Promise<any>[] = [];
-
-			/* if (!existingStream)  */ {
-				this.addRouteConnection(
-					this.publicKey,
-					peerKey,
-					Number.MAX_SAFE_INTEGER
-				);
-
-				// Get accurate latency
-				promises.push(this.ping(peer));
-
-				// Say hello
-				promises.push(
-					this.publishMessage(
-						this.components.peerId,
-						await new Hello({
-							multiaddrs: this.components.addressManager
-								.getAddresses()
-								.map((x) => x.toString())
-						}).sign(this.sign),
-						[peer]
-					)
-				);
-				// Send my goodbye early if I disconnect for some reason, (so my peer can say goodbye for me)
-				// TODO add custom condition fn for doing below
-				promises.push(
-					this.publishMessage(
-						this.components.peerId,
-						await new Goodbye({ early: true }).sign(this.sign),
-						[peer]
-					)
-				);
-
-				// replay all hellos
-				for (const [sender, hellos] of this.helloMap) {
-					if (sender === peerKeyHash) {
-						// Don't say hellos from sender to same sender (uneccessary)
-						continue;
-					}
-
-					outer: for (const [key, hello] of hellos) {
-						if (!hello.header.verify()) {
-							hellos.delete(key);
-						}
-						for (const signer of hello.signatures.publicKeys) {
-							if (!this.routes.hasNode(signer.hashcode())) {
-								// purge this hello since it has travelled a path that no longer exist
-								hellos.delete(key);
-								continue outer;
-							}
-						}
-
-						promises.push(
-							this.publishMessage(this.components.peerId, hello, [peer])
-						);
-					}
-				}
-			}
-			const resolved = await Promise.all(promises);
-			return resolved;
+			this.addRouteConnection(
+				this.publicKeyHash,
+				peerKey.hashcode(),
+				peerKey,
+				0,
+				+new Date()
+			);
 		} catch (err: any) {
 			logger.error(err);
 		}
 	}
 
-	private addRouteConnection(
-		from: PublicSignKey,
-		to: PublicSignKey,
-		latency: number
-	) {
-		this.peerKeyHashToPublicKey.set(from.hashcode(), from);
-		this.peerKeyHashToPublicKey.set(to.hashcode(), to);
-		const links = this.routes.addLink(from.hashcode(), to.hashcode(), latency);
-		for (const added of links) {
-			const key = this.peerKeyHashToPublicKey.get(added);
-			if (key?.equals(this.publicKey) === false) {
-				this.onPeerReachable(key!);
-			}
-		}
-	}
-
-	removeRouteConnection(from: PublicSignKey, to: PublicSignKey) {
-		const has = this.routes.hasNode(to.hashcode());
-		if (!has) {
-			this.onPeerUnreachable(to);
-		} else {
-			const links = this.routes.deleteLink(from.hashcode(), to.hashcode());
-			for (const deleted of links) {
-				const key = this.peerKeyHashToPublicKey.get(deleted)!;
-				this.peerKeyHashToPublicKey.delete(deleted);
-				if (key?.equals(this.publicKey) === false) {
-					this.onPeerUnreachable(key!);
-				}
-			}
-		}
-	}
-
 	/**
 	 * Registrar notifies a closing connection with pubsub protocol
 	 */
@@ -826,6 +772,7 @@ export abstract class DirectStream<
 		// PeerId could be me, if so, it means that I am disconnecting
 		const peerKey = getPublicKeyFromPeerId(peerId);
 		const peerKeyHash = peerKey.hashcode();
+
 		const connections = this.components.connectionManager
 			.getConnectionsMap()
 			.get(peerId);
@@ -845,22 +792,69 @@ export abstract class DirectStream<
 
 		if (!this.publicKey.equals(peerKey)) {
 			await this._removePeer(peerKey);
-			this.removeRouteConnection(this.publicKey, peerKey);
 
 			// Notify network
-			const earlyGoodBye = this.earlyGoodbyes.get(peerKeyHash);
-			if (earlyGoodBye) {
-				earlyGoodBye.early = false;
-				await earlyGoodBye.sign(this.sign);
-				await this.publishMessage(this.components.peerId, earlyGoodBye);
-				this.earlyGoodbyes.delete(peerKeyHash);
+			const dependent = this.routes.getDependent(peerKeyHash);
+			this.removeRouteConnection(peerKeyHash, true);
+
+			if (dependent.length > 0) {
+				await this.publishMessage(
+					this.publicKey,
+					await new Goodbye({
+						leaving: [peerKeyHash],
+						header: new MessageHeader({
+							mode: new SilentDelivery({ to: dependent, redundancy: 2 })
+						})
+					}).sign(this.sign)
+				);
 			}
-			this.peerIdToPublicKey.delete(peerId.toString());
 		}
 
 		logger.debug("connection ended:" + peerKey.toString());
 	}
 
+	public removeRouteConnection(hash: string, neigbour: boolean) {
+		const unreachable = neigbour
+			? this.routes.removeNeighbour(hash)
+			: this.routes.removeTarget(hash);
+		for (const node of unreachable) {
+			this.onPeerUnreachable(node); // TODO types
+			this.peerKeyHashToPublicKey.delete(node);
+		}
+	}
+
+	public addRouteConnection(
+		from: string,
+		neighbour: string,
+		target: PublicSignKey,
+		distance: number,
+		session: number,
+		pending = false
+	) {
+		const targetHash = typeof target === "string" ? target : target.hashcode();
+		const wasReachable =
+			from === this.publicKeyHash
+				? this.routes.isReachable(from, targetHash)
+				: true;
+		if (pending) {
+			this.routes.addPendingRouteConnection(session, {
+				distance,
+				from,
+				neighbour,
+				target: targetHash
+			});
+		} else {
+			this.routes.add(from, neighbour, targetHash, distance, session);
+		}
+
+		const newPeer =
+			wasReachable === false && this.routes.isReachable(from, targetHash);
+		if (newPeer) {
+			this.peerKeyHashToPublicKey.set(target.hashcode(), target);
+			this.onPeerReachable(target); // TODO types
+		}
+	}
+
 	/**
 	 * invoked when a new peer becomes reachable
 	 * @param publicKeyHash
@@ -876,13 +870,14 @@ export abstract class DirectStream<
 	 * invoked when a new peer becomes unreachable
 	 * @param publicKeyHash
 	 */
-	public onPeerUnreachable(publicKey: PublicSignKey) {
+	public onPeerUnreachable(hash: string) {
 		// override this fn
-		this.helloMap.delete(publicKey.hashcode());
-		this.multiaddrsMap.delete(publicKey.hashcode());
 
 		this.dispatchEvent(
-			new CustomEvent("peer:unreachable", { detail: publicKey })
+			// TODO types
+			new CustomEvent("peer:unreachable", {
+				detail: this.peerKeyHashToPublicKey.get(hash)!
+			})
 		);
 	}
 
@@ -896,6 +891,13 @@ export abstract class DirectStream<
 		connId: string
 	): PeerStreams {
 		const publicKeyHash = publicKey.hashcode();
+
+		const hc = this.healthChecks.get(publicKeyHash);
+		if (hc) {
+			clearTimeout(hc);
+			this.healthChecks.delete(publicKeyHash);
+		}
+
 		const existing = this.peers.get(publicKeyHash);
 
 		// If peer streams already exists, do nothing
@@ -920,6 +922,7 @@ export abstract class DirectStream<
 		peerStreams.addEventListener("close", () => this._removePeer(publicKey), {
 			once: true
 		});
+
 		return peerStreams;
 	}
 
@@ -949,44 +952,14 @@ export abstract class DirectStream<
 	 * Responsible for processing each RPC message received by other peers.
 	 */
 	async processMessages(
-		peerId: PeerId,
+		peerId: PublicSignKey,
 		stream: AsyncIterable<Uint8ArrayList>,
 		peerStreams: PeerStreams
 	) {
 		try {
 			await pipe(stream, async (source) => {
 				for await (const data of source) {
-					const msgId = await getMsgId(data);
-					if (this.seenCache.has(msgId)) {
-						// we got message that WE sent?
-
-						/**
-							 * Most propobable reason why we arrive  here is a race condition/issue
-							
-							┌─┐
-							│0│
-							└△┘
-							┌▽┐
-							│1│
-							└△┘
-							┌▽┐
-							│2│
-							└─┘
-							
-							from 2s perspective, 
-	
-							if everyone conents to each other at the same time, then 0 will say hello to 1 and 1 will save that hello to resend to 2 if 2 ever connects
-							but two is already connected by onPeerConnected has not been invoked yet, so the hello message gets forwarded,
-							and later onPeerConnected gets invoked on 1, and the same message gets resent to 2
-							 */
-
-						continue;
-					}
-
-					this.seenCache.add(msgId);
-					this.processRpc(peerId, peerStreams, data).catch((err) =>
-						logger.warn(err)
-					);
+					this.processRpc(peerId, peerStreams, data).catch(logError);
 				}
 			});
 		} catch (err: any) {
@@ -1004,15 +977,10 @@ export abstract class DirectStream<
 	 * Handles an rpc request from a peer
 	 */
 	async processRpc(
-		from: PeerId,
+		from: PublicSignKey,
 		peerStreams: PeerStreams,
 		message: Uint8ArrayList
 	): Promise<boolean> {
-		if (!this.acceptFrom(from)) {
-			logger.debug("received message from unacceptable peer %p", from);
-			return false;
-		}
-
 		// logger.debug("rpc from " + from + ", " + this.peerIdStr);
 
 		if (message.length > 0) {
@@ -1025,31 +993,36 @@ export abstract class DirectStream<
 						logger.error(err);
 					}
 				})
-				.catch((err) => logger.warn(err));
+				.catch(logError);
 		}
 
 		return true;
 	}
 
+	private async modifySeenCache(
+		message: Uint8Array,
+		getIdFn: (bytes: Uint8Array) => Promise<string> = getMsgId
+	) {
+		const msgId = await getIdFn(message);
+		const seen = this.seenCache.get(msgId);
+		this.seenCache.add(msgId, seen ? seen + 1 : 1);
+		return seen || 0;
+	}
+
 	/**
 	 * Handles a message from a peer
 	 */
 	async processMessage(
-		from: PeerId,
+		from: PublicSignKey,
 		peerStream: PeerStreams,
 		msg: Uint8ArrayList
 	) {
-		if (!from.publicKey) {
-			return;
-		}
-
-		if (this.components.peerId.equals(from) && !this.emitSelf) {
+		if (!this.started) {
 			return;
 		}
 
 		// Ensure the message is valid before processing it
 		const message: Message | undefined = Message.from(msg);
-
 		this.dispatchEvent(
 			new CustomEvent("message", {
 				detail: message
@@ -1057,265 +1030,351 @@ export abstract class DirectStream<
 		);
 
 		if (message instanceof DataMessage) {
-			await this.onDataMessage(from, peerStream, message);
-		} else if (message instanceof Hello) {
-			await this.onHello(from, peerStream, message);
-		} else if (message instanceof Goodbye) {
-			await this.onGoodbye(from, peerStream, message);
-		} else if (message instanceof PingPong) {
-			await this.onPing(from, peerStream, message);
+			// DONT await this since it might introduce a dead-lock
+			this._onDataMessage(from, peerStream, msg, message).catch(logError);
 		} else {
-			throw new Error("Unsupported");
+			if (message instanceof ACK) {
+				this.onAck(from, peerStream, msg, message).catch(logError);
+			} else if (message instanceof Goodbye) {
+				this.onGoodBye(from, peerStream, msg, message).catch(logError);
+			} else {
+				throw new Error("Unsupported message type");
+			}
 		}
 	}
 
-	async onDataMessage(
-		from: PeerId,
+	public shouldIgnore(message: DataMessage, seenBefore: number) {
+		const fromMe = message.header.signatures?.publicKeys.find((x) =>
+			x.equals(this.publicKey)
+		);
+
+		if (fromMe) {
+			return true;
+		}
+
+		if (
+			(seenBefore > 0 &&
+				message.header.mode instanceof SeekDelivery === false) ||
+			(message.header.mode instanceof SeekDelivery &&
+				seenBefore >= message.header.mode.redundancy)
+		) {
+			return true;
+		}
+
+		return false;
+	}
+
+	public async onDataMessage(
+		from: PublicSignKey,
 		peerStream: PeerStreams,
-		message: DataMessage
+		message: DataMessage,
+		seenBefore: number
 	) {
-		const isFromSelf = this.components.peerId.equals(from);
-		if (!isFromSelf || this.emitSelf) {
-			const isForAll = message.to.length === 0;
-			const isForMe =
-				!isForAll && message.to.find((x) => x === this.publicKeyHash);
-			if (isForAll || isForMe) {
-				if (
-					this.signaturePolicy === "StictSign" &&
-					!(await message.verify(this.signaturePolicy === "StictSign"))
-				) {
-					// we don't verify messages we don't dispatch because of the performance penalty // TODO add opts for this
-					logger.warn("Recieved message with invalid signature or timestamp");
-					return false;
-				}
+		if (this.shouldIgnore(message, seenBefore)) {
+			return false;
+		}
 
+		let isForMe = false;
+		if (message.header.mode instanceof AnyWhere) {
+			isForMe = true;
+		} else {
+			const isFromSelf = this.publicKey.equals(from);
+			if (!isFromSelf) {
+				isForMe =
+					message.header.mode.to == null ||
+					message.header.mode.to.find((x) => x === this.publicKeyHash) != null;
+			}
+		}
+
+		if (isForMe) {
+			if ((await this.maybeVerifyMessage(message)) === false) {
+				// we don't verify messages we don't dispatch because of the performance penalty // TODO add opts for this
+				logger.warn("Recieved message with invalid signature or timestamp");
+				return false;
+			}
+
+			await this.acknowledgeMessage(peerStream, message, seenBefore);
+
+			if (seenBefore === 0 && message.data) {
 				this.dispatchEvent(
 					new CustomEvent("data", {
 						detail: message
 					})
 				);
 			}
-			if (isForMe && message.to.length === 1) {
+		}
+
+		if (
+			message.header.mode instanceof SilentDelivery ||
+			message.header.mode instanceof AcknowledgeDelivery
+		) {
+			if (
+				message.header.mode.to &&
+				message.header.mode.to.length === 1 &&
+				message.header.mode.to[0] === this.publicKeyHash
+			) {
 				// dont forward this message anymore because it was meant ONLY for me
 				return true;
 			}
 		}
 
 		// Forward
-		await this.relayMessage(from, message);
-		return true;
-	}
-
-	async onHello(from: PeerId, peerStream: PeerStreams, message: Hello) {
-		if (!(await message.verify(false))) {
-			const a = message.header.verify();
-			const b =
-				message.networkInfo.pingLatencies.length ===
-				message.signatures.signatures.length - 1;
-			logger.warn(
-				`Recieved hello message that did not verify. Header: ${a}, Ping info ${b}, Signatures ${
-					a && b
-				}`
-			);
-			return false;
+		if (message.header.mode instanceof SeekDelivery || seenBefore === 0) {
+			// DONT await this since it might introduce a dead-lock
+			if (message.header.mode instanceof SeekDelivery) {
+				if (seenBefore < message.header.mode.redundancy) {
+					const to = [...this.peers.values()].filter(
+						(x) =>
+							!message.header.signatures?.publicKeys.find((y) =>
+								y.equals(x.publicKey)
+							) && x != peerStream
+					);
+					if (to.length > 0) {
+						this.relayMessage(from, message, to);
+					}
+				}
+			} else {
+				this.relayMessage(from, message);
+			}
 		}
+	}
 
-		const sender = message.sender?.hashcode();
-		if (!sender) {
-			logger.warn("Recieved hello without sender");
-			return false;
-		}
+	public async maybeVerifyMessage(message: DataMessage) {
+		return message.verify(this.signaturePolicy === "StictSign");
+	}
 
-		const signatures = message.signatures;
-		for (let i = 0; i < signatures.signatures.length - 1; i++) {
-			this.addRouteConnection(
-				signatures.signatures[i].publicKey,
-				signatures.signatures[i + 1].publicKey,
-				message.networkInfo.pingLatencies[i]
+	async acknowledgeMessage(
+		peerStream: PeerStreams,
+		message: DataMessage,
+		seenBefore: number
+	) {
+		if (
+			(message.header.mode instanceof SeekDelivery ||
+				message.header.mode instanceof AcknowledgeDelivery) &&
+			seenBefore < message.header.mode.redundancy
+		) {
+			await this.publishMessage(
+				this.publicKey,
+				await new ACK({
+					messageIdToAcknowledge: message.id,
+					seenCounter: seenBefore,
+
+					// TODO only give origin info to peers we want to connect to us
+					header: new MessageHeader({
+						mode: new TracedDelivery(
+							message.header.signatures!.publicKeys.map((x) => x.hashcode())
+						),
+
+						// include our origin if message is SeekDelivery and we have not recently pruned a connection to this peer
+						origin:
+							message.header.mode instanceof SeekDelivery &&
+							!message.header.signatures!.publicKeys.find(
+								(x) => this.prunedConnectionsCache?.has(x.hashcode())
+							)
+								? new MultiAddrinfo(
+										this.components.addressManager
+											.getAddresses()
+											.map((x) => x.toString())
+									)
+								: undefined
+					})
+				}).sign(this.sign),
+				[peerStream]
 			);
 		}
+	}
 
-		message.networkInfo.pingLatencies.push(
-			peerStream.pingLatency || 4294967295
-		); // TODO don't propagate if latency is high?
-
-		await message.sign(this.sign); // sign it so othere peers can now I have seen it (and can build a network graph from trace info)
-
-		let hellos = this.helloMap.get(sender);
-		if (!hellos) {
-			hellos = new Map();
-			this.helloMap.set(sender, hellos);
-		}
-
-		this.multiaddrsMap.set(sender, message.multiaddrs);
-
-		const helloSignaturHash = await message.signatures.hashPublicKeys();
-		const existingHello = hellos.get(helloSignaturHash);
-		if (existingHello) {
-			if (existingHello.header.expires < message.header.expires) {
-				hellos.set(helloSignaturHash, message);
-			}
-		} else {
-			hellos.set(helloSignaturHash, message);
-		}
+	private async _onDataMessage(
+		from: PublicSignKey,
+		peerStream: PeerStreams,
+		messageBytes: Uint8ArrayList | Uint8Array,
+		message: DataMessage
+	) {
+		const seenBefore = await this.modifySeenCache(
+			messageBytes instanceof Uint8ArrayList
+				? messageBytes.subarray()
+				: messageBytes
+		);
 
-		// Forward
-		await this.relayMessage(from, message);
-		return true;
+		return this.onDataMessage(from, peerStream, message, seenBefore);
 	}
 
-	async onGoodbye(from: PeerId, peerStream: PeerStreams, message: Goodbye) {
-		if (!(await message.verify(false))) {
-			logger.warn("Recieved message with invalid signature or timestamp");
+	async onAck(
+		publicKey: PublicSignKey,
+		peerStream: PeerStreams,
+		messageBytes: Uint8ArrayList | Uint8Array,
+		message: ACK
+	) {
+		const seenBefore = await this.modifySeenCache(
+			messageBytes instanceof Uint8Array
+				? messageBytes
+				: messageBytes.subarray(),
+			(bytes) => sha256Base64(bytes)
+		);
+
+		if (seenBefore > 1) {
+			logger.debug(
+				"Received message already seen of type: " + message.constructor.name
+			);
 			return false;
 		}
 
-		const sender = message.sender?.hashcode();
-		if (!sender) {
-			logger.warn("Recieved hello without sender");
+		if (!(await message.verify(true))) {
+			logger.warn(`Recieved ACK message that did not verify`);
 			return false;
 		}
 
-		const peerKey = getPublicKeyFromPeerId(from);
-		const peerKeyHash = peerKey.hashcode();
-		if (message.early) {
-			this.earlyGoodbyes.set(peerKeyHash, message);
-		} else {
-			const signatures = message.signatures;
-			/*  TODO Should we update routes on goodbye?
-			for (let i = 1; i < signatures.signatures.length - 1; i++) {
-				this.addRouteConnection(
-					signatures.signatures[i].publicKey,
-					signatures.signatures[i + 1].publicKey
-				);
-			} 
-			*/
-
-			//let neighbour = message.trace[1] || this.peerIdStr;
-			this.removeRouteConnection(
-				signatures.signatures[0].publicKey,
-				signatures.signatures[1].publicKey || this.publicKey
-			);
+		const messageIdString = toBase64(message.messageIdToAcknowledge);
+		const myIndex = message.header.mode.trace.findIndex(
+			(x) => x === this.publicKeyHash
+		);
+		const next = message.header.mode.trace[myIndex - 1];
+		const nextStream = next ? this.peers.get(next) : undefined;
 
-			const relayToPeers: PeerStreams[] = [];
-			for (const stream of this.peers.values()) {
-				if (stream.peerId.equals(from)) {
-					continue;
-				}
-				relayToPeers.push(stream);
-			}
-			await message.sign(this.sign); // sign it so othere peers can now I have seen it (and can build a network graph from trace info)
+		this._ackCallbacks
+			.get(messageIdString)
+			?.callback(message, peerStream, nextStream);
 
-			const hellos = this.helloMap.get(sender);
-			if (hellos) {
-				const helloSignaturHash = await message.signatures.hashPublicKeys();
-				hellos.delete(helloSignaturHash);
+		// relay ACK ?
+		// send exactly backwards same route we got this message
+		if (nextStream) {
+			await this.publishMessage(this.publicKey, message, [nextStream], true);
+		} else {
+			// if origin exist (we can connect to remote peer) && we have autodialer turned on
+			if (message.header.origin && this.connectionManagerOptions.dialer) {
+				this.maybeConnectDirectly(
+					message.header.signatures!.publicKeys[0].hashcode(),
+					message.header.origin
+				);
 			}
-
-			// Forward
-			await this.relayMessage(from, message);
 		}
-		return true;
 	}
 
-	async onPing(from: PeerId, peerStream: PeerStreams, message: PingPong) {
-		if (message instanceof Ping) {
-			// respond with pong
-			await this.publishMessage(
-				this.components.peerId,
-				new Pong(message.pingBytes),
-				[peerStream]
+	async onGoodBye(
+		publicKey: PublicSignKey,
+		peerStream: PeerStreams,
+		messageBytes: Uint8ArrayList | Uint8Array,
+		message: Goodbye
+	) {
+		const seenBefore = await this.modifySeenCache(
+			messageBytes instanceof Uint8Array
+				? messageBytes
+				: messageBytes.subarray()
+		);
+
+		if (seenBefore > 0) {
+			logger.debug(
+				"Received message already seen of type: " + message.constructor.name
 			);
-		} else if (message instanceof Pong) {
-			// Let the (waiting) thread know that we have received the pong
-			peerStream.pingJob?.resolve();
-		} else {
-			throw new Error("Unsupported");
+			return;
 		}
-	}
 
-	async ping(stream: PeerStreams): Promise<number | undefined> {
-		return new Promise<number | undefined>((resolve, reject) => {
-			stream.pingJob?.abort();
-			const ping = new Ping();
-			const start = +new Date();
-			const timeout = setTimeout(() => {
-				reject(new TimeoutError("Ping timed out"));
-			}, 10000);
-			const resolver = () => {
-				const end = +new Date();
-				clearTimeout(timeout);
-
-				// TODO what happens if a peer send a ping back then leaves? Any problems?
-				const latency = end - start;
-				stream.pingLatency = latency;
-				this.addRouteConnection(this.publicKey, stream.publicKey, latency);
-				resolve(undefined);
-			};
-			stream.pingJob = {
-				resolve: resolver,
-				abort: () => {
-					clearTimeout(timeout);
-					resolve(undefined);
-				}
-			};
-			this.publishMessage(this.components.peerId, ping, [stream]).catch(
-				(err) => {
-					clearTimeout(timeout);
-					reject(err);
+		if (!(await message.verify(true))) {
+			logger.warn(`Recieved ACK message that did not verify`);
+			return false;
+		}
+
+		const filteredLeaving = message.leaving.filter((x) =>
+			this.routes.hasTarget(x)
+		);
+
+		if (filteredLeaving.length > 0) {
+			this.publish(new Uint8Array(0), {
+				mode: new SeekDelivery({
+					to: filteredLeaving,
+					redundancy: DEFAULT_SEEK_MESSAGE_REDUDANCY
+				})
+			}).catch((e) => {
+				if (e instanceof TimeoutError || e instanceof AbortError) {
+					// peer left or closed
+				} else {
+					throw e;
 				}
+			}); // this will remove the target if it is still not reable
+		}
+
+		for (const target of message.leaving) {
+			// relay message to every one who previously talked to this peer
+			const dependent = this.routes.getDependent(target);
+			message.header.mode.to = [...message.header.mode.to, ...dependent];
+			message.header.mode.to = message.header.mode.to.filter(
+				(x) => x !== this.publicKeyHash
 			);
-		});
-	}
 
-	/**
-	 * Whether to accept a message from a peer
-	 * Override to create a graylist
-	 */
-	acceptFrom(id: PeerId) {
-		return true;
+			if (message.header.mode.to.length > 0) {
+				await this.publishMessage(publicKey, message, undefined, true);
+			}
+		}
 	}
 
 	async createMessage(
-		data: Uint8Array | Uint8ArrayList,
-		options?: { to?: (string | PublicSignKey | PeerId)[] | Set<string> }
+		data: Uint8Array | Uint8ArrayList | undefined,
+		options: WithTo | WithMode
 	) {
 		// dispatch the event if we are interested
-		let toHashes: string[];
-		if (options?.to) {
-			if (options.to instanceof Set) {
-				toHashes = new Array(options.to.size);
-			} else {
-				toHashes = new Array(options.to.length);
+
+		let mode: SilentDelivery | SeekDelivery | AcknowledgeDelivery | AnyWhere = (
+			options as WithMode
+		).mode
+			? (options as WithMode).mode!
+			: new SilentDelivery({
+					to: (options as WithTo).to!,
+					redundancy: DEFAULT_SILENT_MESSAGE_REDUDANCY
+				});
+
+		if (
+			mode instanceof AcknowledgeDelivery ||
+			mode instanceof SilentDelivery ||
+			mode instanceof SeekDelivery
+		) {
+			if (mode.to?.find((x) => x === this.publicKeyHash)) {
+				mode.to = mode.to.filter((x) => x !== this.publicKeyHash);
 			}
+		}
 
-			let i = 0;
-			for (const to of options.to) {
-				toHashes[i++] =
-					to instanceof PublicSignKey
-						? to.hashcode()
-						: typeof to === "string"
-						? to
-						: getPublicKeyFromPeerId(to).hashcode();
+		if (mode instanceof AcknowledgeDelivery || mode instanceof SilentDelivery) {
+			const now = +new Date();
+			for (const hash of mode.to) {
+				const neighbourRoutes = this.routes.routes
+					.get(this.publicKeyHash)
+					?.get(hash);
+				if (
+					!neighbourRoutes ||
+					now - neighbourRoutes.session >
+						neighbourRoutes.list.length * this.routeSeekInterval
+				) {
+					mode = new SeekDelivery({
+						to: mode.to,
+						redundancy: DEFAULT_SEEK_MESSAGE_REDUDANCY
+					});
+					break;
+				}
 			}
-		} else {
-			toHashes = [];
 		}
+
 		const message = new DataMessage({
 			data: data instanceof Uint8ArrayList ? data.subarray() : data,
-			to: toHashes
+			header: new MessageHeader({ mode })
 		});
-		if (this.signaturePolicy === "StictSign") {
+
+		if (
+			this.signaturePolicy === "StictSign" ||
+			mode instanceof SeekDelivery ||
+			mode instanceof AcknowledgeDelivery
+		) {
 			await message.sign(this.sign);
 		}
+
 		return message;
 	}
 	/**
 	 * Publishes messages to all peers
 	 */
 	async publish(
-		data: Uint8Array | Uint8ArrayList,
-		options?: { to?: (string | PublicSignKey | PeerId)[] | Set<string> }
+		data: Uint8Array | Uint8ArrayList | undefined,
+		options: WithMode | WithTo = {
+			mode: new SeekDelivery({ redundancy: DEFAULT_SEEK_MESSAGE_REDUDANCY })
+		}
 	): Promise<Uint8Array> {
 		if (!this.started) {
 			throw new Error("Not started");
@@ -1323,274 +1382,361 @@ export abstract class DirectStream<
 
 		const message = await this.createMessage(data, options);
 
-		if (this.emitSelf) {
-			super.dispatchEvent(
-				new CustomEvent("data", {
-					detail: 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;
 	}
 
-	public async hello(data?: Uint8Array): Promise<void> {
-		if (!this.started) {
-			return;
-		}
-
-		// send to all the other peers
-		await this.publishMessage(
-			this.components.peerId,
-			await new Hello({
-				multiaddrs: this.components.addressManager
-					.getAddresses()
-					.map((x) => x.toString()),
-				data
-			}).sign(this.sign.bind(this))
-		);
-	}
-
 	public async relayMessage(
-		from: PeerId,
+		from: PublicSignKey,
 		message: Message,
-		to?: PeerStreams[] | PeerMap<PeerStreams>
+		to?: PeerStreams[] | Map<string, PeerStreams>
 	) {
 		if (this.canRelayMessage) {
+			if (message instanceof DataMessage) {
+				if (
+					message.header.mode instanceof AcknowledgeDelivery ||
+					message.header.mode instanceof SeekDelivery
+				) {
+					await message.sign(this.sign);
+				}
+			}
+
 			return this.publishMessage(from, message, to, true);
 		} else {
-			logger.debug("received message we didn't subscribe to. Dropping.");
+			logger.debug("Received a message to relay but canRelayMessage is false");
 		}
 	}
-	public async publishMessage(
-		from: PeerId,
-		message: Message,
-		to?: PeerStreams[] | PeerMap<PeerStreams>,
+
+	private async createDeliveryPromise(
+		from: PublicSignKey,
+		message: DataMessage,
 		relayed?: boolean
-	): Promise<void> {
-		if (message instanceof DataMessage && !to) {
-			// message.to can be distant peers, but "to" are neighbours
-			const fanoutMap = new Map<string, string[]>();
-
-			// Message to > 0
-			if (message.to.length > 0) {
-				const missingPathsFor: string[] = [];
-				for (const to of message.to) {
-					const fromKey = this.peerIdToPublicKey
-						.get(from.toString())
-						?.hashcode();
-					if (to === this.publicKeyHash || fromKey === to) {
-						continue; // don't send to me or backwards
-					}
+	): Promise<{ promise: Promise<void> }> {
+		if (message.header.mode instanceof AnyWhere) {
+			return { promise: Promise.resolve() };
+		}
+		const idString = toBase64(message.id);
 
-					const directStream = this.peers.get(to);
-					if (directStream) {
-						// always favor direct stream, even path seems longer
-						const fanout = fanoutMap.get(to);
-						if (!fanout) {
-							fanoutMap.set(to, [to]);
-						} else {
-							fanout.push(to);
-						}
-						continue;
-					} else {
-						const fromMe = from.equals(this.components.peerId);
-						const block = !fromMe ? fromKey : undefined;
-						const path = this.routes.getPath(this.publicKeyHash, to, {
-							block // prevent send message backwards
-						});
-
-						if (path && path.length > 0) {
-							const fanout = fanoutMap.get(path[1]);
-							if (!fanout) {
-								fanoutMap.set(path[1], [to]);
-								if (
-									this.connectionManagerOptions.autoDial &&
-									path.length >= 3
-								) {
-									// Dont await this even if it is async since this method can fail
-									// and might take some time to run
-									this.maybeConnectDirectly(path).catch((e) => {
-										logger.error(
-											"Failed to request direct connection: " + e.message
-										);
-									});
-								}
-								continue;
-							} else {
-								fanout.push(to);
-								continue;
+		const existing = this._ackCallbacks.get(idString);
+		if (existing) {
+			return { promise: existing.promise };
+		}
+
+		const deliveryDeferredPromise = pDefer<void>();
+		const fastestNodesReached = new Map<string, number[]>();
+		const messageToSet: Set<string> = new Set();
+		if (message.header.mode.to) {
+			for (const to of message.header.mode.to) {
+				if (to === from.hashcode()) {
+					continue;
+				}
+				messageToSet.add(to);
+
+				if (!relayed && !this.healthChecks.has(to)) {
+					this.healthChecks.set(
+						to,
+						setTimeout(() => {
+							this.removeRouteConnection(to, false);
+						}, this.seekTimeout + 5000)
+					);
+				}
+			}
+		}
+
+		if (messageToSet.size === 0) {
+			deliveryDeferredPromise.resolve(); // we dont know how many answer to expect, just resolve immediately
+		}
+
+		const willGetAllAcknowledgements = !relayed; // Only the origin will get all acks
+
+		// Expected to receive at least 'filterMessageForSeenCounter' acknowledgements from each peer
+		const filterMessageForSeenCounter = relayed
+			? undefined
+			: message.header.mode instanceof SeekDelivery
+				? Math.min(this.peers.size, message.header.mode.redundancy)
+				: 1; /*  message.deliveryMode instanceof SeekDelivery ? Math.min(this.peers.size - (relayed ? 1 : 0), message.deliveryMode.redundancy) : 1 */
+
+		const finalize = () => {
+			this._ackCallbacks.delete(idString);
+			if (message.header.mode instanceof SeekDelivery) {
+				this.routes.commitPendingRouteConnection(session);
+			}
+		};
+
+		const uniqueAcks = new Set();
+		const session = +new Date();
+		const timeout = setTimeout(async () => {
+			let hasAll = true;
+			finalize();
+
+			// peer not reachable (?)!
+			for (const to of messageToSet) {
+				let foundNode = false;
+
+				if (fastestNodesReached.has(to)) {
+					foundNode = true;
+					break;
+				}
+
+				if (!foundNode && !relayed) {
+					hasAll = false;
+				}
+			}
+
+			if (!hasAll && willGetAllAcknowledgements) {
+				deliveryDeferredPromise.reject(
+					new TimeoutError(
+						`${
+							this.publicKeyHash
+						} Failed to get message ${idString} ${filterMessageForSeenCounter} ${[
+							...messageToSet
+						]} delivery acknowledges from all nodes (${
+							fastestNodesReached.size
+						}/${messageToSet.size}). Mode: ${
+							message.header.mode.constructor.name
+						}`
+					)
+				);
+			} else {
+				deliveryDeferredPromise.resolve();
+			}
+		}, this.seekTimeout);
+
+		this._ackCallbacks.set(idString, {
+			promise: deliveryDeferredPromise.promise,
+			callback: (ack: ACK, messageThrough, messageFrom) => {
+				const messageTarget = ack.header.signatures!.publicKeys[0];
+				const messageTargetHash = messageTarget.hashcode();
+				const seenCounter = ack.seenCounter;
+
+				// remove the automatic removal of route timeout since we have observed lifesigns of a peer
+				const timer = this.healthChecks.get(messageTargetHash);
+				clearTimeout(timer);
+				this.healthChecks.delete(messageTargetHash);
+
+				// if the target is not inside the original message to, we still ad the target to our routes
+				// this because a relay might modify the 'to' list and we might receive more answers than initially set
+				if (message.header.mode instanceof SeekDelivery) {
+					this.addRouteConnection(
+						messageFrom?.publicKey.hashcode() || this.publicKeyHash,
+						messageThrough.publicKey.hashcode(),
+						messageTarget,
+						seenCounter,
+						session,
+						true
+					); // we assume the seenCounter = distance. The more the message has been seen by the target the longer the path is to the target
+				}
+
+				if (messageToSet.has(messageTargetHash)) {
+					// Only keep track of relevant acks
+					if (
+						filterMessageForSeenCounter == null ||
+						seenCounter < filterMessageForSeenCounter
+					) {
+						// TODO set limit correctly
+						if (seenCounter < MAX_ROUTE_DISTANCE) {
+							let arr = fastestNodesReached.get(messageTargetHash);
+							if (!arr) {
+								arr = [];
+								fastestNodesReached.set(messageTargetHash, arr);
 							}
-						} else {
-							missingPathsFor.push(to);
+							arr.push(seenCounter);
+
+							uniqueAcks.add(messageTargetHash + seenCounter);
 						}
 					}
+				}
 
-					// we can't find path, send message to all peers
-					fanoutMap.clear();
-					break;
+				// This if clause should never enter for relayed connections, since we don't
+				// know how many ACKs we will get
+				if (
+					filterMessageForSeenCounter != null &&
+					uniqueAcks.size >= messageToSet.size * filterMessageForSeenCounter
+				) {
+					if (messageToSet.size > 0) {
+						// this statement exist beacuse if we do SEEK and have to = [], then it means we try to reach as many as possible hence we never want to delete this ACK callback
+						// only remove callback function if we actually expected a expected amount of responses
+						clearTimeout(timeout);
+						finalize();
+					}
+					deliveryDeferredPromise.resolve();
 				}
+			},
+			timeout
+		});
+		return deliveryDeferredPromise;
+	}
 
-				// update to's
-				let sentOnce = false;
-				if (missingPathsFor.length === 0) {
-					if (fanoutMap.size > 0) {
-						for (const [neighbour, distantPeers] of fanoutMap) {
-							message.to = distantPeers;
-							const bytes = message.bytes();
-							if (!sentOnce) {
-								// if relayed = true, we have already added it to seenCache
-								if (!relayed) {
-									this.seenCache.add(await getMsgId(bytes));
-								}
-								sentOnce = true;
-							}
+	public async publishMessage(
+		from: PublicSignKey,
+		message: Message,
+		to?: PeerStreams[] | Map<string, PeerStreams>,
+		relayed?: boolean
+	): Promise<void> {
+		let delivereyPromise: Promise<void> | undefined = undefined as any;
+
+		if (
+			(!message.header.signatures ||
+				message.header.signatures.publicKeys.length === 0) &&
+			message instanceof DataMessage &&
+			message.header.mode instanceof SilentDelivery === false
+		) {
+			throw new Error("Missing signature");
+		}
+
+		/**
+		 * Logic for handling acknowledge messages when we receive them (later)
+		 */
+
+		if (
+			message instanceof DataMessage &&
+			message.header.mode instanceof SeekDelivery &&
+			!relayed
+		) {
+			to = this.peers; // seek delivery will not work unless we try all possible paths
+		}
+
+		if (message instanceof AcknowledgeDelivery) {
+			to = undefined;
+		}
+
+		if (
+			message instanceof DataMessage &&
+			(message.header.mode instanceof SeekDelivery ||
+				message.header.mode instanceof AcknowledgeDelivery)
+		) {
+			delivereyPromise = (
+				await this.createDeliveryPromise(from, message, relayed)
+			).promise;
+		}
+
+		const bytes = message.bytes();
+
+		if (!relayed) {
+			const bytesArray = bytes instanceof Uint8Array ? bytes : bytes.subarray();
+			await this.modifySeenCache(bytesArray);
+		}
+
+		/**
+		 * For non SEEKing message delivery modes, use routing
+		 */
+
+		if (message instanceof DataMessage) {
+			if (
+				(message.header.mode instanceof AcknowledgeDelivery ||
+					message.header.mode instanceof SilentDelivery) &&
+				!to &&
+				message.header.mode.to
+			) {
+				const fanout = this.routes.getFanout(
+					from,
+					message.header.mode.to,
+					message.header.mode.redundancy
+				);
 
+				if (fanout) {
+					if (fanout.size > 0) {
+						for (const [neighbour, _distantPeers] of fanout) {
 							const stream = this.peers.get(neighbour);
 							stream?.waitForWrite(bytes).catch((e) => {
 								logger.error("Failed to publish message: " + e.message);
 							});
 						}
-						return; // we are done sending the message in all direction with updates 'to' lists
+						return delivereyPromise; // we are done sending the message in all direction with updates 'to' lists
 					}
-					return;
+
+					return; // we defintely that we should not forward the message anywhere
 				}
 
+				return;
+
 				// else send to all (fallthrough to code below)
 			}
 		}
 
 		// We fils to send the message directly, instead fallback to floodsub
-		const peers: PeerStreams[] | PeerMap<PeerStreams> = to || this.peers;
+		const peers: PeerStreams[] | Map<string, PeerStreams> = to || this.peers;
 		if (
 			peers == null ||
 			(Array.isArray(peers) && peers.length === 0) ||
 			(peers instanceof Map && peers.size === 0)
 		) {
-			logger.debug("no peers are subscribed");
+			logger.debug("No peers to send to");
 			return;
 		}
 
-		const bytes = message.bytes();
 		let sentOnce = false;
 		for (const stream of peers.values()) {
 			const id = stream as PeerStreams;
-			if (id.peerId.equals(from)) {
+			if (id.publicKey.equals(from)) {
 				continue;
 			}
 
-			if (!sentOnce) {
-				sentOnce = true;
-				if (!relayed) {
-					// if relayed = true, we have already added it to seenCache
-					const msgId = await getMsgId(bytes);
-					this.seenCache.add(msgId);
-				}
-			}
+			sentOnce = true;
+
 			id.waitForWrite(bytes).catch((e) => {
 				logger.error("Failed to publish message: " + e.message);
 			});
 		}
 
-		if (!sentOnce && !relayed) {
-			throw new Error("Message did not have any valid receivers. ");
+		if (!sentOnce) {
+			if (!relayed) {
+				throw new Error("Message did not have any valid receivers");
+			}
 		}
+		return delivereyPromise;
 	}
 
-	async maybeConnectDirectly(path: string[]) {
-		if (path.length < 3) {
-			return;
-		}
-
-		const toHash = path[path.length - 1];
-
-		if (this.peers.has(toHash)) {
+	async maybeConnectDirectly(toHash: string, origin: MultiAddrinfo) {
+		if (this.peers.has(toHash) || this.prunedConnectionsCache?.has(toHash)) {
 			return; // TODO, is this expected, or are we to dial more addresses?
 		}
 
-		// Try to either connect directly
-		if (!this.recentDials.has(toHash)) {
-			this.recentDials.add(toHash);
-			const addrs = this.multiaddrsMap.get(toHash);
+		const addresses = origin.multiaddrs
+			.filter((x) => {
+				const ret = !this.recentDials!.has(x);
+				this.recentDials!.add(x);
+				return ret;
+			})
+			.map((x) => multiaddr(x));
+		if (addresses.length > 0) {
 			try {
-				if (addrs && addrs.length > 0) {
-					await this.components.connectionManager.openConnection(
-						addrs.map((x) => multiaddr(x))
-					);
-					return;
-				}
-			} catch (error) {
-				// continue regardless of error
-			}
-		}
-
-		// Connect through a closer relay that maybe does holepunch for us
-		const nextToHash = path[path.length - 2];
-		const routeKey = nextToHash + toHash;
-		if (!this.recentDials.has(routeKey)) {
-			this.recentDials.add(routeKey);
-			const to = this.peerKeyHashToPublicKey.get(toHash)! as Ed25519PublicKey;
-			const toPeerId = await to.toPeerId();
-			const addrs = this.multiaddrsMap.get(path[path.length - 2]);
-			if (addrs && addrs.length > 0) {
-				const addressesToDial = addrs.sort((a, b) => {
-					if (a.includes("/wss/")) {
-						if (b.includes("/wss/")) {
-							return 0;
-						}
-						return -1;
-					}
-					if (a.includes("/ws/")) {
-						if (b.includes("/ws/")) {
-							return 0;
-						}
-						if (b.includes("/wss/")) {
-							return 1;
-						}
-						return -1;
-					}
-					return 0;
-				});
-
-				for (const addr of addressesToDial) {
-					const circuitAddress = multiaddr(
-						addr + "/p2p-circuit/webrtc/p2p/" + toPeerId.toString()
-					);
-					try {
-						await this.components.connectionManager.openConnection(
-							circuitAddress
-						);
-						return;
-					} catch (error: any) {
-						logger.error(
-							"Failed to connect directly to: " +
-								circuitAddress.toString() +
-								". " +
-								error?.message
-						);
-					}
-				}
+				await this.components.connectionManager.openConnection(addresses);
+			} catch (error: any) {
+				logger.info(
+					"Failed to connect directly to: " +
+						JSON.stringify(addresses.map((x) => x.toString())) +
+						". " +
+						error?.message
+				);
 			}
 		}
 	}
 
-	async waitFor(peer: PeerId | PublicSignKey) {
+	async waitFor(
+		peer: PeerId | PublicSignKey,
+		options?: { signal: AbortSignal }
+	) {
 		const hash = (
 			peer instanceof PublicSignKey ? peer : getPublicKeyFromPeerId(peer)
 		).hashcode();
 		try {
-			await waitFor(() => {
-				if (!this.peers.has(hash)) {
-					return false;
-				}
-				if (!this.routes.hasLink(this.publicKeyHash, hash)) {
-					return false;
-				}
+			await waitFor(
+				() => {
+					if (!this.peers.has(hash)) {
+						return false;
+					}
+					if (!this.routes.isReachable(this.publicKeyHash, hash)) {
+						return false;
+					}
 
-				return true;
-			});
+					return true;
+				},
+				{
+					signal: options?.signal,
+					timeout: 10 * 1000
+				}
+			);
 		} catch (error) {
 			throw new Error(
 				"Stream to " +
@@ -1598,12 +1744,16 @@ export abstract class DirectStream<
 					" does not exist. Connection exist: " +
 					this.peers.has(hash) +
 					". Route exist: " +
-					this.routes.hasLink(this.publicKeyHash, hash)
+					this.routes.isReachable(this.publicKeyHash, hash)
 			);
 		}
 		const stream = this.peers.get(hash)!;
 		try {
-			await waitFor(() => stream.isReadable && stream.isWritable);
+			// Dontwait for readlable https://github.com/libp2p/js-libp2p/issues/2321
+			await waitFor(() => /* stream.isReadable && */ stream.isWritable, {
+				signal: options?.signal,
+				timeout: 10 * 1000
+			});
 		} catch (error) {
 			throw new Error(
 				"Stream to " +
@@ -1615,6 +1765,66 @@ export abstract class DirectStream<
 			);
 		}
 	}
+
+	get pending(): boolean {
+		return this._ackCallbacks.size > 0;
+	}
+
+	lastQueuedBytes = 0;
+
+	// make this into a job? run every few ms
+	maybePruneConnections(): Promise<void> {
+		if (this.connectionManagerOptions.pruner) {
+			if (this.connectionManagerOptions.pruner.bandwidth != null) {
+				let usedBandwidth = 0;
+				for (const [_k, v] of this.peers) {
+					usedBandwidth += v.usedBandwidth;
+				}
+				usedBandwidth /= this.peers.size;
+
+				if (usedBandwidth > this.connectionManagerOptions.pruner.bandwidth) {
+					// prune
+					return this.pruneConnections();
+				}
+			} else if (this.connectionManagerOptions.pruner.maxBuffer != null) {
+				const queuedBytes = this.getQueuedBytes();
+				if (queuedBytes > this.connectionManagerOptions.pruner.maxBuffer) {
+					// prune
+					return this.pruneConnections();
+				}
+			}
+		}
+
+		return Promise.resolve();
+	}
+
+	async pruneConnections(): Promise<void> {
+		// TODO sort by bandwidth
+		if (this.peers.size <= this.connectionManagerOptions.minConnections) {
+			return;
+		}
+		const sorted = [...this.peers.values()]
+			.sort((x, y) => x.usedBandwidth - y.usedBandwidth)
+			.map((x) => x.publicKey.hashcode());
+		const prunables = this.routes.getPrunable(sorted);
+		if (prunables.length === 0) {
+			return;
+		}
+
+		const stream = this.peers.get(prunables[0])!;
+		this.prunedConnectionsCache!.add(stream.publicKey.hashcode());
+
+		await this.onPeerDisconnected(stream.peerId);
+		return this.components.connectionManager.closeConnections(stream.peerId);
+	}
+
+	getQueuedBytes(): number {
+		let sum = 0;
+		for (const peer of this.peers) {
+			sum += peer[1].outboundStream?.readableLength || 0;
+		}
+		return sum;
+	}
 }
 
 export const waitForPeers = async (