@hive-p2p/browser 1.0.89 → 1.0.90

package/core/crypto-codex.mjs

@@ -9,7 +9,7 @@ import { concatBytes } from '@noble/ciphers/utils.js';
 export class CryptoCodex {
 	argon2 = new Argon2Unified();
 	converter = new Converter();
-	AVOID_CRYPTO = false;
+	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;
     /** @type {Uint8Array} */ publicKey;
@@ -92,6 +92,11 @@ 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) {

package/core/gossip.mjs

@@ -83,7 +83,7 @@ class DegenerateBloomFilter {
 }
 
 export class Gossip {
-	/** @type {Record<string, Function[]>} */ callbacks = { message_handle: [] };
+	/** @type {Record<string, function(GossipMessage)[]>} */ 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 +96,7 @@ export class Gossip {
 		this.bloomFilter = new DegenerateBloomFilter(cryptoCodex);
 	}
 
-	/** @param {string} callbackType @param {Function} callback */
+	/** @param {string} callbackType @param {function(GossipMessage)} callback */
 	on(callbackType, callback) {
 		if (!this.callbacks[callbackType]) this.callbacks[callbackType] = [callback];
 		else this.callbacks[callbackType].push(callback);
@@ -131,6 +131,7 @@ export class Gossip {
 
 		const message = this.cryptoCodex.readGossipMessage(serialized);
 		if (!message) return this.arbiter.countPeerAction(from, 'WRONG_SERIALIZATION');
+
 		const isOk = await this.arbiter.digestMessage(from, message, serialized);
 		if (!isOk) return; // invalid message or from banished peer
 		if (this.arbiter.isBanished(from)) return; // ignore messages from banished peers
@@ -144,7 +145,8 @@ export class Gossip {
 			else console.log(`(${this.id}) Gossip ${topic} from ${senderId} (by: ${from}): ${data}`);
 
 		this.peerStore.digestPeerNeighbors(senderId, neighborsList);
-		for (const cb of this.callbacks[topic] || []) cb(senderId, data, HOPS, message); // specific topic callback
+		//for (const cb of this.callbacks[topic] || []) cb(senderId, data, HOPS, message); // specific topic callback
+		for (const cb of this.callbacks[topic] || []) cb(message); // specific topic callback with full message object
 		if (HOPS < 1) return; // stop forwarding if HOPS is 0
 
 		const nCount = this.peerStore.neighborsList.length;

package/core/node.mjs

@@ -9,6 +9,13 @@ import { Topologist } from './topologist.mjs';
 import { CryptoCodex } from './crypto-codex.mjs';
 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
+ */
+
 /** Create and start a new PublicNode instance.
  * @param {Object} options
  * @param {string[]} options.bootstraps List of bootstrap nodes used as P2P network entry
@@ -86,12 +93,12 @@ export class Node {
 		peerStore.on('data', (peerId, data) => this.#onData(peerId, data));
 		
 		// UNICAST LISTENERS
-		messager.on('signal_answer', (senderId, data) => topologist.handleIncomingSignal(senderId, data));
-		messager.on('signal_offer', (senderId, data) => topologist.handleIncomingSignal(senderId, data));
-		messager.on('privacy', (senderId, data) => this.#handlePrivacy(senderId, data));
+		messager.on('signal_answer', (msg) => topologist.handleIncomingSignal(msg.senderId, msg.data));
+		messager.on('signal_offer', (msg) => topologist.handleIncomingSignal(msg.senderId, msg.data));
+		messager.on('privacy', (msg) => this.#handlePrivacy(msg));
 
 		// GOSSIP LISTENERS
-		gossip.on('signal_offer', (senderId, data, HOPS) => topologist.handleIncomingSignal(senderId, data, HOPS));
+		gossip.on('signal_offer', (msg) => topologist.handleIncomingSignal(msg.senderId, msg.data));
 
 		if (verbose > 2) console.log(`Node initialized: ${this.id}`);
 	}
@@ -221,8 +228,13 @@ export class Node {
 		}
 		return p;
 	}
-	/** @param {string} senderId @param {Uint8Array} peerPub */
-	#handlePrivacy(senderId, peerPub) {
+	/** @param {DirectMessage} msg */
+	#handlePrivacy(msg) {
+		const { senderId, data: peerPub } = msg;
+		if (!(peerPub instanceof Uint8Array)) {
+			this.verbose > 1 ? console.warn(`Received invalid privacy message from ${senderId}, expected peer public key as Uint8Array.`) : null;
+			return;
+		}
 		if (this.peerStore.privacy[senderId]?.sharedSecret) return; // already have shared secret
 		
 		if (!this.peerStore.privacy[senderId])
@@ -256,36 +268,24 @@ export class Node {
 	}
 
 	// HANDLERS REGISTRATION --------------------------------------------------
-
 	/** Triggered when a new peer connection is established.
 	 *  @param {function} callback can use arguments: (peerId:string, direction:string) */
 	onPeerConnect(callback) { this.peerStore.on('connect', callback); }
-	
-	/** Triggered when a peer connection is closed.
-	 *  @param {function} callback can use arguments: (peerId:string, direction:string) */
+	/** Triggered when a peer connection is closed. @param {function} callback can use arguments: (peerId:string, direction:string) */
 	onPeerDisconnect(callback) { this.peerStore.on('disconnect', callback); }
-
-	/** Triggered when a new message is received.
-	 *  @param {function} callback can use arguments: (senderId:string, data:any) */
+	/** Triggered when a new message is received. @param {function(DirectMessage)} callback */
 	onMessageData(callback, includesPrivate = true) {
 		this.messager.on('message', callback);
 		if (includesPrivate) this.messager.on('private_message', callback);
 	}
-
-	/** Triggered when a new private message is received.
-	 * @param {function} callback can use arguments: (senderId:string, data:any) */
+	/** Triggered when a new private message is received. @param {function(DirectMessage)} callback */
 	onPrivateMessageData(callback) { this.messager.on('private_message', callback); }
-
-	/** Triggered when a new gossip message is received.
-	 * @param {function} callback can use arguments: (senderId:string, data:any, HOPS:number) */
+	/** Triggered when a new gossip message is received. @param {function(GossipMessage)} callback */
 	onGossipData(callback) { this.gossip.on('gossip', callback); }
-
-	/** Triggered when a new signal offer is received from another peer.
-	 *  @param {function} callback can use arguments: (senderId:string, data:SignalData) */
+	/** Triggered when a new signal offer is received from another peer. @param {function(string, SignalData)} callback can use arguments: (senderId:string, data:SignalData) */
 	onSignalOffer(callback) { this.messager.on('signal_offer', callback); this.gossip.on('signal_offer', callback); }
-
 	/** Triggered when a new signal answer is received from another peer.
-	 * @param {function} callback can use arguments: (senderId:string, data:SignalData) */
+	 * @param {function(string, SignalData)} callback can use arguments: (senderId:string, data:SignalData) */
 	onSignalAnswer(callback) { this.messager.on('signal_answer', callback); }
 
 	/** Kick a peer.  @param {string} peerId @param {string} [reason] */

package/core/topologist.mjs

@@ -17,7 +17,9 @@ const { SANDBOX, ICE_CANDIDATE_EMITTER, TEST_WS_EVENT_MANAGER } = SIMULATION.ENA
  * @property {number} overlap
  * @property {number} neighborsCount
  * @property {number} timestamp
- * */
+ * 
+ * @typedef {import('./unicast.mjs').DirectMessage} DirectMessage
+ * @typedef {import('./gossip.mjs').GossipMessage} GossipMessage */
 
 export class OfferQueue {
 	maxOffers = 30;
@@ -88,8 +90,8 @@ export class Topologist {
 		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) {
+	/** @param {string} senderId @param {SignalData} data */
+	handleIncomingSignal(senderId, data) {
 		if (this.isPublicNode || !senderId || this.peerStore.isKicked(senderId)) return;
 		if (data.signal?.type !== 'offer' && data.signal?.type !== 'answer') return;
 		

package/core/unicast.mjs

@@ -14,8 +14,10 @@ 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
+	get senderId() { return this.newRoute ? this.newRoute[0] : this.route[0]; }
 
-	/** @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 */
+	/** @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) {
 		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;
@@ -30,7 +32,8 @@ export class DirectMessage { // TYPE DEFINITION
 			traveledRoute.push(route[i]);
 			if (route[i] === selfId) { selfPosition = i; break; }
 		}
-		const senderId = route[0];
+		//const senderId = route[0];
+		const senderId = this.senderId;
 		const targetId = route[route.length - 1];
 		const prevId = selfPosition > 0 ? route[selfPosition - 1] : null;
 		const nextId = (selfPosition !== -1) ? route[selfPosition + 1] : null;
@@ -51,7 +54,7 @@ export class ReroutedDirectMessage extends DirectMessage {
 }
 
 export class UnicastMessager {
-	/** @type {Record<string, Function[]>} */ callbacks = { message_handle: [] };
+	/** @type {Record<string, function(DirectMessage)[]>} */ callbacks = { message_handle: [] };
 	id; cryptoCodex; arbiter; peerStore; verbose; pathFinder;
 	
 	maxHops = UNICAST.MAX_HOPS;
@@ -68,7 +71,7 @@ export class UnicastMessager {
 		this.pathFinder = new RouteBuilder(this.id, this.peerStore);
 	}
 
-	/** @param {string} callbackType @param {Function} callback */
+	/** @param {string} callbackType @param {function(DirectMessage)} callback */
 	on(callbackType, callback) {
 		if (!this.callbacks[callbackType]) this.callbacks[callbackType] = [callback];
 		else this.callbacks[callbackType].push(callback);
@@ -135,7 +138,8 @@ export class UnicastMessager {
 		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
+		//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
 		const { success, reason } = this.#sendMessageToPeer(nextId, serialized);