@hive-p2p/server 1.0.65 → 1.0.67

package/core/crypto-codex.mjs

@@ -105,7 +105,7 @@ export class CryptoCodex {
 	async #generateAntiSybilIdentity(seed, asPublicNode) {
 		const maxIterations = (2 ** IDENTITY.DIFFICULTY) * 100; // avoid infinite loop
 		for (let i = 0; i < maxIterations; i++) { // avoid infinite loop
-			const { secretKey, publicKey } = ed25519.keygen(seed);
+			const { secretKey, publicKey } = await ed25519.keygenAsync(seed);
 			const id = this.#idFromPublicKey(publicKey);
 			if (asPublicNode && !this.isPublicNode(id)) continue; // Check prefix
 			if (!asPublicNode && this.isPublicNode(id)) continue; // Check prefix
@@ -120,13 +120,15 @@ export class CryptoCodex {
 	}
 
 	// MESSSAGE CREATION (SERIALIZATION AND SIGNATURE INCLUDED)
-	signBufferViewAndAppendSignature(bufferView, privateKey, signaturePosition = bufferView.length - IDENTITY.SIGNATURE_LENGTH) {
+	/** @param {Uint8Array} bufferView @param {Uint8Array} privateKey @param {number} [signaturePosition] */
+	async signBufferViewAndAppendSignature(bufferView, privateKey, signaturePosition = bufferView.length - IDENTITY.SIGNATURE_LENGTH) {
 		if (this.AVOID_CRYPTO) return;
 		const dataToSign = bufferView.subarray(0, signaturePosition);
-		bufferView.set(ed25519.sign(dataToSign, privateKey), signaturePosition);
+		const signature = await ed25519.signAsync(dataToSign, privateKey);
+		bufferView.set(signature, signaturePosition);
 	}
 	/** @param {string} topic @param {string | Uint8Array | Object} data @param {number} [HOPS] @param {string[]} route @param {string[]} [neighbors] */
-	createGossipMessage(topic, data, HOPS = 3, neighbors = [], timestamp = CLOCK.time) {
+	async 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}'.`);
 		
@@ -140,7 +142,7 @@ export class CryptoCodex {
 		bufferView.set(neighborsBytes, 47); 					// X bytes for neighbors
 		bufferView.set(dataBytes, 47 + neighborsBytes.length); 	// X bytes for data
 		bufferView.set([Math.min(255, HOPS)], totalBytes - 1); 	// 1 byte for HOPS (Unsigned)
-		this.signBufferViewAndAppendSignature(bufferView, this.privateKey, totalBytes - IDENTITY.SIGNATURE_LENGTH - 1);
+		await this.signBufferViewAndAppendSignature(bufferView, this.privateKey, totalBytes - IDENTITY.SIGNATURE_LENGTH - 1);
 		return bufferView;
 	}
 	/** @param {Uint8Array} serializedMessage */
@@ -151,7 +153,7 @@ export class CryptoCodex {
 		return clone;
 	}
 	/** @param {string} type @param {string | Uint8Array | Object} data @param {string[]} route @param {string[]} [neighbors] */
-	createUnicastMessage(type, data, route, neighbors = [], timestamp = CLOCK.time) {
+	async createUnicastMessage(type, data, route, neighbors = [], timestamp = CLOCK.time) {
 		const MARKER = UNICAST.MARKERS_BYTES[type];
 		if (MARKER === undefined) throw new Error(`Failed to create unicast message: unknown type '${type}'.`);
 		if (route.length < 2) throw new Error('Failed to create unicast message: route must have at least 2 nodes (next hop and target).');
@@ -171,11 +173,11 @@ export class CryptoCodex {
 		bufferView.set([route.length], 47 + NDBL);				// 1 byte for route length
 		bufferView.set(routeBytes, 47 + 1 + NDBL);				// X bytes for route
 
-		this.signBufferViewAndAppendSignature(bufferView, this.privateKey, totalBytes - IDENTITY.SIGNATURE_LENGTH);
+		await this.signBufferViewAndAppendSignature(bufferView, this.privateKey, totalBytes - IDENTITY.SIGNATURE_LENGTH);
 		return bufferView;
 	}
 	/** @param {Uint8Array} serialized @param {string[]} newRoute */
-	createReroutedUnicastMessage(serialized, newRoute) {
+	async 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}).`);
 	
@@ -187,7 +189,7 @@ export class CryptoCodex {
 		bufferView.set(this.publicKey, serialized.length); // 32 bytes for new public key
 		for (let i = 0; i < routeBytesArray.length; i++) bufferView.set(routeBytesArray[i], serialized.length + 32 + (i * IDENTITY.ID_LENGTH)); // new route
 		
-		this.signBufferViewAndAppendSignature(bufferView, this.privateKey, totalBytes - IDENTITY.SIGNATURE_LENGTH);
+		await this.signBufferViewAndAppendSignature(bufferView, this.privateKey, totalBytes - IDENTITY.SIGNATURE_LENGTH);
 		return bufferView;
 	}
 	/** @param {string[]} ids */
@@ -217,8 +219,6 @@ export class CryptoCodex {
 	/** @param {Uint8Array} publicKey @param {Uint8Array} dataToVerify @param {Uint8Array} signature */
 	async verifySignature(publicKey, dataToVerify, signature) {
 		if (this.AVOID_CRYPTO) return true;
-		//return ed25519.verifyAsync(signature, dataToVerify, publicKey);
-		// new version with batching to optimize timings using ed25519 async.
 		return this.verifier.verifySignature(publicKey, dataToVerify, signature);
 	}
 	/** @param {Uint8Array} bufferView */

package/core/gossip.mjs

@@ -103,9 +103,9 @@ export class Gossip {
 	}
 	/** Gossip a message to all connected peers > will be forwarded to all peers
 	 * @param {string | Uint8Array | Object} data @param {string} topic default: 'gossip' @param {number} [HOPS] */
-	broadcastToAll(data, topic = 'gossip', HOPS) {
+	async broadcastToAll(data, topic = 'gossip', HOPS) {
 		const hops = HOPS || GOSSIP.HOPS[topic] || GOSSIP.HOPS.default;
-		const serializedMessage = this.cryptoCodex.createGossipMessage(topic, data, hops, this.peerStore.neighborsList);
+		const serializedMessage = await this.cryptoCodex.createGossipMessage(topic, data, hops, this.peerStore.neighborsList);
 		if (!this.bloomFilter.addMessage(serializedMessage)) return; // avoid sending duplicate messages
 		if (this.verbose > 3) console.log(`(${this.id}) Gossip ${topic}, to ${JSON.stringify(this.peerStore.neighborsList)}: ${data}`);
 		for (const peerId of this.peerStore.neighborsList) this.#broadcastToPeer(peerId, serializedMessage);

package/core/node-services.mjs

@@ -51,7 +51,7 @@ export class NodeServices {
 	#startWebSocketServer(domain = 'localhost', port = SERVICE.PORT) {
 		this.wsServer = new TRANSPORTS.WS_SERVER({ port, host: domain });
 		this.wsServer.on('error', (error) => console.error(`WebSocket error on Node #${this.id}:`, error));
-		this.wsServer.on('connection', (ws) => {
+		this.wsServer.on('connection', async (ws) => {
 			ws.on('close', () => { if (remoteId) for (const cb of this.peerStore.callbacks.disconnect) cb(remoteId, 'in'); });
 			ws.on('error', (error) => console.error(`WebSocket error on Node #${this.id} with peer ${remoteId}:`, error.stack));
 
@@ -78,7 +78,9 @@ export class NodeServices {
 					for (const cb of this.peerStore.callbacks.connect) cb(remoteId, 'in');
 				}
 			});
-			ws.send(this.cryptoCodex.createUnicastMessage('handshake', null, [this.id, this.id], this.peerStore.neighborsList));
+
+			const handshakeMsg = await this.cryptoCodex.createUnicastMessage('handshake', null, [this.id, this.id], this.peerStore.neighborsList);
+			ws.send(handshakeMsg);
 		});
 	}
 	#startSTUNServer(host = 'localhost', port = SERVICE.PORT + 1) {

package/core/node.mjs

@@ -162,10 +162,10 @@ export class Node {
 	/** Broadcast a message to all connected peers or to a specified peer
 	 * @param {string | Uint8Array | Object} data @param {string} topic default: 'gossip' @param {string} [targetId] default: broadcast to all
 	 * @param {number} [timestamp] default: CLOCK.time @param {number} [HOPS] default: GOSSIP.HOPS[topic] || GOSSIP.HOPS.default */
-	broadcast(data, topic, HOPS) { this.gossip.broadcastToAll(data, topic, HOPS); }
+	async broadcast(data, topic, HOPS) { return this.gossip.broadcastToAll(data, topic, HOPS); }
 	
 	/** @param {string} remoteId @param {string | Uint8Array | Object} data @param {string} type */
-	sendMessage(remoteId, data, type, spread = 1) { this.messager.sendUnicast(remoteId, data, type, spread); }
+	async sendMessage(remoteId, data, type, spread = 1) { return this.messager.sendUnicast(remoteId, data, type, spread); }
 
 	/** Send a connection request to a peer */
 	async tryConnectToPeer(targetId = 'toto', retry = 10) {

package/core/topologist.mjs

@@ -169,7 +169,7 @@ export class Topologist {
 		let remoteId = null;
 		const ws = new TRANSPORTS.WS_CLIENT(this.#getFullWsUrl(publicUrl)); ws.binaryType = 'arraybuffer';
 		ws.onerror = (error) => console.error(`WebSocket error:`, error.stack);
-		ws.onopen = () => {
+		ws.onopen = async () => {
 			this.bootstrapsConnectionState.set(publicUrl, true);
 			ws.onclose = () => {
 				this.bootstrapsConnectionState.set(publicUrl, false);
@@ -197,8 +197,9 @@ export class Topologist {
 					for (const cb of this.peerStore.callbacks.connect) cb(remoteId, 'out');
 				}
 			};
-			ws.send(this.cryptoCodex.createUnicastMessage('handshake', null, [this.id, this.id], this.peerStore.neighborsList));
-		};		
+			const handshakeMsg = await this.cryptoCodex.createUnicastMessage('handshake', null, [this.id, this.id], this.peerStore.neighborsList);
+			ws.send(handshakeMsg);
+		};
 	}
 	#tryToSpreadSDP(nonPublicNeighborsCount = 0, isHalfReached = false) { // LOOP TO SELECT ONE UNSEND READY OFFER AND BROADCAST IT
 		if (!this.automation.spreadOffers) return;

package/core/unicast.mjs

@@ -76,13 +76,14 @@ export class UnicastMessager {
 	/** 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) {
+	async 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 createdMessagePromises = [];
 		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;
@@ -90,9 +91,11 @@ export class UnicastMessager {
 				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
+			createdMessagePromises.push(this.cryptoCodex.createUnicastMessage(type, data, route, this.peerStore.neighborsList));
 		}
+
+		const createdMessages = await Promise.all(createdMessagePromises);
+		for (const message of createdMessages) this.#sendMessageToPeer(message.route[1], message);
 		return true;
 	}
 	/** @param {string} targetId @param {Uint8Array} serialized */
@@ -148,7 +151,7 @@ export class UnicastMessager {
 				return; // too long route
 			}
 				
-			const patchedMessage = this.cryptoCodex.createReroutedUnicastMessage(serialized, newRoute);
+			const patchedMessage = await this.cryptoCodex.createReroutedUnicastMessage(serialized, newRoute);
 			const nextPeerId = newRoute[selfPosition + 1];
 			this.#sendMessageToPeer(nextPeerId, patchedMessage);
 		}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hive-p2p/server",
-  "version": "1.0.65",
+  "version": "1.0.67",
   "publishConfig": {
     "access": "public"
   },

package/services/cryptos.mjs

@@ -2,14 +2,19 @@ import { Converter } from './converter.mjs';
 const IS_BROWSER = typeof window !== 'undefined';
 
 // ED25519 EXPOSURE NODEJS/BROWSER COMPATIBLE ---------------------------------
-const [ed_, {sha512}] = await Promise.all([
+/*const [ed_, {sha512}] = await Promise.all([
     import(IS_BROWSER ? '../libs/ed25519-custom.min.js' : '@noble/ed25519'),
     import(IS_BROWSER ? '../libs/ed25519-custom.min.js' : '@noble/hashes/sha2.js')
-]);
+]);*/
+
+// Now we only use nodejs version without sha512
+const ed_ = await import('@noble/ed25519');
+
 /** @type {import('@noble/ed25519')} */
 const ed25519 = ed_.default || ed_;
-ed25519.hashes.sha512 = sha512;
-export { ed25519, sha512 };
+//ed25519.hashes.sha512 = sha512;
+//export { ed25519, sha512 };
+export { ed25519 };
 
 //-----------------------------------------------------------------------------