@hive-p2p/server 1.0.67 → 1.0.69

package/core/arbiter.mjs

@@ -99,7 +99,7 @@ export class Arbiter {
 	/** Call from HiveP2P module only! @param {string} from @param {any} message @param {Uint8Array} serialized @param {number} [powCheckFactor] default: 0.01 (1%) */
 	async digestMessage(from, message, serialized, powCheckFactor = .01) {
 		const { senderId, pubkey, topic, expectedEnd } = message; // avoid powControl() on banished peers
-		if (!await this.#signatureControl(from, message, serialized)) return;
+		if (!this.#signatureControl(from, message, serialized)) return;
 		if (!this.#lengthControl(from, topic ? 'gossip' : 'unicast', serialized, expectedEnd)) return;
 
 		const routeOrHopsOk = topic ? this.#hopsControl(from, message) : this.#routeLengthControl(from, message);
@@ -111,11 +111,11 @@ export class Arbiter {
 		return true;
 	}
 	/** @param {string} from @param {import('./gossip.mjs').GossipMessage} message @param {Uint8Array} serialized */
-	async #signatureControl(from, message, serialized) {
+	#signatureControl(from, message, serialized) {
 		try {
 			const { pubkey, signature, signatureStart } = message;
 			const signedData = serialized.subarray(0, signatureStart);
-			const signatureValid = await this.cryptoCodex.verifySignature(pubkey, signedData, signature);
+			const signatureValid = this.cryptoCodex.verifySignature(pubkey, signedData, signature);
 			if (!signatureValid) throw new Error('Gossip signature invalid');
 			this.adjustTrust(from, TRUST_VALUES.VALID_SIGNATURE, 'Gossip signature valid');
 			return true;

package/core/crypto-codex.mjs

@@ -5,54 +5,10 @@ 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;
@@ -88,7 +44,6 @@ export class CryptoCodex {
 		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 */
@@ -105,7 +60,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 } = await ed25519.keygenAsync(seed);
+			const { secretKey, publicKey } = ed25519.keygen(seed);
 			const id = this.#idFromPublicKey(publicKey);
 			if (asPublicNode && !this.isPublicNode(id)) continue; // Check prefix
 			if (!asPublicNode && this.isPublicNode(id)) continue; // Check prefix
@@ -121,14 +76,14 @@ export class CryptoCodex {
 
 	// MESSSAGE CREATION (SERIALIZATION AND SIGNATURE INCLUDED)
 	/** @param {Uint8Array} bufferView @param {Uint8Array} privateKey @param {number} [signaturePosition] */
-	async signBufferViewAndAppendSignature(bufferView, privateKey, signaturePosition = bufferView.length - IDENTITY.SIGNATURE_LENGTH) {
+	signBufferViewAndAppendSignature(bufferView, privateKey, signaturePosition = bufferView.length - IDENTITY.SIGNATURE_LENGTH) {
 		if (this.AVOID_CRYPTO) return;
 		const dataToSign = bufferView.subarray(0, signaturePosition);
-		const signature = await ed25519.signAsync(dataToSign, privateKey);
+		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] */
-	async createGossipMessage(topic, data, HOPS = 3, neighbors = [], timestamp = CLOCK.time) {
+	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}'.`);
 		
@@ -142,7 +97,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)
-		await this.signBufferViewAndAppendSignature(bufferView, this.privateKey, totalBytes - IDENTITY.SIGNATURE_LENGTH - 1);
+		this.signBufferViewAndAppendSignature(bufferView, this.privateKey, totalBytes - IDENTITY.SIGNATURE_LENGTH - 1);
 		return bufferView;
 	}
 	/** @param {Uint8Array} serializedMessage */
@@ -153,7 +108,7 @@ export class CryptoCodex {
 		return clone;
 	}
 	/** @param {string} type @param {string | Uint8Array | Object} data @param {string[]} route @param {string[]} [neighbors] */
-	async createUnicastMessage(type, data, route, neighbors = [], timestamp = CLOCK.time) {
+	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).');
@@ -173,11 +128,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
 
-		await this.signBufferViewAndAppendSignature(bufferView, this.privateKey, totalBytes - IDENTITY.SIGNATURE_LENGTH);
+		this.signBufferViewAndAppendSignature(bufferView, this.privateKey, totalBytes - IDENTITY.SIGNATURE_LENGTH);
 		return bufferView;
 	}
 	/** @param {Uint8Array} serialized @param {string[]} newRoute */
-	async createReroutedUnicastMessage(serialized, 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}).`);
 	
@@ -189,7 +144,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
 		
-		await this.signBufferViewAndAppendSignature(bufferView, this.privateKey, totalBytes - IDENTITY.SIGNATURE_LENGTH);
+		this.signBufferViewAndAppendSignature(bufferView, this.privateKey, totalBytes - IDENTITY.SIGNATURE_LENGTH);
 		return bufferView;
 	}
 	/** @param {string[]} ids */
@@ -217,9 +172,9 @@ export class CryptoCodex {
 
 	// MESSSAGE READING (DESERIALIZATION AND SIGNATURE VERIFICATION INCLUDED)
 	/** @param {Uint8Array} publicKey @param {Uint8Array} dataToVerify @param {Uint8Array} signature */
-	async verifySignature(publicKey, dataToVerify, signature) {
+	verifySignature(publicKey, dataToVerify, signature) {
 		if (this.AVOID_CRYPTO) return true;
-		return this.verifier.verifySignature(publicKey, dataToVerify, signature);
+		return ed25519.verify(signature, dataToVerify, publicKey);
 	}
 	/** @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] */
-	async broadcastToAll(data, topic = 'gossip', HOPS) {
+	broadcastToAll(data, topic = 'gossip', HOPS) {
 		const hops = HOPS || GOSSIP.HOPS[topic] || GOSSIP.HOPS.default;
-		const serializedMessage = await this.cryptoCodex.createGossipMessage(topic, data, hops, this.peerStore.neighborsList);
+		const serializedMessage = 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,12 +51,12 @@ 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', async (ws) => {
+		this.wsServer.on('connection', (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));
 
 			let remoteId;
-			ws.on('message', async (data) => { // When peer proves his id, we can handle data normally
+			ws.on('message', (data) => { // When peer proves his id, we can handle data normally
 				if (remoteId) for (const cb of this.peerStore.callbacks.data) cb(remoteId, data);
 				else { // FIRST MESSAGE SHOULD BE HANDSHAKE WITH ID
 					const d = new Uint8Array(data); if (d[0] > 127) return; // not unicast, ignore
@@ -68,7 +68,7 @@ export class NodeServices {
 
 					const { signatureStart, pubkey, signature } = message;
 					const signedData = d.subarray(0, signatureStart);
-					if (!await this.cryptoCodex.verifySignature(pubkey, signedData, signature)) return;
+					if (!this.cryptoCodex.verifySignature(pubkey, signedData, signature)) return;
 
 					remoteId = route[0];
 					this.peerStore.digestPeerNeighbors(remoteId, neighborsList); // Update known store
@@ -79,8 +79,7 @@ export class NodeServices {
 				}
 			});
 
-			const handshakeMsg = await this.cryptoCodex.createUnicastMessage('handshake', null, [this.id, this.id], this.peerStore.neighborsList);
-			ws.send(handshakeMsg);
+			ws.send(this.cryptoCodex.createUnicastMessage('handshake', null, [this.id, this.id], this.peerStore.neighborsList));
 		});
 	}
 	#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 */
-	async broadcast(data, topic, HOPS) { return this.gossip.broadcastToAll(data, topic, HOPS); }
+	broadcast(data, topic, HOPS) { return this.gossip.broadcastToAll(data, topic, HOPS); }
 	
 	/** @param {string} remoteId @param {string | Uint8Array | Object} data @param {string} type */
-	async sendMessage(remoteId, data, type, spread = 1) { return this.messager.sendUnicast(remoteId, data, type, spread); }
+	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,13 +169,13 @@ 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 = async () => {
+		ws.onopen = () => {
 			this.bootstrapsConnectionState.set(publicUrl, true);
 			ws.onclose = () => {
 				this.bootstrapsConnectionState.set(publicUrl, false);
 				for (const cb of this.peerStore.callbacks.disconnect) cb(remoteId, 'out');
 			}
-			ws.onmessage = async (data) => {
+			ws.onmessage = (data) => {
 				if (remoteId) for (const cb of this.peerStore.callbacks.data) cb(remoteId, data.data);
 				else { // FIRST MESSAGE SHOULD BE HANDSHAKE WITH ID
 					const d = new Uint8Array(data.data); if (d[0] > 127) return; // not unicast, ignore
@@ -187,7 +187,7 @@ export class Topologist {
 
 					const { signatureStart, pubkey, signature } = message;
 					const signedData = d.subarray(0, signatureStart);
-					if (!await this.cryptoCodex.verifySignature(pubkey, signedData, signature)) return;
+					if (!this.cryptoCodex.verifySignature(pubkey, signedData, signature)) return;
 
 					remoteId = route[0];
 					this.peerStore.digestPeerNeighbors(remoteId, neighborsList); // Update known store
@@ -197,8 +197,8 @@ export class Topologist {
 					for (const cb of this.peerStore.callbacks.connect) cb(remoteId, 'out');
 				}
 			};
-			const handshakeMsg = await this.cryptoCodex.createUnicastMessage('handshake', null, [this.id, this.id], this.peerStore.neighborsList);
-			ws.send(handshakeMsg);
+
+			ws.send(this.cryptoCodex.createUnicastMessage('handshake', null, [this.id, this.id], this.peerStore.neighborsList));
 		};
 	}
 	#tryToSpreadSDP(nonPublicNeighborsCount = 0, isHalfReached = false) { // LOOP TO SELECT ONE UNSEND READY OFFER AND BROADCAST IT

package/core/unicast.mjs

@@ -76,14 +76,13 @@ 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 */
-	async sendUnicast(remoteId, data, type = 'message', spread = 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 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;
@@ -91,11 +90,9 @@ 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
 			}
-			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);
+			this.#sendMessageToPeer(route[1], this.cryptoCodex.createUnicastMessage(type, data, route, this.peerStore.neighborsList));
+		}
 		return true;
 	}
 	/** @param {string} targetId @param {Uint8Array} serialized */

package/package.json

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

package/services/cryptos.mjs

@@ -2,19 +2,11 @@ import { Converter } from './converter.mjs';
 const IS_BROWSER = typeof window !== 'undefined';
 
 // ED25519 EXPOSURE NODEJS/BROWSER COMPATIBLE ---------------------------------
-/*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')
-]);*/
+const { ed25519, x25519 } = await import('@noble/curves/ed25519.js');
+const { chacha20poly1305 } = await import('@noble/ciphers/chacha.js');
+const { randomBytes } = await import('@noble/ciphers/utils.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 };
-export { ed25519 };
+export { ed25519, x25519, chacha20poly1305, randomBytes };
 
 //-----------------------------------------------------------------------------