@peerbit/stream 2.0.5 → 3.0.0

package/src/index.ts

@@ -38,10 +38,9 @@ import type { TypedEventTarget } from "@libp2p/interface";
 export type SignaturePolicy = "StictSign" | "StrictNoSign";
 
 import { logger } from "./logger.js";
-
 export { logger };
-
 import { Cache } from "@peerbit/cache";
+
 import type { Libp2pEvents } from "@libp2p/interface";
 import { ready } from "@peerbit/crypto";
 import {
@@ -104,11 +103,11 @@ type WithTo = {
 type WithMode = {
 	mode?: SilentDelivery | SeekDelivery | AcknowledgeDelivery | AnyWhere;
 };
+
 /**
  * Thin wrapper around a peer's inbound / outbound pubsub streams
  */
 export class PeerStreams extends TypedEventEmitter<PeerStreamEvents> {
-	public counter = 0;
 	public readonly peerId: PeerId;
 	public readonly publicKey: PublicSignKey;
 	public readonly protocol: string;
@@ -149,7 +148,6 @@ export class PeerStreams extends TypedEventEmitter<PeerStreamEvents> {
 		this.inboundAbortController = new AbortController();
 		this.closed = false;
 		this.connId = init.connId;
-		this.counter = 1;
 		this.usedBandWidthTracker = new MovingAverageTracker();
 	}
 
@@ -407,7 +405,6 @@ export abstract class DirectStream<
 	 * if publish should emit to self, if subscribed
 	 */
 
-	public signaturePolicy: SignaturePolicy;
 	public queue: Queue;
 	public multicodecs: string[];
 	public seenCache: Cache<number>;
@@ -423,6 +420,8 @@ export abstract class DirectStream<
 	routeSeekInterval: number;
 	seekTimeout: number;
 	closeController: AbortController;
+	session: number;
+
 	private _ackCallbacks: Map<
 		string,
 		{
@@ -434,7 +433,7 @@ export abstract class DirectStream<
 			) => void;
 			timeout: ReturnType<typeof setTimeout>;
 		}
-	> = new Map();
+	>;
 
 	constructor(
 		readonly components: DirectStreamComponents,
@@ -475,7 +474,7 @@ export abstract class DirectStream<
 		this._onIncomingStream = this._onIncomingStream.bind(this);
 		this.onPeerConnected = this.onPeerConnected.bind(this);
 		this.onPeerDisconnected = this.onPeerDisconnected.bind(this);
-		this.signaturePolicy = signaturePolicy;
+		this._ackCallbacks = new Map();
 
 		if (connectionManager === false || connectionManager === null) {
 			this.connectionManagerOptions = {
@@ -527,6 +526,7 @@ export abstract class DirectStream<
 			return;
 		}
 
+		this.session = +new Date();
 		await ready;
 
 		this.closeController = new AbortController();
@@ -767,7 +767,8 @@ export abstract class DirectStream<
 				peerKey.hashcode(),
 				peerKey,
 				-1,
-				+new Date()
+				+new Date(),
+				-1
 			);
 		} catch (err: any) {
 			logger.error(err);
@@ -804,7 +805,7 @@ export abstract class DirectStream<
 
 			// Notify network
 			const dependent = this.routes.getDependent(peerKeyHash);
-			this.removeRouteConnection(peerKeyHash, true);
+			this.removeRouteConnection(peerKeyHash);
 
 			if (dependent.length > 0) {
 				await this.publishMessage(
@@ -812,6 +813,7 @@ export abstract class DirectStream<
 					await new Goodbye({
 						leaving: [peerKeyHash],
 						header: new MessageHeader({
+							session: this.session,
 							mode: new SilentDelivery({ to: dependent, redundancy: 2 })
 						})
 					}).sign(this.sign)
@@ -822,10 +824,8 @@ export abstract class DirectStream<
 		logger.debug("connection ended:" + peerKey.toString());
 	}
 
-	public removeRouteConnection(hash: string, neigbour: boolean) {
-		const unreachable = neigbour
-			? this.routes.removeNeighbour(hash)
-			: this.routes.removeTarget(hash);
+	public removeRouteConnection(hash: string, asNeigh = true) {
+		const unreachable = this.routes.remove(hash);
 		for (const node of unreachable) {
 			this.onPeerUnreachable(node); // TODO types
 			this.peerKeyHashToPublicKey.delete(node);
@@ -837,21 +837,27 @@ export abstract class DirectStream<
 		neighbour: string,
 		target: PublicSignKey,
 		distance: number,
-		session: number
+		session: number,
+		remoteSession: number
 	) {
 		const targetHash = typeof target === "string" ? target : target.hashcode();
-		const wasReachable =
-			from === this.publicKeyHash
-				? this.routes.isReachable(from, targetHash)
-				: true;
 
-		this.routes.add(from, neighbour, targetHash, distance, session);
+		const update = this.routes.add(
+			from,
+			neighbour,
+			targetHash,
+			distance,
+			session,
+			remoteSession
+		);
 
-		const newPeer =
-			wasReachable === false && this.routes.isReachable(from, targetHash);
-		if (newPeer) {
-			this.peerKeyHashToPublicKey.set(target.hashcode(), target);
-			this.onPeerReachable(target); // TODO types
+		// second condition is that we don't want to emit 'reachable' events for routes where we act only as a relay
+		// in this case, from is != this.publicKeyhash
+		if (from === this.publicKeyHash) {
+			if (update === "new") {
+				this.peerKeyHashToPublicKey.set(target.hashcode(), target);
+				this.onPeerReachable(target);
+			}
 		}
 	}
 
@@ -881,6 +887,24 @@ export abstract class DirectStream<
 		);
 	}
 
+	public updateSession(key: PublicSignKey, session?: number) {
+		if (this.routes.updateSession(key.hashcode(), session)) {
+			return this.onPeerSession(key, session!);
+		}
+	}
+	public invalidateSession(key: string) {
+		this.routes.updateSession(key, undefined);
+	}
+
+	public onPeerSession(key: PublicSignKey, session: number) {
+		this.dispatchEvent(
+			// TODO types
+			new CustomEvent("peer:session", {
+				detail: key
+			})
+		);
+	}
+
 	/**
 	 * Notifies the router that a peer has been connected
 	 */
@@ -898,7 +922,6 @@ export abstract class DirectStream<
 
 		// If peer streams already exists, do nothing
 		if (existing != null) {
-			existing.counter += 1;
 			existing.connId = connId;
 			return existing;
 		}
@@ -915,6 +938,8 @@ export abstract class DirectStream<
 		});
 
 		this.peers.set(publicKeyHash, peerStreams);
+		this.updateSession(publicKey, -1);
+
 		peerStreams.addEventListener("close", () => this._removePeer(publicKey), {
 			once: true
 		});
@@ -1084,7 +1109,7 @@ export abstract class DirectStream<
 		}
 
 		if (isForMe) {
-			if ((await this.maybeVerifyMessage(message)) === false) {
+			if (!(await this.verifyAndProcess(message))) {
 				// 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;
@@ -1136,8 +1161,19 @@ export abstract class DirectStream<
 		}
 	}
 
-	public async maybeVerifyMessage(message: DataMessage) {
-		return message.verify(this.signaturePolicy === "StictSign");
+	public async verifyAndProcess(message: Message<any>) {
+		const verified = await message.verify(true);
+		if (!verified) {
+			return false;
+		}
+
+		const from = message.header.signatures!.publicKeys[0];
+		if (this.peers.has(from.hashcode())) {
+			// do nothing
+		} else {
+			this.updateSession(from, Number(message.header.session));
+		}
+		return true;
 	}
 
 	async acknowledgeMessage(
@@ -1145,6 +1181,12 @@ export abstract class DirectStream<
 		message: DataMessage,
 		seenBefore: number
 	) {
+		const signers = message.header.signatures!.publicKeys.map((x) =>
+			x.hashcode()
+		);
+		const from = signers[0];
+
+		this.routes.remoteInfo.get(from)?.session;
 		if (
 			(message.header.mode instanceof SeekDelivery ||
 				message.header.mode instanceof AcknowledgeDelivery) &&
@@ -1155,12 +1197,10 @@ export abstract class DirectStream<
 				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())
-						),
+						mode: new TracedDelivery(signers),
+						session: this.session,
 
 						// include our origin if message is SeekDelivery and we have not recently pruned a connection to this peer
 						origin:
@@ -1216,7 +1256,7 @@ export abstract class DirectStream<
 			return false;
 		}
 
-		if (!(await message.verify(true))) {
+		if (!(await this.verifyAndProcess(message))) {
 			logger.warn(`Recieved ACK message that did not verify`);
 			return false;
 		}
@@ -1238,7 +1278,9 @@ export abstract class DirectStream<
 			await this.publishMessage(this.publicKey, message, [nextStream], true);
 		} else {
 			if (myIndex !== 0) {
-				throw new Error("Unexpected");
+				// TODO should we throw something, or log?
+				// we could arrive here if the ACK target does not exist any more...
+				return;
 			}
 			// if origin exist (we can connect to remote peer) && we have autodialer turned on
 			if (message.header.origin && this.connectionManagerOptions.dialer) {
@@ -1269,7 +1311,7 @@ export abstract class DirectStream<
 			return;
 		}
 
-		if (!(await message.verify(true))) {
+		if (!(await this.verifyAndProcess(message))) {
 			logger.warn(`Recieved ACK message that did not verify`);
 			return false;
 		}
@@ -1278,6 +1320,10 @@ export abstract class DirectStream<
 			this.routes.hasTarget(x)
 		);
 
+		for (const remote of filteredLeaving) {
+			this.invalidateSession(remote);
+		}
+
 		if (filteredLeaving.length > 0) {
 			this.publish(new Uint8Array(0), {
 				mode: new SeekDelivery({
@@ -1338,10 +1384,12 @@ export abstract class DirectStream<
 				const neighbourRoutes = this.routes.routes
 					.get(this.publicKeyHash)
 					?.get(hash);
+
 				if (
 					!neighbourRoutes ||
-					now - neighbourRoutes.latestSession >
-						neighbourRoutes.list.length * this.routeSeekInterval
+					now - neighbourRoutes.session >
+						neighbourRoutes.list.length * this.routeSeekInterval ||
+					!this.routes.isUpToDate(hash, neighbourRoutes)
 				) {
 					mode = new SeekDelivery({
 						to: mode.to,
@@ -1354,18 +1402,11 @@ export abstract class DirectStream<
 
 		const message = new DataMessage({
 			data: data instanceof Uint8ArrayList ? data.subarray() : data,
-			header: new MessageHeader({ mode })
+			header: new MessageHeader({ mode, session: this.session })
 		});
 
-		if (
-			this.signaturePolicy === "StictSign" ||
-			mode instanceof SeekDelivery ||
-			mode instanceof AcknowledgeDelivery ||
-			mode instanceof AnyWhere
-		) {
-			await message.sign(this.sign);
-		}
-
+		// TODO allow messages to also be sent unsigned (signaturePolicy property)
+		await message.sign(this.sign);
 		return message;
 	}
 	/**
@@ -1530,7 +1571,8 @@ export abstract class DirectStream<
 						messageThrough.publicKey.hashcode(),
 						messageTarget,
 						seenCounter,
-						session
+						session,
+						Number(ack.header.session)
 					); // we assume the seenCounter = distance. The more the message has been seen by the target the longer the path is to the target
 				}
 
@@ -1790,8 +1832,6 @@ export abstract class DirectStream<
 		return this._ackCallbacks.size > 0;
 	}
 
-	lastQueuedBytes = 0;
-
 	// make this into a job? run every few ms
 	maybePruneConnections(): Promise<void> {
 		if (this.connectionManagerOptions.pruner) {
@@ -1823,8 +1863,6 @@ export abstract class DirectStream<
 		if (this.peers.size <= this.connectionManagerOptions.minConnections) {
 			return;
 		}
-		console.log("PRUNE CONNECTIONS");
-
 		const sorted = [...this.peers.values()]
 			.sort((x, y) => x.usedBandwidth - y.usedBandwidth)
 			.map((x) => x.publicKey.hashcode());

package/src/metrics.ts

@@ -1,5 +1,3 @@
-import { PublicSignKey } from "@peerbit/crypto";
-
 export class MovingAverageTracker {
 	private lastTS = 0;
 

package/src/routes.ts

@@ -1,35 +1,38 @@
 import { AbortError, delay } from "@peerbit/time";
 
 export const MAX_ROUTE_DISTANCE = Number.MAX_SAFE_INTEGER - 1;
-type RouteInfo = {
+
+type RelayInfo = {
 	session: number;
 	hash: string;
 	expireAt?: number;
 	distance: number;
 };
+type RouteInfo = {
+	remoteSession: number;
+	session: number;
+	list: RelayInfo[];
+};
+
 export class Routes {
-	// END receiver -> Neighbour
-
-	routes: Map<
-		string,
-		Map<
-			string,
-			{
-				latestSession: number;
-				list: RouteInfo[];
-			}
-		>
-	> = new Map();
+	// FROM -> TO -> { ROUTE INFO, A list of neighbours that we can send data through to reach to}
+	routes: Map<string, Map<string, RouteInfo>> = new Map();
 
+	remoteInfo: Map<string, { session?: number }> = new Map();
+
+	// Maximum amount of time to retain routes that are not valid anymore
+	// once we receive new route info to reach a specific target
 	routeMaxRetentionPeriod: number;
-	signal: AbortSignal;
+
+	signal?: AbortSignal;
 
 	constructor(
 		readonly me: string,
-		options: { routeMaxRetentionPeriod: number; signal: AbortSignal }
+		options?: { routeMaxRetentionPeriod?: number; signal?: AbortSignal }
 	) {
-		this.routeMaxRetentionPeriod = options.routeMaxRetentionPeriod;
-		this.signal = options.signal;
+		this.routeMaxRetentionPeriod =
+			options?.routeMaxRetentionPeriod ?? 10 * 1000;
+		this.signal = options?.signal;
 	}
 
 	clear() {
@@ -42,7 +45,7 @@ export class Routes {
 			const map = fromMap.get(to);
 			if (map) {
 				const now = +new Date();
-				const keepRoutes: RouteInfo[] = [];
+				const keepRoutes: RelayInfo[] = [];
 				for (const route of map.list) {
 					// delete all routes after a while
 					if (route.expireAt != null && route.expireAt < now) {
@@ -68,8 +71,9 @@ export class Routes {
 		neighbour: string,
 		target: string,
 		distance: number,
-		session: number
-	) {
+		session: number,
+		remoteSession: number
+	): "new" | "updated" | "restart" {
 		let fromMap = this.routes.get(from);
 		if (!fromMap) {
 			fromMap = new Map();
@@ -77,22 +81,42 @@ export class Routes {
 		}
 
 		let prev = fromMap.get(target);
-
+		const routeDidExist = prev;
+		const isNewSession = !prev || session > prev.session;
 		if (!prev) {
-			prev = { latestSession: 0, list: [] as RouteInfo[] };
+			prev = { session, remoteSession, list: [] as RelayInfo[] };
 			fromMap.set(target, prev);
 		}
 
-		if (from === this.me && neighbour === target) {
-			// force distance to neighbour as targets to always favor directly sending to them
-			// i.e. if target is our neighbour, always assume the shortest path to them is the direct path
-			distance = -1;
+		if (neighbour === target) {
+			if (from === this.me) {
+				// force distance to neighbour as targets to always favor directly sending to them
+				// i.e. if target is our neighbour, always assume the shortest path to them is the direct path
+				distance = -1;
+			}
+
+			// we do this since don't care about remote session if the
+			//peer is our neighbour since we will always be up to date by connect/disconnect events
+			remoteSession = -1;
+		}
+
+		let isNewRemoteSession = false;
+		if (routeDidExist) {
+			if (prev.remoteSession != -1) {
+				// if the remote session is later, we consider that the remote has 'restarted'
+				isNewRemoteSession = remoteSession > (prev.remoteSession || -1);
+				prev.remoteSession =
+					remoteSession === -1
+						? remoteSession
+						: Math.max(remoteSession, prev.remoteSession || -1);
+			} else {
+				isNewRemoteSession = false;
+			}
 		}
 
-		// Update routes and cleanup all old routes that are older than latest session - some threshold
-		const isNewSession = session > prev.latestSession;
-		prev.latestSession = Math.max(session, prev.latestSession);
+		prev.session = Math.max(session, prev.session);
 
+		// Update routes and cleanup all old routes that are older than latest session - some threshold
 		if (isNewSession) {
 			// Mark previous routes as old
 
@@ -121,6 +145,7 @@ export class Routes {
 		}
 
 		// Modify list for new/update route
+		let exist = false;
 		for (const route of prev.list) {
 			if (route.hash === neighbour) {
 				// if route is faster or just as fast, update existing route
@@ -129,13 +154,14 @@ export class Routes {
 					route.session = session;
 					route.expireAt = undefined; // remove expiry since we updated
 					prev.list.sort((a, b) => a.distance - b.distance);
-					return;
+					return isNewRemoteSession ? "restart" : "updated";
 				} else if (route.distance === distance) {
 					route.session = session;
 					route.expireAt = undefined; // remove expiry since we updated
-					return;
+					return isNewRemoteSession ? "restart" : "updated";
 				}
 
+				exist = true;
 				// else break and push the route as a new route (that ought to be longer)
 				break;
 			}
@@ -143,33 +169,36 @@ export class Routes {
 
 		prev.list.push({ distance, session, hash: neighbour });
 		prev.list.sort((a, b) => a.distance - b.distance);
+		return exist ? (isNewRemoteSession ? "restart" : "updated") : "new";
 	}
 
-	removeTarget(target: string) {
-		this.routes.delete(target);
-		for (const [fromMapKey, fromMap] of this.routes) {
-			// delete target
-			fromMap.delete(target);
-			if (fromMap.size === 0) {
-				this.routes.delete(fromMapKey);
-			}
-		}
-		return [target];
-	}
-
-	removeNeighbour(target: string) {
+	/**
+	 *
+	 * @param target
+	 * @returns unreachable nodes (from me) after removal
+	 */
+	remove(target: string) {
 		this.routes.delete(target);
-		const maybeUnreachable: Set<string> = new Set([target]);
+		const maybeUnreachable: Set<string> = new Set();
+		let targetRemoved = false;
 		for (const [fromMapKey, fromMap] of this.routes) {
 			// delete target
-			fromMap.delete(target);
+			const deletedAsTarget = fromMap.delete(target);
+			targetRemoved =
+				targetRemoved || (deletedAsTarget && fromMapKey === this.me);
 
 			// delete this as neighbour
 			for (const [remote, neighbours] of fromMap) {
-				neighbours.list = neighbours.list.filter((x) => x.hash !== target);
+				const filtered = neighbours.list.filter((x) => x.hash !== target);
+				neighbours.list = filtered;
 				if (neighbours.list.length === 0) {
 					fromMap.delete(remote);
-					maybeUnreachable.add(remote);
+
+					if (fromMapKey === this.me) {
+						// TODO we only return maybeUnreachable if the route starts from me.
+						// expected?
+						maybeUnreachable.add(remote);
+					}
 				}
 			}
 
@@ -177,6 +206,11 @@ export class Routes {
 				this.routes.delete(fromMapKey);
 			}
 		}
+		this.remoteInfo.delete(target);
+
+		if (targetRemoved) {
+			maybeUnreachable.add(target);
+		}
 		return [...maybeUnreachable].filter((x) => !this.isReachable(this.me, x));
 	}
 
@@ -185,18 +219,29 @@ export class Routes {
 	}
 
 	isReachable(from: string, target: string, maxDistance = MAX_ROUTE_DISTANCE) {
-		return (
-			(this.routes.get(from)?.get(target)?.list[0]?.distance ??
-				Number.MAX_SAFE_INTEGER) <= maxDistance
-		);
-	}
+		const remoteInfo = this.remoteInfo.get(target);
+		const routeInfo = this.routes.get(from)?.get(target);
+		if (!routeInfo) {
+			return false;
+		}
+		if (!remoteInfo) {
+			return false;
+		}
+		if (
+			routeInfo.remoteSession == undefined ||
+			remoteInfo.session === undefined
+		) {
+			return false;
+		}
 
-	hasShortestPath(target: string) {
-		const path = this.routes.get(this.me)?.get(target);
-		if (!path) {
+		if (routeInfo.remoteSession < remoteInfo.session) {
+			// route info is older than remote info
 			return false;
 		}
-		return path.list[0].distance <= 0;
+
+		return (
+			(routeInfo?.list[0]?.distance ?? Number.MAX_SAFE_INTEGER) <= maxDistance
+		);
 	}
 
 	hasTarget(target: string) {
@@ -208,11 +253,68 @@ export class Routes {
 		return false;
 	}
 
-	getDependent(target: string) {
+	updateSession(remote: string, session?: number) {
+		if (session == null) {
+			this.remoteInfo.delete(remote);
+			return false;
+		}
+
+		const remoteInfo = this.remoteInfo.get(remote);
+		if (remoteInfo) {
+			// remote has restartet, mark all routes originating from me to the remote as 'old'
+			if (remoteInfo.session === -1) {
+				return false;
+			}
+			if (session === -1) {
+				remoteInfo.session = -1;
+				return false;
+			} else {
+				if (session > (remoteInfo.session || -1)) {
+					remoteInfo.session = session;
+					return true;
+				}
+				return false;
+			}
+		} else if (session !== undefined) {
+			this.remoteInfo.set(remote, { session });
+			return true;
+		}
+		return false;
+	}
+
+	getSession(remote: string): number | undefined {
+		return this.remoteInfo.get(remote)?.session;
+	}
+
+	isUpToDate(target: string, route: RouteInfo) {
+		const peerInfo = this.remoteInfo.get(target);
+		return peerInfo?.session != null && route.remoteSession >= peerInfo.session;
+	}
+
+	getDependent(peer: string) {
 		const dependent: string[] = [];
-		for (const [fromMapKey, fromMap] of this.routes) {
-			if (fromMapKey !== this.me && fromMap.has(target)) {
+
+		outer: for (const [fromMapKey, fromMap] of this.routes) {
+			if (fromMapKey !== this.me) {
+				continue; // skip this because these routes are starting from me. We are looking for routes that affect others
+			}
+
+			// If the route is to the target
+			// tell 'from' that it is no longer reachable
+			if (fromMap.has(peer)) {
 				dependent.push(fromMapKey);
+				continue outer;
+			}
+
+			// If the relay is dependent of peer
+			// tell 'from' that it is no longer reachable
+			for (const [_to, through] of fromMap) {
+				for (const neighbour of through.list) {
+					if (neighbour.hash === peer) {
+						dependent.push(fromMapKey);
+						continue outer;
+					}
+				}
 			}
 		}
 		return dependent;
@@ -284,7 +386,7 @@ export class Routes {
 						fanout.set(to, { to, timestamp: session });
 
 						if (
-							(distance == 0 && session === neighbour.latestSession) ||
+							(distance == 0 && session === neighbour.session) ||
 							distance == -1
 						) {
 							foundClosest = true;