@hive-p2p/server 1.0.64 → 1.0.66

package/core/crypto-codex.mjs

@@ -5,10 +5,54 @@ import { DirectMessage, ReroutedDirectMessage } from './unicast.mjs';
 import { Converter } from '../services/converter.mjs';
 import { ed25519, Argon2Unified } from '../services/cryptos.mjs'; // now exposed in full and browser builds
 
+class Ed25519BatchVerifier {
+	#verifyQueue = [];
+	#verifyResolvers = new Map();
+	#batchTimer = null;
+	#nextId = 0;
+	#BATCH_SIZE = 10;
+	#BATCH_TIMEOUT = 5;
+
+	verifySignature(publicKey, dataToVerify, signature) {
+		return new Promise((resolve) => {
+			const id = this.#nextId++;
+			this.#verifyQueue.push({ id, publicKey, dataToVerify, signature });
+			this.#verifyResolvers.set(id, resolve);
+
+			// Flush immediately if batch full
+			if (this.#verifyQueue.length >= this.#BATCH_SIZE) {
+				this.#flushBatch();
+				return;
+			}
+
+			// Otherwise schedule flush
+			if (!this.#batchTimer)
+				this.#batchTimer = setTimeout(() => this.#flushBatch(), this.#BATCH_TIMEOUT);
+		});
+	}
+
+	async #flushBatch() {
+		if (this.#batchTimer) clearTimeout(this.#batchTimer), this.#batchTimer = null;
+		if (this.#verifyQueue.length === 0) return;
+
+		const batch = this.#verifyQueue.splice(0);
+		const results = await Promise.all(
+			batch.map(item => ed25519.verifyAsync(item.signature, item.dataToVerify, item.publicKey))
+		);
+
+		for (let i = 0; i < batch.length; i++) {
+			this.#verifyResolvers.get(batch[i].id)(results[i]);
+			this.#verifyResolvers.delete(batch[i].id);
+		}
+	}
+}
+
 export class CryptoCodex {
 	argon2 = new Argon2Unified();
 	converter = new Converter();
 	AVOID_CRYPTO = false;
+	/** @type {Ed25519BatchVerifier} only if "AVOID_CRYPTO" is disabled*/
+	verifier;
 	verbose = NODE.DEFAULT_VERBOSE;
 	/** @type {string} */ id;
     /** @type {Uint8Array} */ publicKey;
@@ -17,8 +61,9 @@ export class CryptoCodex {
 	/** @param {string} [nodeId] If provided: used to generate a fake keypair > disable crypto operations */
 	constructor(nodeId, verbose = NODE.DEFAULT_VERBOSE) {
 		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.AVOID_CRYPTO = true;
+
 		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
@@ -42,6 +87,8 @@ export class CryptoCodex {
 	async generate(asPublicNode, seed) { // Generate Ed25519 keypair cross-platform | set id only for simulator
 		if (this.nodeId) return;
 		await this.#generateAntiSybilIdentity(seed, asPublicNode);
+		this.AVOID_CRYPTO = false; // enable crypto operations
+		this.verifier = new Ed25519BatchVerifier();
 		if (!this.id) throw new Error('Failed to generate identity');
     }
 	/** Check if the pubKey meets the difficulty using Argon2 derivation @param {Uint8Array} publicKey */
@@ -58,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
@@ -73,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}'.`);
 		
@@ -93,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 */
@@ -104,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).');
@@ -124,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}).`);
 	
@@ -140,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 */
@@ -170,7 +219,7 @@ 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);
+		return this.verifier.verifySignature(publicKey, dataToVerify, signature);
 	}
 	/** @param {Uint8Array} bufferView */
 	readBufferHeader(bufferView, readAssociatedId = true) {

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,7 +76,7 @@ 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);
@@ -90,7 +90,7 @@ 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);
+			const message = await this.cryptoCodex.createUnicastMessage(type, data, route, this.peerStore.neighborsList);
 			this.#sendMessageToPeer(route[1], message); // send to next peer
 		}
 		return true;
@@ -148,7 +148,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.64",
+  "version": "1.0.66",
   "publishConfig": {
     "access": "public"
   },

package/services/cryptos.mjs

@@ -6,16 +6,14 @@ const IS_BROWSER = typeof window !== 'undefined';
     import(IS_BROWSER ? '../libs/ed25519-custom.min.js' : '@noble/ed25519'),
     import(IS_BROWSER ? '../libs/ed25519-custom.min.js' : '@noble/hashes/sha2.js')
 ]);*/
-/** @type {import('@noble/ed25519')} */
-//const ed25519 = ed_.default || ed_;
-//ed25519.hashes.sha512 = sha512;
-//export { ed25519, sha512 };
 
-const [ed_] = await Promise.all([
-    import(IS_BROWSER ? '../libs/ed25519-custom.min.js' : '@noble/ed25519'),
-]);
+// 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 };
 export { ed25519 };
 
 //-----------------------------------------------------------------------------