hive-p2p 1.0.108 → 1.0.112

package/core/config.mjs

@@ -88,10 +88,10 @@ export const IDENTITY = {
 	ARGON2_MEM: 2**16,
 	/** Boolean to indicate if we use hex ids, Default: true = hex | false = strings as Bytes (can involve in serialization failures) */
 	ARE_IDS_HEX: true,
-	/** Identifier prefix for public nodes | Default: '0' */
-	PUBLIC_PREFIX: '0',
-	/** Identifier prefix for standard nodes | Default: '1' */
-	STANDARD_PREFIX: '1',
+	/** Identifier prefix for public nodes [binaryPrefix, StringPrefix] | Default: ['0', 'P_'] */
+	PUBLIC_PREFIX: ['0', 'P_'],
+	/** Identifier prefix for standard nodes [binaryPrefix, StringPrefix]  | Default: ['1', 'N_'] */
+	STANDARD_PREFIX: ['1', 'N_'],
 	/** !!EVEN NUMBER ONLY!! length of peer id | Default: 16 */
 	ID_LENGTH: 16,
 	PUBKEY_LENGTH: 32,
@@ -156,7 +156,7 @@ export const UNICAST = { // MARKERS RANGE: 0-127
 	/** Maximum number of routes to consider during BFS
 	 * - Default: 5, light: 3, super-light: 1 */
 	MAX_ROUTES: 5,
-	/** First byte markers for unicast messages | RANGE: 0-127 */
+	/** First byte markers for unicast messages | RANGE: 0-127 @type {Record<string, string | number>} */
 	MARKERS_BYTES: {
 		message: 0,
 		'0': 'message',
@@ -181,7 +181,7 @@ export const GOSSIP = { // MARKERS RANGE: 128-255
 	/** Time to keep messages in cache to avoid reprocessing | Default: 20_000 (20 seconds) */
 	CACHE_DURATION: 20_000,
 	/** Maximum number of hops for gossip messages | Default: 20 
-	 * - Here you can set different max hops for different message types */
+	 * - Here you can set different max hops for different message types @type {Record<string, number>} */
 	HOPS: {
 		default: 20, 		// 16 should be the maximum
 		signal_offer: 6, 	// works with 3 ?
@@ -192,7 +192,8 @@ export const GOSSIP = { // MARKERS RANGE: 128-255
 	},
 	/** Ponderation to lower the transmission rate based on neighbors count
 	 * - Lowering the transmission rate based on neighbors count, but involve a lower gossip diffusion
-	 * - As well you can apply different ponderation factors for different message types */
+	 * - As well you can apply different ponderation factors for different message types
+	 * @type {Record<string, number>} */
 	TRANSMISSION_RATE: {
 		/** Minimum neighbors to apply ponderation, Default: 2
 		 * - Decrease to apply ponderation sooner */
@@ -206,7 +207,7 @@ export const GOSSIP = { // MARKERS RANGE: 128-255
 		// peer_connected: .5, 		// we can reduce this, but lowering the map quality
 		// peer_disconnected: .618
 	},
-	/** First byte markers for gossip messages | RANGE: 128-255 */
+	/** First byte markers for gossip messages | RANGE: 128-255 @type {Record<string, string | number>} */
 	MARKERS_BYTES: {
 		gossip: 128,
 		'128': 'gossip',

package/core/crypto-codex.mjs

@@ -1,7 +1,8 @@
+// @ts-check
 import { CLOCK } from '../services/clock.mjs';
 import { SIMULATION, NODE, IDENTITY, GOSSIP, UNICAST, LOG_CSS } from './config.mjs';
 import { GossipMessage } from './gossip.mjs';
-import { DirectMessage, ReroutedDirectMessage } from './unicast.mjs';
+import { DirectMessage } from './unicast.mjs';
 import { Converter } from '../services/converter.mjs';
 import { ed25519, x25519, chacha20poly1305, randomBytes, Argon2Unified } from '../services/cryptos.mjs'; // now exposed in full and browser builds
 import { concatBytes } from '@noble/ciphers/utils.js';
@@ -11,25 +12,27 @@ export class CryptoCodex {
 	converter = new Converter();
 	AVOID_CRYPTO = true; // AVOID CRYPTO OPERATIONS (default) => auto-enable when generate() is called, but can be set to true to disable crypto in any case (e.g. for testing with string ids)
 	verbose = NODE.DEFAULT_VERBOSE;
-	/** @type {string} */ id;
+	id;
     /** @type {Uint8Array} */ publicKey;
     /** @type {Uint8Array} */ privateKey;
+	get idLength() { return IDENTITY.ARE_IDS_HEX ? IDENTITY.ID_LENGTH / 2 : IDENTITY.ID_LENGTH; }
 
 	/** @param {string} [nodeId] If provided: used to generate a fake keypair > disable crypto operations */
 	constructor(nodeId, verbose = NODE.DEFAULT_VERBOSE) {
+		this.privateKey = new Uint8Array(32).fill(0);
+		this.publicKey = new Uint8Array(32).fill(0);
 		this.verbose = verbose;
 		//this.AVOID_CRYPTO = IDENTITY.ARE_IDS_HEX ? false : true; // disable crypto if string ids are used
 		if (!nodeId) return; // IF NOT PROVIDED: generate() should be called.
 
 		this.id = nodeId.padEnd(IDENTITY.ID_LENGTH, ' ').slice(0, IDENTITY.ID_LENGTH);
-		this.privateKey = new Uint8Array(32).fill(0); this.publicKey = new Uint8Array(32).fill(0);
 		const idBytes = new TextEncoder().encode(this.id); // use nodeId to create a fake public key
 		for (let i = 0; i < IDENTITY.ID_LENGTH; i++) this.publicKey[i] = idBytes[i];
 	}
 
 	/** @param {boolean} asPublicNode Default: false @param {Uint8Array | string} seed 32 bytes PrivateKey *-optional* */
 	static async createCryptoCodex(asPublicNode, seed) {
-		const cryptoCodex = new CryptoCodex(undefined, this.verbose);
+		const cryptoCodex = new CryptoCodex(undefined, NODE.DEFAULT_VERBOSE);
 		const seedBytes = !seed ? undefined : (typeof seed === 'string' ? cryptoCodex.converter.hexToBytes(seed) : seed);
 		await cryptoCodex.generate(asPublicNode, seedBytes);
 		return cryptoCodex;
@@ -37,23 +40,27 @@ export class CryptoCodex {
 
 	// IDENTITY
 	/** @param {string} id Check the first character against the PUBLIC_PREFIX */
-	static isPublicNode(id) { return (IDENTITY.ARE_IDS_HEX ? Converter.hexToBits(id[0]) : id).startsWith(IDENTITY.PUBLIC_PREFIX); }
-	/** @param {string} id */
-	get idLength() { return IDENTITY.ARE_IDS_HEX ? IDENTITY.ID_LENGTH / 2 : IDENTITY.ID_LENGTH; }
+	static isPublicNode(id) {
+		const idStr = id[1] === '_' ? id : Converter.hexToBits(id[0]);
+		if (typeof idStr !== 'string') throw new Error("idStr isn't string!");
+		return idStr.startsWith(IDENTITY.PUBLIC_PREFIX[0]) || idStr.startsWith(IDENTITY.PUBLIC_PREFIX[1]);
+	}
+	/** @param {string} id Check the first character against the PUBLIC_PREFIX */
 	isPublicNode(id) { return CryptoCodex.isPublicNode(id); }
     /** @param {boolean} asPublicNode @param {Uint8Array} [seed] The privateKey. DON'T USE IN SIMULATION */
 	async generate(asPublicNode, seed) { // Generate Ed25519 keypair cross-platform | set id only for simulator
-		if (this.nodeId) return;
+		if (this.id) return;
 
 		const s = seed || await CryptoCodex.generateNewSybilIdentity(asPublicNode, this.verbose > 0);
 		await this.#generateAntiSybilIdentity(s, asPublicNode);
 		this.AVOID_CRYPTO = false; // force enable crypto operations
 		if (!this.id) throw new Error('Failed to generate identity');
     }
-	/** Check if the pubKey meets the difficulty using Argon2 derivation @param {Uint8Array} publicKey */
+	/** Check if the pubKey meets the difficulty using Argon2 derivation @param {string | Uint8Array} publicKey */
 	async pubkeyDifficultyCheck(publicKey) {
 		if (this.AVOID_CRYPTO || !IDENTITY.DIFFICULTY) return true;
-		const { bitsString } = await this.argon2.hash(publicKey, 'HiveP2P', IDENTITY.ARGON2_MEM) || {};
+		const pubKeyStr = typeof publicKey === 'string' ? publicKey : this.converter.bytesToHex(publicKey, IDENTITY.PUBKEY_LENGTH);
+		const { bitsString } = await this.argon2.hash(pubKeyStr, 'HiveP2P', IDENTITY.ARGON2_MEM) || {};
 		if (bitsString && bitsString.startsWith('0'.repeat(IDENTITY.DIFFICULTY))) return true;
 	}
 	/** @param {Uint8Array} publicKey */
@@ -69,7 +76,8 @@ export class CryptoCodex {
 		if (!asPublicNode && this.isPublicNode(id)) throw new Error('Seed does not produce a private node identity.');
 		if (!await this.pubkeyDifficultyCheck(publicKey)) throw new Error('Seed does not meet difficulty requirements.');
 		this.id = id;
-		this.privateKey = secretKey; this.publicKey = publicKey;
+		this.privateKey = secretKey;
+		this.publicKey = publicKey;
 	}
 	/** @param {boolean} asPublicNode */
 	static async generateNewSybilIdentity(asPublicNode, log = true) {
@@ -93,6 +101,7 @@ export class CryptoCodex {
 		const { secretKey, publicKey } = x25519.keygen(seed);
 		return { myPub: publicKey, myPriv: secretKey };
 	}
+	/** @param {Uint8Array} secret @param {Uint8Array} pub */
 	computeX25519SharedSecret(secret, pub) {
 		return x25519.getSharedSecret(secret, pub);
 	}
@@ -103,11 +112,6 @@ export class CryptoCodex {
 		const cipher = chacha20poly1305(sharedSecret, nonce);
 		const encrypted = cipher.encrypt(data);
 		return concatBytes(nonce, encrypted);
-		// Vanilla =>
-		/*const result = new Uint8Array(nonce.length + encrypted.length);
-		result.set(nonce, 0);
-		result.set(encrypted, nonce.length);
-		return result;*/
 	}
 	/** @param {Uint8Array} encryptedData @param {Uint8Array} sharedSecret */
 	decryptData(encryptedData, sharedSecret) {
@@ -126,11 +130,12 @@ export class CryptoCodex {
 		const signature = ed25519.sign(dataToSign, privateKey);
 		bufferView.set(signature, signaturePosition);
 	}
-	/** @param {string} topic @param {string | Uint8Array | Object} data @param {number} [HOPS] @param {string[]} route @param {string[]} [neighbors] */
+	/** @param {string} topic @param {string | Uint8Array | Object} data @param {number} [HOPS] @param {string[]} [neighbors] */
 	createGossipMessage(topic, data, HOPS = 3, neighbors = [], timestamp = CLOCK.time) {
 		const MARKER = GOSSIP.MARKERS_BYTES[topic];
-		if (MARKER === undefined) throw new Error(`Failed to create gossip message: unknown topic '${topic}'.`);
-		
+		if (typeof MARKER !== 'number') throw new Error(`Failed to create gossip message: wrong topic '${topic}'.`);
+		if (typeof timestamp !== 'number') throw new Error('Wrong timestamp type!');
+
 		const neighborsBytes = this.#idsToBytes(neighbors);
 		const { dataCode, dataBytes } = this.#dataToBytes(data);
 		const totalBytes = 1 + 1 + 1 + 8 + 4 + 32 + neighborsBytes.length + dataBytes.length + IDENTITY.SIGNATURE_LENGTH + 1;
@@ -151,12 +156,13 @@ export class CryptoCodex {
 		clone[serializedMessage.length - 1] = Math.max(0, hops - 1);
 		return clone;
 	}
-	/** @param {string} type @param {string | Uint8Array | Object} data @param {string[]} route @param {string[]} [neighbors] @param {Uint8Array} [encryptionKey] @param {number} [timestamp] */
+	/** @param {string} type @param {string | Uint8Array | Object} data @param {string[]} route @param {string[]} [neighbors] @param {Uint8Array} [encryptionKey] */
 	createUnicastMessage(type, data, route, neighbors = [], encryptionKey, timestamp = CLOCK.time) {
 		const MARKER = UNICAST.MARKERS_BYTES[type];
-		if (MARKER === undefined) throw new Error(`Failed to create unicast message: unknown type '${type}'.`);
+		if (typeof MARKER !== 'number') throw new Error(`Failed to create gossip message: wrong type '${type}'.`);
+		if (typeof timestamp !== 'number') throw new Error('Wrong timestamp type!');
 		if (route.length < 2) throw new Error('Failed to create unicast message: route must have at least 2 nodes (next hop and target).');
-		if (route.length > UNICAST.MAX_HOPS) throw new Error(`Failed to create unicast message: route exceeds max hops (${UNICAST.MAX_HOPS}).`);
+		if (route.length > UNICAST.MAX_HOPS + 1) throw new Error(`Failed to create unicast message: route exceeds max hops (${UNICAST.MAX_HOPS}).`);
 		
 		const neighborsBytes = this.#idsToBytes(neighbors);
 		const { dataCode, dataBytes } = this.#dataToBytes(data);
@@ -179,7 +185,7 @@ export class CryptoCodex {
 	/** @param {Uint8Array} serialized @param {string[]} newRoute */
 	createReroutedUnicastMessage(serialized, newRoute) {
 		if (newRoute.length < 2) throw new Error('Failed to create rerouted unicast message: route must have at least 2 nodes (next hop and target).');
-		if (newRoute.length > UNICAST.MAX_HOPS) throw new Error(`Failed to create rerouted unicast message: route exceeds max hops (${UNICAST.MAX_HOPS}).`);
+		if (newRoute.length > UNICAST.MAX_HOPS + 1) throw new Error(`Failed to create rerouted unicast message: route exceeds max hops (${UNICAST.MAX_HOPS}).`);
 	
 		const routeBytesArray = newRoute.map(id => this.converter.stringToBytes(id));
 		const totalBytes = serialized.length + 32 + (IDENTITY.ID_LENGTH * routeBytesArray.length) + IDENTITY.SIGNATURE_LENGTH;
@@ -194,7 +200,7 @@ export class CryptoCodex {
 	}
 	/** @param {string[]} ids */
 	#idsToBytes(ids) {
-		if (IDENTITY.ARE_IDS_HEX) return this.converter.hexToBytes(ids.join(''), IDENTITY.ID_LENGTH * ids.length);
+		if (IDENTITY.ARE_IDS_HEX) return this.converter.hexToBytes(ids.join(''));
 		return this.converter.stringToBytes(ids.join(''));
 	}
 	/** @param {string | Uint8Array | Object} data */
@@ -235,15 +241,17 @@ export class CryptoCodex {
 		const dataLength = this.converter.bytes4ToNumber(lBytes);
 		return { marker, dataCode, neighLength, timestamp, dataLength, pubkey, associatedId };
 	}
-	/** @param {Uint8Array | ArrayBuffer} serialized @return {GossipMessage | null } */
+	/** @param {Uint8Array} serialized */
 	readGossipMessage(serialized) {
 		if (this.verbose > 3) console.log(`%creadGossipMessage ${serialized.byteLength} bytes`, LOG_CSS.CRYPTO_CODEX);
 		if (this.verbose > 4) console.log(`%c${serialized}`, LOG_CSS.CRYPTO_CODEX);
 		let topic;
-		try { // 1, 1, 1, 8, 4, 32, X, 64, 1
+		try { // 1, 1, 1, 8, 4, 32, X, 64, 1 
 			const { marker, dataCode, neighLength, timestamp, dataLength, pubkey, associatedId } = this.readBufferHeader(serialized);
 			topic = GOSSIP.MARKERS_BYTES[marker];
-			if (topic === undefined) throw new Error(`Failed to deserialize gossip message: unknown marker byte ${d[0]}.`);
+			if (typeof topic !== 'string') throw new Error(`Failed to deserialize gossip message: unknown marker byte ${serialized[0]}.`);
+			if (typeof associatedId !== 'string') throw new Error('Wrong associatedId tyoe!');
+			
 			const NDBL = neighLength + dataLength;
 			const neighbors = this.#bytesToIds(serialized.slice(47, 47 + neighLength));
 			const deserializedData = this.#bytesToData(dataCode, serialized.slice(47 + neighLength, 47 + NDBL));
@@ -251,12 +259,11 @@ export class CryptoCodex {
 			const signature = serialized.slice(signatureStart, signatureStart + IDENTITY.SIGNATURE_LENGTH);
 			const HOPS = serialized[serialized.length - 1];
 			const expectedEnd = signatureStart + IDENTITY.SIGNATURE_LENGTH + 1;
-			const senderId = associatedId;
-			return new GossipMessage(topic, timestamp, neighbors, HOPS, senderId, pubkey, deserializedData, signature, signatureStart, expectedEnd);
-		} catch (error) { if (this.verbose > 1) console.warn(`Error deserializing ${topic || 'unknown'} gossip message:`, error.stack); }
+			return new GossipMessage(topic, timestamp, neighbors, HOPS, associatedId, pubkey, deserializedData, signature, signatureStart, expectedEnd);
+		} catch (/** @type {any} */ error) { if (this.verbose > 1) console.warn(`Error deserializing ${topic || 'unknown'} gossip message:`, error.stack); }
 		return null;
 	}
-	/** @param {Uint8Array | ArrayBuffer} serialized @param {import('./peer-store.mjs').PeerStore} peerStore @return {DirectMessage | ReroutedDirectMessage | null} */
+	/** @param {Uint8Array} serialized @param {import('./peer-store.mjs').PeerStore} peerStore */
 	readUnicastMessage(serialized, peerStore) {
 		if (this.verbose > 3) console.log(`%creadUnicastMessage ${serialized.byteLength} bytes`, LOG_CSS.CRYPTO_CODEX);
 		if (this.verbose > 4) console.log(`%c${serialized}`, LOG_CSS.CRYPTO_CODEX);
@@ -264,7 +271,8 @@ export class CryptoCodex {
 		try { // 1, 1, 1, 8, 4, 32, X, 1, X, 64
 			const { marker, dataCode, neighLength, timestamp, dataLength, pubkey } = this.readBufferHeader(serialized, false);
 			type = UNICAST.MARKERS_BYTES[marker];
-			if (type === undefined) throw new Error(`Failed to deserialize unicast message: unknown marker byte ${d[0]}.`);
+			if (typeof type !== 'string') throw new Error(`Failed to deserialize unicast message: unknown marker byte ${serialized[0]}.`);
+			
 			const NDBL = neighLength + dataLength;
 			const neighbors = this.#bytesToIds(serialized.slice(47, 47 + neighLength));
 			const routeLength = serialized[47 + NDBL];
@@ -288,8 +296,8 @@ export class CryptoCodex {
 			const rerouterPubkey = serialized.slice(initialMessageEnd, initialMessageEnd + 32);
 			const newRoute = this.#bytesToIds(serialized.slice(initialMessageEnd + 32, serialized.length - IDENTITY.SIGNATURE_LENGTH));
 			const rerouterSignature = serialized.slice(serialized.length - IDENTITY.SIGNATURE_LENGTH);
-			return new ReroutedDirectMessage(type, timestamp, neighbors, route, pubkey, deserializedData, signature, rerouterPubkey, newRoute, rerouterSignature, serialized.length);
-		} catch (error) { if (this.verbose > 1) console.warn(`Error deserializing ${type || 'unknown'} unicast message:`, error.stack); }
+			return new DirectMessage(type, timestamp, neighbors, route, pubkey, deserializedData, signature, signatureStart, serialized.length, rerouterPubkey, newRoute, rerouterSignature);
+		} catch (/** @type {any} */ error) { if (this.verbose > 1) console.warn(`Error deserializing ${type || 'unknown'} unicast message:`, error.stack); }
 		return null;
 	}
 	/** @param {Uint8Array} serialized */
@@ -306,7 +314,7 @@ export class CryptoCodex {
 		}
 		return ids;
 	}
-	/** @param {1 | 2 | 3} dataCode @param {Uint8Array} dataBytes @return {string | Uint8Array | Object} */
+	/** @param {1 | 2 | 3 | number} dataCode @param {Uint8Array} dataBytes @return {string | Uint8Array | Object} */
 	#bytesToData(dataCode, dataBytes) {
 		if (dataCode === 1) return this.converter.bytesToString(dataBytes);
 		if (dataCode === 2) return dataBytes;

package/core/gossip.mjs

@@ -1,3 +1,4 @@
+// @ts-check
 import { CLOCK } from '../services/clock.mjs';
 import { GOSSIP } from './config.mjs';
 import { xxHash32 } from '../libs/xxhash32.mjs';
@@ -14,7 +15,7 @@ export class GossipMessage { // TYPE DEFINITION
 	signatureStart; // position in the serialized message where the signature starts
 	expectedEnd; // expected length of the serialized message
 
-	/** @param {string} topic @param {number} timestamp @param {string[]} neighborsList @param {number} HOPS @param {string} senderId @param {string} pubkey @param {string | Uint8Array | Object} data @param {string | undefined} signature @param {number} signatureStart @param {number} expectedEnd */
+	/** @param {string} topic @param {number} timestamp @param {string[]} neighborsList @param {number} HOPS @param {string} senderId @param {Uint8Array} pubkey @param {string | Uint8Array | Object} data @param {Uint8Array | undefined} signature @param {number} signatureStart @param {number} expectedEnd */
 	constructor(topic, timestamp, neighborsList, HOPS, senderId, pubkey, data, signature, signatureStart, expectedEnd) {
 		this.topic = topic; this.timestamp = timestamp; this.neighborsList = neighborsList;
 		this.HOPS = HOPS; this.senderId = senderId; this.pubkey = pubkey; this.data = data;
@@ -28,6 +29,7 @@ export class GossipMessage { // TYPE DEFINITION
  * @property {string} senderId
  * @property {string} topic
  * @property {Uint8Array} serializedMessage
+ * @property {number} timestamp
  * @property {number} expiration
  */
 class DegenerateBloomFilter {
@@ -54,23 +56,31 @@ class DegenerateBloomFilter {
 	addMessage(serializedMessage) {
     	const n = CLOCK.time;
 		const { marker, neighLength, timestamp, dataLength, pubkey, associatedId } = this.cryptoCodex.readBufferHeader(serializedMessage);
-		if (n - timestamp > GOSSIP.EXPIRATION) return;
+		const topic = GOSSIP.MARKERS_BYTES[marker];
+		if (typeof topic !== 'string') throw new Error(`Wrong topic byte: ${marker}`)
+		if (n === null || n - timestamp > GOSSIP.EXPIRATION) return;
+		if (!associatedId) return;
 
 		const hashableData = serializedMessage.subarray(0, 47 + neighLength + dataLength);
-		const h = xxHash32(hashableData);
+		const h = xxHash32(hashableData).toString();
 		this.xxHash32UsageCount++;
 		if (this.seenTimeouts[h]) return;
 
-		const topic = GOSSIP.MARKERS_BYTES[marker];
-		const senderId = associatedId;
 		const expiration = n + GOSSIP.CACHE_DURATION;
-		this.cache.push({ hash: h, senderId, topic, serializedMessage, timestamp, expiration });
+		this.cache.push({
+			hash: h,
+			senderId: associatedId,
+			topic,
+			serializedMessage,
+			timestamp,
+			expiration
+		});
 		this.seenTimeouts[h] = expiration;
 
 		if (--this.cleanupIn <= 0) this.#cleanupOldestEntries(n);
 		return { hash: h, isNew: !this.seenTimeouts[h] };
 	}
-	#cleanupOldestEntries(n = CLOCK.time) {
+	#cleanupOldestEntries(n = CLOCK.time || 0) {
 		let firstValidIndex = -1;
 		for (let i = 0; i < this.cache.length; i++)
 			if (this.cache[i].expiration <= n) delete this.seenTimeouts[this.cache[i].hash];
@@ -83,7 +93,7 @@ class DegenerateBloomFilter {
 }
 
 export class Gossip {
-	/** @type {Record<string, function(GossipMessage)[]>} */ callbacks = { message_handle: [] };
+	/** @type {Record<string, function[]>} */ callbacks = { message_handle: [] };
 	id; cryptoCodex; arbiter; peerStore; verbose; bloomFilter;
 
 	/** @param {string} selfId @param {import('./crypto-codex.mjs').CryptoCodex} cryptoCodex @param {import('./arbiter.mjs').Arbiter} arbiter @param {import('./peer-store.mjs').PeerStore} peerStore */
@@ -96,7 +106,7 @@ export class Gossip {
 		this.bloomFilter = new DegenerateBloomFilter(cryptoCodex);
 	}
 
-	/** @param {string} callbackType @param {function(GossipMessage)} callback */
+	/** @param {string} callbackType @param {function} callback */
 	on(callbackType, callback) {
 		if (!this.callbacks[callbackType]) this.callbacks[callbackType] = [callback];
 		else this.callbacks[callbackType].push(callback);
@@ -118,11 +128,12 @@ export class Gossip {
 		try { transportInstance.send(serializedMessage); }
 		catch (error) { this.peerStore.connected[targetId]?.close(); }
 	}
+	/** @param {string} peerId */
 	sendGossipHistoryToPeer(peerId) {
 		const gossipHistory = this.bloomFilter.getGossipHistoryByTime('asc');
 		for (const entry of gossipHistory) this.#broadcastSerializedToPeer(peerId, entry.data);
 	}
-	/** @param {string} from @param {Uint8Array} serialized @returns {void} */
+	/** @param {string} from @param {Uint8Array} serialized */
 	async handleGossipMessage(from, serialized) {
 		if (this.arbiter.isBanished(from)) return this.verbose >= 3 ? console.info(`%cReceived gossip message from banned peer ${from}, ignoring.`, 'color: red;') : null;
 		if (!this.arbiter.countMessageBytes(from, serialized.byteLength, 'gossip')) return; // ignore if flooding/banished

package/core/node.mjs

@@ -11,10 +11,8 @@ import { NodeServices } from './node-services.mjs';
 
 /**
  * @typedef {import('./unicast.mjs').DirectMessage} DirectMessage
- * @typedef {import('./unicast.mjs').ReroutedDirectMessage} ReroutedDirectMessage
  * @typedef {import('./gossip.mjs').GossipMessage} GossipMessage
- * @typedef {import('./topologist.mjs').SignalData} SignalData
- */
+ * @typedef {import('./topologist.mjs').SignalData} SignalData */
 
 /** Create and start a new PublicNode instance.
  * @param {Object} options

package/core/peer-store.mjs

@@ -1,6 +1,6 @@
 import { CLOCK } from '../services/clock.mjs';
 import { SIMULATION, NODE, DISCOVERY, LOG_CSS } from './config.mjs';
-const { SANDBOX, ICE_CANDIDATE_EMITTER, TEST_WS_EVENT_MANAGER } = SIMULATION.ENABLED ? await import('../simulation/test-transports.mjs') : {};
+const { SANDBOX, ICE_CANDIDATE_EMITTER, TEST_WS_EVENT_MANAGER } = SIMULATION.USE_TEST_TRANSPORTS ? await import('../simulation/test-transports.mjs') : {};
 
 export class KnownPeer { // known peer, not necessarily connected
 	neighbors; connectionsCount;

package/core/route-builder.mjs

@@ -55,11 +55,8 @@ export class RouteBuilder_V2 {
 			for (let i = 1; i < path.length; i++) {
 				const from = path[i - 1];
 				const to = path[i];
-				if (from === this.id) {
-					if (!this.peerStore.connected[to]) return false;
-				} else {
-					if (!this.peerStore.known[from]?.neighbors?.[to]) return false;
-				}
+				if (from === this.id) if (!this.peerStore.connected[to]) return false;
+				else if (!this.peerStore.known[from]?.neighbors?.[to]) return false;
 			}
 		}
 		return true;
@@ -100,7 +97,7 @@ export class RouteBuilder_V2 {
 		const backwardQueue = [{ node: remoteId, path: [remoteId], pathSet: new Set([remoteId]), depth: 0 }];
 		const backwardVisited = new Map(); // node -> path from remoteId
 		backwardVisited.set(remoteId, [remoteId]);
-
+		
 		const maxDepthPerSide = Math.ceil(maxHops / 2);
 		while ((forwardQueue.length > 0 || backwardQueue.length > 0) && nodesExplored < maxNodes) {
 			if (forwardQueue.length > 0) { // Expand forward search

package/core/topologist.mjs

@@ -1,7 +1,7 @@
 import { CLOCK } from '../services/clock.mjs';
 import { SIMULATION, TRANSPORTS, NODE, DISCOVERY, GOSSIP } from './config.mjs';
 import { PeerConnection } from './peer-store.mjs';
-const { SANDBOX, ICE_CANDIDATE_EMITTER, TEST_WS_EVENT_MANAGER } = SIMULATION.ENABLED ? await import('../simulation/test-transports.mjs') : {};
+const { SANDBOX, ICE_CANDIDATE_EMITTER, TEST_WS_EVENT_MANAGER } = SIMULATION.USE_TEST_TRANSPORTS ? await import('../simulation/test-transports.mjs') : {};
 
 /**
  * @typedef {Object} SignalData

package/core/unicast.mjs

@@ -1,7 +1,8 @@
+// @ts-check
 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 { SANDBOX, ICE_CANDIDATE_EMITTER, TEST_WS_EVENT_MANAGER } = SIMULATION.USE_TEST_TRANSPORTS ? await import('../simulation/test-transports.mjs') : {};
 const RouteBuilder = RouteBuilder_V2; // temporary switch
 
 export class DirectMessage { // TYPE DEFINITION
@@ -14,13 +15,29 @@ export class DirectMessage { // TYPE DEFINITION
 	signature;
 	signatureStart; // position in the serialized message where the signature starts
 	expectedEnd; // expected length of the serialized message
-	/** @type {string[] | undefined} */ newRoute; // for re-routing patch
+
+	/** Redirect only */ rerouterPubkey;
+	/** Redirect only */ newRoute; // for re-routing patch
+	/** Redirect only */ rerouterSignature;
+
 	get senderId() { return this.newRoute ? this.newRoute[0] : this.route[0]; }
+	get isRerouted() { return (this.rerouterPubkey && this.newRoute && this.rerouterSignature); }
+	getRerouterId() { if (this.newRoute) return this.newRoute[0]; }
 
-	/** @param {string} type @param {number} timestamp @param {string[]} neighborsList @param {string[]} route @param {Uint8Array} pubkey @param {string | Uint8Array | Object} data @param {Uint8Array | undefined} signature @param {number} signatureStart @param {number} expectedEnd */
-	constructor(type, timestamp, neighborsList, route, pubkey, data, signature, signatureStart, expectedEnd) {
+	/** 
+	 * @param {string} type @param {number} timestamp @param {string[]} neighborsList
+	 * @param {string[]} route @param {Uint8Array} pubkey @param {string | Uint8Array | Object} data
+	 * @param {Uint8Array | undefined} signature @param {number} signatureStart @param {number} expectedEnd
+	 * @param {Uint8Array} [rerouterPubkey] @param {string[]} [newRoute] @param {Uint8Array} [rerouterSignature] */
+	constructor(type, timestamp, neighborsList, route, pubkey, data, signature, signatureStart, expectedEnd, rerouterPubkey, newRoute, rerouterSignature) {
 		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;
+		this.route = route; this.pubkey = pubkey; this.data = data; this.signature = signature;
+		this.signatureStart = signatureStart;
+		this.expectedEnd = expectedEnd;
+
+		this.rerouterPubkey = rerouterPubkey;
+		this.newRoute = newRoute;
+		this.rerouterSignature = rerouterSignature;
 	}
 	getSenderId() { return this.route[0]; }
 	getTargetId() { return this.route[this.route.length - 1]; }
@@ -40,18 +57,6 @@ export class DirectMessage { // TYPE DEFINITION
 		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(DirectMessage)[]>} */ callbacks = { message_handle: [] };
@@ -89,7 +94,7 @@ export class UnicastMessager {
 		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 (route.length > UNICAST.MAX_HOPS + 1) {
 				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
 			}
@@ -105,7 +110,7 @@ export class UnicastMessager {
 		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) {
+		catch (/** @type {any} */ error) {
 			this.peerStore.kickPeer(targetId, 0, 'send-error');
 			if (this.verbose > 0) console.error(`Error sending message to ${targetId}:`, error.message);
 		}
@@ -141,14 +146,16 @@ export class UnicastMessager {
 		//if (this.id === targetId) { for (const cb of this.callbacks[message.type] || []) cb(senderId, message.data); return; } // message for self
 		if (this.id === targetId) { for (const cb of this.callbacks[message.type] || []) cb(message); return; } // message for self
 
-		// re-send the message to the next peer in the route
+		// re-send the message to the next peer in the route-
+		if (!nextId) throw new Error('Needs to tranmit message but no "nextId" provied!');
+		
 		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 (newRoute.length > UNICAST.MAX_HOPS + 1) {
 				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
 			}