@hive-p2p/server 1.0.18 → 1.0.20

package/core/topologist.mjs

@@ -0,0 +1,254 @@
+import { CLOCK, SIMULATION, TRANSPORTS, NODE, DISCOVERY, GOSSIP } from './config.mjs';
+import { PeerConnection } from './peer-store.mjs';
+import { CryptoCodex } from './crypto-codex.mjs';
+const { SANDBOX, ICE_CANDIDATE_EMITTER, TEST_WS_EVENT_MANAGER } = SIMULATION.ENABLED ? await import('../simulation/test-transports.mjs') : {};
+
+/**
+ * @typedef {Object} SignalData
+ * @property {Array<string>} neighbors
+ * @property {Object} signal
+ * @property {'offer' | 'answer'} signal.type
+ * @property {string} signal.sdp
+ * @property {string} [offerHash]
+ * 
+ * @typedef {Object} OfferQueueItem
+ * @property {string} senderId
+ * @property {SignalData} data
+ * @property {number} overlap
+ * @property {number} neighborsCount
+ * @property {number} timestamp
+ * */
+
+class OfferQueue {
+	maxOffers = 30;
+	/** @type {Array<OfferQueueItem>} */ offers = [];
+	/** @type {'overlap' | 'neighborsCount'} */ orderingBy = 'neighborsCount';
+	get size() { return this.offers.length; }
+
+	updateOrderingBy(isHalfTargetReached = false) { this.orderingBy = isHalfTargetReached ? 'overlap' : 'neighborsCount'; }
+	removeOlderThan(age = 1000) { this.offers = this.offers.filter(item => item.timestamp + age >= CLOCK.time); }
+	get bestOfferInfo() {
+		const { senderId, overlap, neighborsCount, data, timestamp } = this.offers.shift() || {};
+		return { senderId, data, timestamp, value: this.orderingBy === 'overlap' ? overlap : neighborsCount };
+	}
+	
+	/** @param {OfferQueueItem} offer @param {boolean} isHalfTargetReached @param {{min: number, max: number}} [ignoringFactors] */
+	pushSortTrim(offer, ignoringFactors = {min: .2, max: .8}) { // => 20%-80% to ignore the offer depending on the queue length
+		const { min, max } = ignoringFactors; // AVOID SIMULATOR FLOODING, AND AVOID ALL PEERS TO PROCESS SAME OFFERS
+		if (Math.random() < Math.min(min, this.offers.size / this.maxOffers * max)) return;
+
+		this.offers.push(offer);
+		if (this.offers.length === 1) return;
+
+		// SORT THE QUEUE: by overlap ASCENDING, or by neighborsCount DESCENDING
+		this.offers.sort((a, b) => this.orderingBy === 'overlap' ? a.overlap - b.overlap : b.neighborsCount - a.neighborsCount);
+		if (this.size > this.maxOffers) this.offers.pop();
+	}
+}
+
+export class Topologist {
+	id; gossip; messager; peerStore; bootstraps;
+	halfTarget = Math.ceil(DISCOVERY.TARGET_NEIGHBORS_COUNT / 2);
+	twiceTarget = DISCOVERY.TARGET_NEIGHBORS_COUNT * 2;
+	/** @type {Set<string>} */ bootstrapsIds = new Set();
+	get isPublicNode() { return this.services?.publicUrl ? true : false; }
+	/** @type {import('./node-services.mjs').NodeServices | undefined} */ services;
+	
+	phase = 0;
+	nextBootstrapIndex = 0;
+	offersQueue = new OfferQueue();
+	maxBonus = NODE.CONNECTION_UPGRADE_TIMEOUT * .2; // 20% of 15sec: 3sec max
+
+	/** @param {string} selfId @param {import('./gossip.mjs').Gossip} gossip @param {import('./unicast.mjs').UnicastMessager} messager @param {import('./peer-store.mjs').PeerStore} peerStore @param {Array<{id: string, publicUrl: string}>} bootstraps */
+	constructor(selfId, gossip, messager, peerStore, bootstraps) {
+		this.id = selfId; this.gossip = gossip; this.messager = messager; this.peerStore = peerStore;
+		for (const bootstrap of bootstraps) this.bootstrapsIds.add(bootstrap.id);
+		this.bootstraps = [...bootstraps].sort(() => Math.random() - 0.5); // shuffle
+		this.nextBootstrapIndex = Math.random() * this.bootstrapsIds.size | 0;
+	}
+
+	// PUBLIC METHODS
+	tick() {
+		const { neighborsCount, nonPublicNeighborsCount, isEnough, isTooMany, isHalfReached } = this.#localTopologyInfo;
+		const offersToCreate = nonPublicNeighborsCount >= DISCOVERY.TARGET_NEIGHBORS_COUNT / 3 ? 1 : TRANSPORTS.MAX_SDP_OFFERS;
+		this.peerStore.offerManager.offersToCreate = isEnough ? 0 : offersToCreate;
+		if (this.isPublicNode) { this.services.freePublicNodeByKickingPeers(); return; } // public nodes don't need more connections
+		if (isTooMany) return Math.random() > .05 ? this.#improveTopologyByKickingPeers() : null;
+		
+		if (!isEnough) this.#digestBestOffers(); // => needs more peers
+		else if (Math.random() > .05) this.#digestBestOffers(); // => sometimes, try topology improvement...
+	
+		this.phase = this.phase ? 0 : 1;
+		if (this.phase === 0) this.tryConnectNextBootstrap(neighborsCount, nonPublicNeighborsCount);
+		if (this.phase === 1) this.#tryToSpreadSDP(nonPublicNeighborsCount, isHalfReached);
+	}
+	/** @param {string} peerId @param {SignalData} data @param {number} [HOPS] */
+	handleIncomingSignal(senderId, data, HOPS) {
+		if (this.isPublicNode || !senderId || this.peerStore.isKicked(senderId)) return;
+		if (data.signal?.type !== 'offer' && data.signal?.type !== 'answer') return;
+		
+		const { signal, offerHash } = data || {}; // remoteInfo
+		const { connected, nonPublicNeighborsCount, isTooMany, isHalfReached } = this.#localTopologyInfo;
+		if (isTooMany || connected[senderId]) return;
+
+		if (signal.type === 'answer') { // ANSWER SHORT CIRCUIT => Rich should connect poor, and poor should connect rich.
+			if (this.peerStore.addConnectingPeer(senderId, signal, offerHash) !== true) return;
+			const delta = Math.abs(nonPublicNeighborsCount - this.#getOverlap(senderId).nonPublicCount);
+			const bonusPerDeltaPoint = this.maxBonus / DISCOVERY.TARGET_NEIGHBORS_COUNT; // from 0 to maxBonus
+			const bonus = Math.round(Math.min(this.maxBonus, delta * bonusPerDeltaPoint));
+			return this.peerStore.assignSignal(senderId, signal, offerHash, CLOCK.time + bonus);
+		}
+
+		// OFFER
+		if (nonPublicNeighborsCount > this.twiceTarget) return; // we are over connected, ignore the offer
+		const { overlap, nonPublicCount } = this.#getOverlap(senderId);
+		if (nonPublicCount > this.twiceTarget) return; // the sender is over connected, ignore the offer
+		
+		const offerItem = { senderId, data, overlap, neighborsCount: nonPublicCount, timestamp: CLOCK.time };
+		this.offersQueue.updateOrderingBy(isHalfReached);
+		this.offersQueue.pushSortTrim(offerItem);
+	}
+	tryConnectNextBootstrap(neighborsCount = 0, nonPublicNeighborsCount = 0) {
+		if (this.bootstrapsIds.size === 0) return;
+		const publicConnectedCount = neighborsCount - nonPublicNeighborsCount;
+		let [connectingCount, publicConnectingCount] = [0, 0];
+		for (const id in this.peerStore.connecting)
+			if (this.bootstrapsIds.has(id)) publicConnectingCount++;
+			else connectingCount++;
+
+		// MINIMIZE BOOTSTRAP CONNECTIONS DEPENDING ON HOW MANY NEIGHBORS WE HAVE
+		if (publicConnectedCount + publicConnectingCount >= this.halfTarget) return; // already connected to enough bootstraps
+		if (neighborsCount >= DISCOVERY.TARGET_NEIGHBORS_COUNT) return; // no more bootstrap needed
+		if (connectingCount + nonPublicNeighborsCount > this.twiceTarget) return; // no more bootstrap needed
+
+		const { id, publicUrl } = this.bootstraps[this.nextBootstrapIndex++ % this.bootstrapsIds.size];
+		if (id && publicUrl && (this.peerStore.connected[id] || this.peerStore.connecting[id])) return;
+		this.#connectToPublicNode(id, publicUrl);
+	}
+	
+	// INTERNAL METHODS
+	get #localTopologyInfo() {
+		return {
+			connected: this.peerStore.connected,
+			neighborsCount: this.peerStore.neighborsList.length,
+			nonPublicNeighborsCount: this.peerStore.standardNeighborsList.length,
+			isEnough: this.peerStore.standardNeighborsList.length >= DISCOVERY.TARGET_NEIGHBORS_COUNT,
+			isTooMany: this.peerStore.standardNeighborsList.length > DISCOVERY.TARGET_NEIGHBORS_COUNT,
+			isHalfReached: this.peerStore.standardNeighborsList.length >= this.halfTarget,
+		}
+	}
+	#getOverlap(peerId1 = 'toto') {
+		const p1n = this.peerStore.known[peerId1]?.neighbors || {};
+		const result = { overlap: 0, nonPublicCount: 0, p1nCount: this.peerStore.getUpdatedPeerConnectionsCount(peerId1) };
+		for (const id in p1n) if (!CryptoCodex.isPublicNode(id)) result.nonPublicCount++;
+		for (const id of this.peerStore.standardNeighborsList) if (p1n[id]) result.overlap++;
+		return result;
+	}
+	/** Get overlap information for multiple peers @param {string[]} peerIds */
+	#getOverlaps(peerIds = []) { return peerIds.map(id => ({ id, ...this.#getOverlap(id) })); }
+	#connectToPublicNode(remoteId = 'toto', publicUrl = 'localhost:8080') {
+		if (!CryptoCodex.isPublicNode(remoteId)) return this.verbose < 1 ? null : console.warn(`Topologist: trying to connect to a non-public node (${remoteId})`);
+		const ws = new TRANSPORTS.WS_CLIENT(publicUrl); ws.binaryType = 'arraybuffer';
+		if (!this.peerStore.connecting[remoteId]) this.peerStore.connecting[remoteId] = {};
+		this.peerStore.connecting[remoteId].out = new PeerConnection(remoteId, ws, 'out', true);
+		ws.onerror = (error) => console.error(`WebSocket error:`, error.stack);
+		ws.onopen = () => {
+			ws.onclose = () => { for (const cb of this.peerStore.callbacks.disconnect) cb(remoteId, 'out'); }
+			ws.onmessage = (data) => { for (const cb of this.peerStore.callbacks.data) cb(remoteId, data.data); };
+			for (const cb of this.peerStore.callbacks.connect) cb(remoteId, 'out');
+		};
+	}
+	#tryToSpreadSDP(nonPublicNeighborsCount = 0, isHalfReached = false) { // LOOP TO SELECT ONE UNSEND READY OFFER AND BROADCAST IT
+		// LIMIT OFFER SPREADING IF WE ARE CONNECTING TO MANY PEERS, LOWER GOSSIP TRAFFIC
+		const connectingCount = Object.keys(this.peerStore.connecting).length;
+		const ingPlusEd = connectingCount + nonPublicNeighborsCount;
+		
+		// SELECT BEST READY OFFER BASED ON TIMESTAMP
+		let [ offerHash, readyOffer, since ] = [ null, null, null ];
+		for (const hash in this.peerStore.offerManager.offers) {
+			const offer = this.peerStore.offerManager.offers[hash];
+			const { isUsed, sentCounter, signal, timestamp } = offer;
+			if (isUsed || sentCounter > 0) continue; // already used or already sent at least once
+			const createdSince = CLOCK.time - timestamp;
+			if (createdSince > TRANSPORTS.SDP_OFFER_EXPIRATION / 2) continue; // old, don't spread
+			if (since && createdSince > since) continue; // already have a better (more recent) offer
+			readyOffer = offer; offerHash = hash; since = createdSince;
+			break;
+		}
+		if (!offerHash || !readyOffer) return; // no ready offer to spread
+
+		// IF WE ARE CONNECTED TO LESS 2 (WRTC) AND NOT TO MUCH CONNECTING, WE CAN BROADCAST IT TO ALL
+		if (!isHalfReached && ingPlusEd <= this.twiceTarget) {
+			this.gossip.broadcastToAll({ signal: readyOffer.signal, offerHash }, 'signal_offer');
+			readyOffer.sentCounter++; // avoid sending it again
+			return; // limit to one per loop
+		}
+		
+		let bestValue = null;
+		for (const overlapInfo of this.#getOverlaps(this.peerStore.standardNeighborsList)) {
+			const value = overlapInfo[isHalfReached ? 'overlap' : 'nonPublicCount'];
+			if (bestValue === null) bestValue = value;
+			if (isHalfReached && value < bestValue) bestValue = value;
+			if (!isHalfReached && value <= bestValue) bestValue = value;
+		}
+
+		let maxIds = 100; let maxSearch = 1000; const knownCount = this.peerStore.knownCount;
+		const r = Math.max(Math.min(maxSearch / knownCount, knownCount / maxSearch), .127);
+		const selectedIds = []; // ELSE, SEND USING UNICAST TO THE BEST 10 CANDIDATES
+		for (const id in this.peerStore.known) {
+			if (Math.random() > r) continue; // randomize a bit the search
+			if (--maxSearch <= 0) break;
+			if (id === this.id || CryptoCodex.isPublicNode(id) || this.peerStore.isKicked(id)) continue;
+			else if (this.peerStore.connected[id] || this.peerStore.connecting[id]) continue;
+			
+			const { overlap, nonPublicCount } = this.#getOverlap(id);
+			if (nonPublicCount > DISCOVERY.TARGET_NEIGHBORS_COUNT) continue; // the peer is over connected, ignore it
+			if (bestValue === null) bestValue = isHalfReached ? overlap : nonPublicCount;
+			if (isHalfReached && overlap > bestValue) continue; // only target lowest overlap
+			if (!isHalfReached && nonPublicCount < bestValue) continue; // only target highest neighbors count
+			selectedIds.push(id);
+			if (--maxIds <= 0) break;
+		}
+		if (!selectedIds.length) return;
+		
+		const sentTo = new Map();
+		for (let i = 0; i < Math.min(selectedIds.length, 100); i++) {
+			const peerId = selectedIds[Math.floor(Math.random() * selectedIds.length)];
+			if (sentTo.has(peerId)) continue;
+			if (sentTo.size === 0) readyOffer.sentCounter++;
+			sentTo.set(peerId, true);
+			this.messager.sendUnicast(peerId, { signal: readyOffer.signal, offerHash }, 'signal_offer', 1);
+			if (sentTo.size >= 12) break; // limit to 12 unicast max
+		}
+	}
+	/** Process signal_offer queue by filtering fresh offers and answering these with best:
+	 * - Lowest overlap if we already have neighbors 
+	 * - Highest neighbors count if we don't */
+	#digestBestOffers() {
+		let bestValue = null;
+		let connectingCount = Object.keys(this.peerStore.connecting).length;
+		this.offersQueue.updateOrderingBy(this.#localTopologyInfo.isHalfReached);
+		this.offersQueue.removeOlderThan(TRANSPORTS.SDP_OFFER_EXPIRATION / 2); // remove close to expiration offers
+		for (let i = 0; i < this.offersQueue.size; i++) {
+			//if (connectingCount > this.twiceTarget * 2) break; // stop if we are over connecting
+			const { senderId, data, timestamp, value } = this.offersQueue.bestOfferInfo;
+			if (!senderId || !data || !timestamp) break;
+			if (this.peerStore.connected[senderId] || this.peerStore.isKicked(senderId)) continue;
+			if (this.peerStore.connecting[senderId]?.['in']) continue;
+			bestValue = bestValue === null ? value : bestValue;
+			if (bestValue !== value) break; // stop if the value is not the best anymore
+
+			if (this.peerStore.addConnectingPeer(senderId, data.signal, data.offerHash) !== true) continue;
+			this.peerStore.assignSignal(senderId, data.signal, data.offerHash, timestamp);
+			connectingCount++;
+		}
+	}
+	
+	/** Kick the peer with the biggest overlap (any round of 2.5sec is isTooMany)
+	 * - If all peers have the same overlap, kick the one with the most non-public neighbors */
+	#improveTopologyByKickingPeers() {
+		const overlaps = this.#getOverlaps(this.peerStore.standardNeighborsList);
+		const sortedPeers = overlaps.sort((a, b) => b.overlap - a.overlap || b.nonPublicCount - a.nonPublicCount);
+		this.peerStore.kickPeer(sortedPeers[0].id, 60_000, 'improveTopology');
+	}
+}

package/core/unicast.mjs

@@ -0,0 +1,155 @@
+import { SIMULATION, DISCOVERY, UNICAST } from "./config.mjs";
+import { TRUST_VALUES } from "./arbiter.mjs";
+import { RouteBuilder_V2 } from "./route-builder.mjs";
+const { SANDBOX, ICE_CANDIDATE_EMITTER, TEST_WS_EVENT_MANAGER } = SIMULATION.ENABLED ? await import('../simulation/test-transports.mjs') : {};
+const RouteBuilder = RouteBuilder_V2; // temporary switch
+
+export class DirectMessage { // TYPE DEFINITION
+	type = 'message';
+	timestamp;
+	neighborsList;
+	route;
+	pubkey;
+	data;
+	signature;
+	signatureStart; // position in the serialized message where the signature starts
+	expectedEnd; // expected length of the serialized message
+
+	/** @param {string} type @param {number} timestamp @param {string[]} neighborsList @param {string[]} route @param {string} pubkey @param {string | Uint8Array | Object} data @param {string | undefined} signature @param {number} signatureStart @param {number} expectedEnd */
+	constructor(type, timestamp, neighborsList, route, pubkey, data, signature, signatureStart, expectedEnd) {
+		this.type = type; this.timestamp = timestamp; this.neighborsList = neighborsList;
+		this.route = route; this.pubkey = pubkey; this.data = data; this.signature = signature; this.signatureStart = signatureStart; this.expectedEnd = expectedEnd;
+	}
+	getSenderId() { return this.route[0]; }
+	getTargetId() { return this.route[this.route.length - 1]; }
+	extractRouteInfo(selfId = 'toto') {
+		const route = this.newRoute || this.route;
+		const traveledRoute = [];
+		let selfPosition = -1;
+		for (let i = 0; i < route.length; i++) {
+			traveledRoute.push(route[i]);
+			if (route[i] === selfId) { selfPosition = i; break; }
+		}
+		const senderId = route[0];
+		const targetId = route[route.length - 1];
+		const prevId = selfPosition > 0 ? route[selfPosition - 1] : null;
+		const nextId = (selfPosition !== -1) ? route[selfPosition + 1] : null;
+		return { traveledRoute, selfPosition, senderId, targetId, prevId, nextId, routeLength: route.length };
+	}
+}
+export class ReroutedDirectMessage extends DirectMessage {
+	rerouterPubkey;
+	newRoute;
+	rerouterSignature;
+
+	/** @param {string} type @param {number} timestamp @param {string[]} route @param {string} pubkey @param {string | Uint8Array | Object} data @param {Uint8Array} rerouterPubkey @param {string | undefined} signature @param {string[]} newRoute @param {string} rerouterSignature */
+	constructor(type, timestamp, route, pubkey, data, signature, rerouterPubkey, newRoute, rerouterSignature) {
+		super(type, timestamp, route, pubkey, data, signature);
+		this.rerouterPubkey = rerouterPubkey; this.newRoute = newRoute; this.rerouterSignature = rerouterSignature; // patch
+	}
+	getRerouterId() { return this.newRoute[0]; }
+}
+
+export class UnicastMessager {
+	/** @type {Record<string, Function[]>} */ callbacks = { message_handle: [] };
+	id; cryptoCodex; arbiter; peerStore; verbose; pathFinder;
+	
+	maxHops = UNICAST.MAX_HOPS;
+	maxRoutes = UNICAST.MAX_ROUTES;
+	maxNodes = UNICAST.MAX_NODES;
+
+	/** @param {string} selfId @param {import('./crypto-codex.mjs').CryptoCodex} cryptoCodex @param {import('./arbiter.mjs').Arbiter} arbiter @param {import('./peer-store.mjs').PeerStore} peerStore */
+	constructor(selfId, cryptoCodex, arbiter, peerStore, verbose = 0) {
+		this.id = selfId;
+		this.cryptoCodex = cryptoCodex;
+		this.arbiter = arbiter;
+		this.peerStore = peerStore;
+		this.verbose = verbose;
+		this.pathFinder = new RouteBuilder(this.id, this.peerStore);
+	}
+
+	/** @param {string} callbackType @param {Function} callback */
+	on(callbackType, callback) {
+		if (!this.callbacks[callbackType]) this.callbacks[callbackType] = [callback];
+		else this.callbacks[callbackType].push(callback);
+	}
+	/** Send unicast message to a target
+	 * @param {string} remoteId @param {string | Uint8Array | Object} data @param {string} type
+	 * @param {number} [spread] Max neighbors used to relay the message, default: 1 */
+	sendUnicast(remoteId, data, type = 'message', spread = 1) {
+		if (remoteId === this.id) return false;
+
+		const builtResult = this.pathFinder.buildRoutes(remoteId, this.maxRoutes, this.maxHops, this.maxNodes, true);
+		if (!builtResult.success) return false;
+
+		// Caution: re-routing usage who can involve insane results
+		const finalSpread = builtResult.success === 'blind' ? 1 : spread; // Spread only if re-routing is false
+		for (let i = 0; i < Math.min(finalSpread, builtResult.routes.length); i++) {
+			const route = builtResult.routes[i].path;
+			if (route.length > UNICAST.MAX_HOPS) {
+				if (this.verbose > 1) console.warn(`Cannot send unicast message to ${remoteId} as route exceeds maxHops (${UNICAST.MAX_HOPS}). BFS incurred.`);
+				continue; // too long route
+			}
+			const message = this.cryptoCodex.createUnicastMessage(type, data, route, this.peerStore.neighborsList);
+			this.#sendMessageToPeer(route[1], message); // send to next peer
+		}
+		return true;
+	}
+	/** @param {string} targetId @param {Uint8Array} serialized */
+	#sendMessageToPeer(targetId, serialized) {
+		if (this.id === targetId) return { success: false, reason: `Cannot send message to self.` };
+		const transportInstance = this.peerStore.connected[targetId]?.transportInstance;
+		if (!transportInstance) return { success: false, reason: `Transport instance is not available for peer ${targetId}.` };
+		try { transportInstance.send(serialized); return { success: true }; }
+		catch (error) {
+			this.peerStore.kickPeer(targetId, 0, 'send-error');
+			if (this.verbose > 0) console.error(`Error sending message to ${targetId}:`, error.message);
+		}
+		return { success: false, reason: `Error sending message to ${targetId}.` };
+	}
+	/** @param {string} from @param {Uint8Array} serialized */
+	async handleDirectMessage(from, serialized) {
+		if (this.arbiter.isBanished(from)) return this.verbose >= 3 ? console.info(`%cReceived direct message from banned peer ${from}, ignoring.`, 'color: red;') : null;
+		if (!this.arbiter.countMessageBytes(from, serialized.byteLength, 'unicast')) return; // ignore if flooding/banished
+
+		const message = this.cryptoCodex.readUnicastMessage(serialized);
+		if (!message) return this.arbiter.countPeerAction(from, 'WRONG_SERIALIZATION');
+		await this.arbiter.digestMessage(from, message, serialized);
+		if (this.arbiter.isBanished(from)) return; // ignore messages from banished peers
+		if (this.arbiter.isBanished(message.senderId)) return; // ignore messages from banished peers
+
+		const { traveledRoute, selfPosition, senderId, targetId, prevId, nextId } = message.extractRouteInfo(this.id);
+		if (from === senderId && from === this.id) throw new Error('DirectMessage senderId and from are both self id !!');
+		
+		for (const cb of this.callbacks.message_handle || []) cb(); // Simulator counter
+		if (selfPosition === -1) return this.arbiter.adjustTrust(from, TRUST_VALUES.UNICAST_INVALID_ROUTE, 'Self not in route');
+		if (prevId && from !== prevId) return this.arbiter.adjustTrust(from, TRUST_VALUES.UNICAST_INVALID_ROUTE, 'Previous hop id does not match actual from id');
+		if (senderId === this.id) return this.arbiter.adjustTrust(from, TRUST_VALUES.UNICAST_INVALID_ROUTE, 'SenderId is self id');
+		
+		if (this.verbose > 3)
+			if (senderId === from) console.log(`(${this.id}) Direct ${message.type} from ${senderId}: ${message.data}`);
+			else console.log(`(${this.id}) Direct ${message.type} from ${senderId} (lastRelay: ${from}): ${message.data}`);
+		
+		this.peerStore.digestPeerNeighbors(senderId, message.neighborsList);
+		if (from !== senderId) this.arbiter.adjustTrust(from, TRUST_VALUES.UNICAST_RELAYED, 'Relayed unicast message');
+		if (DISCOVERY.ON_UNICAST.DIGEST_TRAVELED_ROUTE) this.peerStore.digestValidRoute(traveledRoute);
+		if (this.id === targetId) { for (const cb of this.callbacks[message.type] || []) cb(senderId, message.data); return; } // message for self
+
+		// re-send the message to the next peer in the route
+		const { success, reason } = this.#sendMessageToPeer(nextId, serialized);
+		if (!success && !message.rerouterSignature) { // try to patch the route
+			const builtResult = this.pathFinder.buildRoutes(targetId, this.maxRoutes, this.maxHops, this.maxNodes, true);
+			if (!builtResult.success) return;
+
+			const newRoute = builtResult.routes[0].path;
+			if (newRoute.length > UNICAST.MAX_HOPS) {
+				if (this.verbose > 1) console.warn(`Cannot re-route unicast message to ${targetId} as new route exceeds maxHops (${UNICAST.MAX_HOPS}).`);
+				return; // too long route
+			}
+				
+			const patchedMessage = this.cryptoCodex.createReroutedUnicastMessage(serialized, newRoute);
+			const nextPeerId = newRoute[selfPosition + 1];
+			this.#sendMessageToPeer(nextPeerId, patchedMessage);
+		}
+	}
+}

package/libs/xxhash32.mjs

@@ -0,0 +1,65 @@
+const PRIME32_1 = 2654435761;
+const PRIME32_2 = 2246822519;
+const PRIME32_3 = 3266489917;
+const PRIME32_4 = 668265263;
+const PRIME32_5 = 374761393;
+let encoder;
+/** @param input - byte array or string @param seed - optional seed (32-bit unsigned); */
+export function xxHash32(input, seed = 0) {
+    const buffer = typeof input === 'string' ? (encoder ??= new TextEncoder()).encode(input) : input;
+    const b = buffer;
+    let acc = (seed + PRIME32_5) & 0xffffffff;
+    let offset = 0;
+    if (b.length >= 16) {
+        const accN = [
+            (seed + PRIME32_1 + PRIME32_2) & 0xffffffff,
+            (seed + PRIME32_2) & 0xffffffff,
+            (seed + 0) & 0xffffffff,
+            (seed - PRIME32_1) & 0xffffffff,
+        ];
+        const b = buffer;
+        const limit = b.length - 16;
+        let lane = 0;
+        for (offset = 0; (offset & 0xfffffff0) <= limit; offset += 4) {
+            const i = offset;
+            const laneN0 = b[i + 0] + (b[i + 1] << 8);
+            const laneN1 = b[i + 2] + (b[i + 3] << 8);
+            const laneNP = laneN0 * PRIME32_2 + ((laneN1 * PRIME32_2) << 16);
+            let acc = (accN[lane] + laneNP) & 0xffffffff;
+            acc = (acc << 13) | (acc >>> 19);
+            const acc0 = acc & 0xffff;
+            const acc1 = acc >>> 16;
+            accN[lane] = (acc0 * PRIME32_1 + ((acc1 * PRIME32_1) << 16)) & 0xffffffff;
+            lane = (lane + 1) & 0x3;
+        }
+        acc =
+            (((accN[0] << 1) | (accN[0] >>> 31)) +
+                ((accN[1] << 7) | (accN[1] >>> 25)) +
+                ((accN[2] << 12) | (accN[2] >>> 20)) +
+                ((accN[3] << 18) | (accN[3] >>> 14))) &
+                0xffffffff;
+    }
+    acc = (acc + buffer.length) & 0xffffffff;
+    const limit = buffer.length - 4;
+    for (; offset <= limit; offset += 4) {
+        const i = offset;
+        const laneN0 = b[i + 0] + (b[i + 1] << 8);
+        const laneN1 = b[i + 2] + (b[i + 3] << 8);
+        const laneP = laneN0 * PRIME32_3 + ((laneN1 * PRIME32_3) << 16);
+        acc = (acc + laneP) & 0xffffffff;
+        acc = (acc << 17) | (acc >>> 15);
+        acc = ((acc & 0xffff) * PRIME32_4 + (((acc >>> 16) * PRIME32_4) << 16)) & 0xffffffff;
+    }
+    for (; offset < b.length; ++offset) {
+        const lane = b[offset];
+        acc = acc + lane * PRIME32_5;
+        acc = (acc << 11) | (acc >>> 21);
+        acc = ((acc & 0xffff) * PRIME32_1 + (((acc >>> 16) * PRIME32_1) << 16)) & 0xffffffff;
+    }
+    acc = acc ^ (acc >>> 15);
+    acc = (((acc & 0xffff) * PRIME32_2) & 0xffffffff) + (((acc >>> 16) * PRIME32_2) << 16);
+    acc = acc ^ (acc >>> 13);
+    acc = (((acc & 0xffff) * PRIME32_3) & 0xffffffff) + (((acc >>> 16) * PRIME32_3) << 16);
+    acc = acc ^ (acc >>> 16);
+    return acc < 0 ? acc + 4294967296 : acc;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hive-p2p/server",
-  "version": "1.0.18",
+  "version": "1.0.20",
   "publishConfig": {
     "access": "public"
   },
@@ -9,10 +9,10 @@
   "main": "index.mjs",
   "files": [
     "index.mjs",
-    "core\\",
-    "libs\\xxhash32.mjs",
-    "rendering\\",
-    "services\\"
+    "core/",
+    "libs/xxhash32.mjs",
+    "rendering/",
+    "services/"
   ],
   "dependencies": {
     "@noble/ed25519": "3.0.0",