hive-p2p 1.0.0

package/libs/xxhash32.mjs

@@ -0,0 +1,65 @@
+const PRIME32_1 = 2654435761;
+const PRIME32_2 = 2246822519;
+const PRIME32_3 = 3266489917;
+const PRIME32_4 = 668265263;
+const PRIME32_5 = 374761393;
+let encoder;
+/** @param input - byte array or string @param seed - optional seed (32-bit unsigned); */
+export function xxHash32(input, seed = 0) {
+    const buffer = typeof input === 'string' ? (encoder ??= new TextEncoder()).encode(input) : input;
+    const b = buffer;
+    let acc = (seed + PRIME32_5) & 0xffffffff;
+    let offset = 0;
+    if (b.length >= 16) {
+        const accN = [
+            (seed + PRIME32_1 + PRIME32_2) & 0xffffffff,
+            (seed + PRIME32_2) & 0xffffffff,
+            (seed + 0) & 0xffffffff,
+            (seed - PRIME32_1) & 0xffffffff,
+        ];
+        const b = buffer;
+        const limit = b.length - 16;
+        let lane = 0;
+        for (offset = 0; (offset & 0xfffffff0) <= limit; offset += 4) {
+            const i = offset;
+            const laneN0 = b[i + 0] + (b[i + 1] << 8);
+            const laneN1 = b[i + 2] + (b[i + 3] << 8);
+            const laneNP = laneN0 * PRIME32_2 + ((laneN1 * PRIME32_2) << 16);
+            let acc = (accN[lane] + laneNP) & 0xffffffff;
+            acc = (acc << 13) | (acc >>> 19);
+            const acc0 = acc & 0xffff;
+            const acc1 = acc >>> 16;
+            accN[lane] = (acc0 * PRIME32_1 + ((acc1 * PRIME32_1) << 16)) & 0xffffffff;
+            lane = (lane + 1) & 0x3;
+        }
+        acc =
+            (((accN[0] << 1) | (accN[0] >>> 31)) +
+                ((accN[1] << 7) | (accN[1] >>> 25)) +
+                ((accN[2] << 12) | (accN[2] >>> 20)) +
+                ((accN[3] << 18) | (accN[3] >>> 14))) &
+                0xffffffff;
+    }
+    acc = (acc + buffer.length) & 0xffffffff;
+    const limit = buffer.length - 4;
+    for (; offset <= limit; offset += 4) {
+        const i = offset;
+        const laneN0 = b[i + 0] + (b[i + 1] << 8);
+        const laneN1 = b[i + 2] + (b[i + 3] << 8);
+        const laneP = laneN0 * PRIME32_3 + ((laneN1 * PRIME32_3) << 16);
+        acc = (acc + laneP) & 0xffffffff;
+        acc = (acc << 17) | (acc >>> 15);
+        acc = ((acc & 0xffff) * PRIME32_4 + (((acc >>> 16) * PRIME32_4) << 16)) & 0xffffffff;
+    }
+    for (; offset < b.length; ++offset) {
+        const lane = b[offset];
+        acc = acc + lane * PRIME32_5;
+        acc = (acc << 11) | (acc >>> 21);
+        acc = ((acc & 0xffff) * PRIME32_1 + (((acc >>> 16) * PRIME32_1) << 16)) & 0xffffffff;
+    }
+    acc = acc ^ (acc >>> 15);
+    acc = (((acc & 0xffff) * PRIME32_2) & 0xffffffff) + (((acc >>> 16) * PRIME32_2) << 16);
+    acc = acc ^ (acc >>> 13);
+    acc = (((acc & 0xffff) * PRIME32_3) & 0xffffffff) + (((acc >>> 16) * PRIME32_3) << 16);
+    acc = acc ^ (acc >>> 16);
+    return acc < 0 ? acc + 4294967296 : acc;
+}

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "hive-p2p",
+  "version": "1.0.0",
+  "description": "P2P networking library for browser and Node.js with WebRTC",
+  "type": "module",
+  "main": "./index.mjs",
+  "browser": "./browser.mjs",
+  "exports": {
+    ".": {
+      "browser": "./browser.mjs", 
+      "node": "./index.mjs",
+      "default": "./index.mjs"
+    }
+  },
+  "files": [
+    "core/",
+    "libs/",
+    "services/",
+    "index.mjs",
+    "browser.mjs"
+  ],
+  "dependencies": {
+    "@noble/ed25519": "3.0.0",
+    "@noble/hashes": "2.0.0", 
+    "argon2": "~0.44.0",
+    "express": "~5.1.0",
+    "node-pre-gyp": "~0.17.0",
+    "simple-peer": "~9.11.1",
+    "socket.io-client": "~4.8.1",
+    "socket.io": "~4.8.1",
+    "wrtc": "~0.4.7",
+    "ws": "~8.18.3"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Seigneur-Machiavel/hive-p2p.git"
+  },
+  "keywords": ["p2p", "webrtc", "networking", "browser", "nodejs", "gossip", "mesh"],
+  "author": "Seigneur-Machiavel",
+  "license": "MIT",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  }
+}

package/services/clock.mjs

@@ -0,0 +1,144 @@
+/**
+ * Synchronized Network Clock
+ * Simple, efficient NTP-based time synchronization
+ */
+
+export class Clock {
+	verbose;
+	mockMode; // if true, use local time without sync
+	static #instance = null;
+
+	#offset = null; // ms difference from local time
+	#syncing = false;
+	#lastSync = 0;
+	#sources = ['time.google.com', 'time.cloudflare.com', 'pool.ntp.org'];
+
+	constructor(verbose = 0, mockMode = false) {
+		this.verbose = verbose;
+		this.mockMode = mockMode;
+		if (Clock.#instance) return Clock.#instance;
+		else Clock.#instance = this;
+	}
+	
+	// PUBLIC API
+	static get instance() { return Clock.#instance || new Clock(); }
+	static get time() { return Clock.instance.time; } // Sync API - returns current synchronized time or null
+	get time() { 
+		if (this.mockMode) return Date.now();
+		if (this.#offset === null) return null; 
+		return Date.now() + Math.round(this.#offset); 
+	}
+	async sync(verbose) { // Force synchronization - returns promise with synchronized time
+		if (verbose !== undefined) this.verbose = verbose;
+		if (this.mockMode) return Date.now(); // Bypass sync in mock mode
+
+		if (this.#syncing) { // Wait for current sync to complete
+			while (this.#syncing) await new Promise(resolve => setTimeout(resolve, 50));
+			return this.time;
+		}
+
+		this.#syncing = true;
+
+		try {
+			const samples = await this.#fetchTimeSamples();
+			if (samples.length === 0) {
+				console.warn('[Clock] All NTP sources failed, using local time');
+				this.#offset = 0;
+				return this.time;
+			}
+
+			this.#offset = this.#calculateOffset(samples);
+			this.#lastSync = Date.now();
+
+			// Continue refining in background if we got partial results
+			if (samples.length < this.#sources.length) setTimeout(() => this.#backgroundRefine(), 100);
+			return this.time;
+		} catch (error) {
+			console.error('[Clock] Sync failed:', error);
+			this.#offset = 0; // Fallback to local time
+			return this.time;
+		} finally { this.#syncing = false; }
+	}
+	get status() { // Get sync status info
+		if (this.mockMode) return { synchronized: true, syncing: false, offset: 0, lastSync: Date.now(), age: 0 };
+		return {
+			synchronized: this.#offset !== null,
+			syncing: this.#syncing,
+			offset: this.#offset,
+			lastSync: this.#lastSync,
+			age: this.#lastSync ? Date.now() - this.#lastSync : null
+		};
+	}
+
+	// PRIVATE METHODS
+	async #fetchTimeSamples() { // Fetch time samples from all sources in parallel
+		const promises = this.#sources.map(source => this.#fetchTimeFromSource(source));
+		const results = await Promise.allSettled(promises);
+		const samples = [];
+		for (const result of results) if (result.status === 'fulfilled') samples.push(result.value);
+		return samples;
+	}
+	/** @param {'time.google.com' | 'time.cloudflare.com' | 'pool.ntp.org'} source */
+	async #fetchTimeFromSource(source) { // Fetch time from a single NTP source
+		const controller = new AbortController();
+		const timeoutId = setTimeout(() => controller.abort(), 2000); // 2s timeout
+
+		try {
+			const startTime = Date.now();
+			const response = await fetch(`https://${source}`, { method: 'HEAD', signal: controller.signal, cache: 'no-cache' });
+			const networkLatency = (Date.now() - startTime) / 2; // Rough RTT/2
+			if (!response.ok) throw new Error(`HTTP ${response.status}`);
+
+			const serverTime = new Date(response.headers.get('date')).getTime();
+			if (isNaN(serverTime)) throw new Error('Invalid date header');
+
+			return {
+				source,
+				serverTime: serverTime + networkLatency, // Compensate for network delay
+				localTime: Date.now(),
+				latency: networkLatency * 2
+			};
+		} finally { clearTimeout(timeoutId); }
+	}
+	/** @param {Array<{serverTime: number, localTime: number, latency: number}>} samples */
+	#calculateOffset(samples) { // Calculate offset from multiple samples
+		if (samples.length === 1) return samples[0].serverTime - samples[0].localTime;
+		samples.sort((a, b) => a.latency - b.latency); // Sort by latency, prefer lower latency sources
+
+		const offsets = [];
+		for (const sample of samples) offsets.push(sample.serverTime - sample.localTime);
+		offsets.sort((a, b) => a - b); // Use median to filter outliers
+		const mid = Math.floor(offsets.length / 2);
+
+		if (offsets.length % 2 === 0) return (offsets[mid - 1] + offsets[mid]) / 2;
+		return offsets[mid];
+	}
+	async #backgroundRefine() { // Background refinement after initial sync
+		if (this.#syncing) return;
+
+		try {
+			const samples = await this.#fetchTimeSamples();
+			if (samples.length === 0) return; // All failed
+			
+			// Only update if change is significant (> 100ms)
+			const newOffset = this.#calculateOffset(samples);
+			if (Math.abs(newOffset - this.#offset) > 100) this.#offset = newOffset;
+		} catch (error) { if (this.verbose) console.warn('[Clock] Background refine failed:', error); }
+	}
+}
+
+
+export async function CLOCK_TEST() { // DEBUG TEST WHILE RUNNING AS STANDALONE
+	const startTime = Date.now();
+	const clock = new Clock();
+	clock.sync().then(() => {
+		console.log('Synchronized in: ', Date.now() - startTime, 'ms');
+		console.log('Synchronized time:', new Date(clock.time).toISOString());
+		console.log('Clock status:', clock.status);
+	}).catch(console.error);
+	
+	while (true) {
+		console.log('Clock status:', clock.status);
+		await new Promise(r => setTimeout(r, 1000));
+	}
+}

package/services/converter.mjs

@@ -0,0 +1,64 @@
+export class Converter {
+	IS_BROWSER = typeof window !== 'undefined';
+	FROMBASE64_AVAILABLE = typeof Uint8Array.fromBase64 === 'function';
+	textEncoder = new TextEncoder();
+	textDecoder = new TextDecoder();
+	buffer2 = new ArrayBuffer(2); view2 = new DataView(this.buffer2);
+	buffer4 = new ArrayBuffer(4); view4 = new DataView(this.buffer4);
+	buffer8 = new ArrayBuffer(8); view8 = new DataView(this.buffer8);
+	hexMap = { '0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9, 'A': 10, 'B': 11, 'C': 12, 'D': 13, 'E': 14, 'F': 15, 'a': 10, 'b': 11, 'c': 12, 'd': 13, 'e': 14, 'f': 15 };
+
+	// ... TO BYTES
+	/** Number should be between 0 and 65535 @param {number} num - Integer to convert to 2 bytes Uint8Array */
+	numberTo2Bytes(num) { this.view2.setUint16(0, num, true); return new Uint8Array(this.buffer2); }
+	/** Number should be between 0 and 4294967295 @param {number} num - Integer to convert to 4 bytes Uint8Array */
+	numberTo4Bytes(num) { this.view4.setUint32(0, num, true); return new Uint8Array(this.buffer4); }
+	/** Number should be between 0 and 18446744073709551615 @param {number} num - Integer to convert to 8 bytes Uint8Array */
+	numberTo8Bytes(num) { this.view8.setBigUint64(0, BigInt(num), true); return new Uint8Array(this.buffer8); }
+	stringToBytes(str = 'toto') { return this.textEncoder.encode(str); }
+	/** @param {string} hex - Hex string to convert to Uint8Array */
+    hexToBytes(hex) {
+        const length = hex.length / 2;
+        const uint8Array = new Uint8Array(length);
+        for (let i = 0, j = 0; i < length; ++i, j += 2) uint8Array[i] = (this.hexMap[hex[j]] << 4) + this.hexMap[hex[j + 1]];
+        return uint8Array;
+    }
+	/** Base64 string to convert to Uint8Array @param {string} base64 @returns {Uint8Array} */
+	base64toBytes(base64) {
+		if (!this.IS_BROWSER) return new Uint8Array(Buffer.from(base64, 'base64'));
+		if (this.FROMBASE64_AVAILABLE) return Uint8Array.fromBase64(base64);
+		const binaryString = atob(base64);
+		const bytes = new Uint8Array(binaryString.length);
+		for (let i = 0; i < binaryString.length; i++) bytes[i] = binaryString.charCodeAt(i);
+		return bytes;
+	}
+	// BYTES TO ...
+	/** @param {Uint8Array} uint8Array - Uint8Array to convert to number */
+    bytes2ToNumber(uint8Array) { for (let i = 0; i < 2; i++) this.view2.setUint8(i, uint8Array[i]); return this.view2.getUint16(0, true); }
+	/** @param {Uint8Array} uint8Array - Uint8Array to convert to number */
+	bytes4ToNumber(uint8Array) { for (let i = 0; i < 4; i++) this.view4.setUint8(i, uint8Array[i]); return this.view4.getUint32(0, true); }
+	/** @param {Uint8Array} uint8Array - Uint8Array to convert to number */
+	bytes8ToNumber(uint8Array) { for (let i = 0; i < 8; i++) this.view8.setUint8(i, uint8Array[i]); return Number(this.view8.getBigUint64(0, true)); }
+	/** @param {Uint8Array} uint8Array - Uint8Array to convert to string */
+	bytesToString(uint8Array) { return this.textDecoder.decode(uint8Array); }
+	/** @param {Uint8Array} uint8Array - Uint8Array to convert to string */
+    static bytesToHex(uint8Array, minLength = 0) {
+        let hexStr = '';
+        for (const byte of uint8Array) hexStr += byte < 16 ? `0${byte.toString(16)}` : byte.toString(16);
+        if (minLength > 0) { hexStr = hexStr.padStart(minLength, '0'); }
+        return hexStr;
+    }
+	/** @param {Uint8Array} uint8Array - Uint8Array to convert to string */
+	bytesToHex(uint8Array, minLength = 0) { return Converter.bytesToHex(uint8Array, minLength); }
+	// OTHERS
+	/** @param {string} hex - Hex string to convert to bits @param {'string' | 'arrayOfString' | 'arrayOfNumbers'} format - Output format, default: string */
+	static hexToBits(hex = 'ffffff', format = 'string') {
+		let bitsString = []; // WE USE STRING METHODS FOR PERFORMANCE (number '0' = 8 Bytes | string '0' = 1 Byte)
+		if (format === 'arrayOfNumbers') for (let i = 0; i < hex.length; i++) bitsString.push(...(parseInt(hex[i], 16).toString(2).padStart(4, '0').split('').map(b => parseInt(b, 10))));
+		else for (let i = 0; i < hex.length; i++) bitsString.push(parseInt(hex[i], 16).toString(2).padStart(4, '0'));
+		return format === 'string' ? bitsString.join('') : bitsString;
+	}
+	/** @param {Uint8Array} uint8Array - Uint8Array to convert to bits @param {'string' | 'arrayOfString' | 'arrayOfNumbers'} format - Output format, default: string */
+	static bytesToBits(uint8Array, format = 'string') { return this.hexToBits(this.bytesToHex(uint8Array), format); }
+	static ipToInt(ip = '192.168.0.1') { return ip.split('.').reduce((int, oct) => (int << 8) + parseInt(oct, 10), 0); }
+}

package/services/cryptos.mjs

@@ -0,0 +1,83 @@
+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 ? 'https://unpkg.com/@noble/ed25519@3.0.0/index.js' : '@noble/ed25519'),
+    import(IS_BROWSER ? 'https://unpkg.com/@noble/hashes@2.0.0/sha2.js' : '@noble/hashes/sha2.js')
+]);
+
+/** @type {import('@noble/ed25519')} */
+const ed25519 = ed_;
+ed25519.hashes.sha512 = sha512;
+export { ed25519 };
+//-----------------------------------------------------------------------------
+
+// ARGON2 EXPOSURE NODEJS/BROWSER COMPATIBLE ----------------------------------
+export class Argon2Unified {
+	converter = new Converter();
+	/** @type {import('argon2')} */ argon2;
+
+	/** This function hashes a password using Argon2 - Browser/NodeJS unified
+	 * @param {string} pass - Password to hash
+	 * @param {string} salt - Salt to use for the hash
+	 * @param {number} [mem] - Memory usage in KiB, default: 2**16 = 65_536 (64 MiB) | RECOMMENDED: 2**16
+	 * @param {number} [time] - Time cost in iterations, default: 1
+	 * @param {number} [parallelism] - Number of threads to use, default: 1
+	 * @param {number} [type] - 0: Argon2d, 1: Argon2i, 2: Argon2id, default: 2 (Argon2id)
+	 * @param {number} [hashLen] - Length of the hash in bytes, default: 32 */
+	hash = async (pass, salt, mem = 2**16, time = 1, parallelism = 1, type = 2, hashLen = 32) => {
+		const params = this.#createArgon2Params(pass, salt, time, mem, parallelism, type, hashLen);
+		const argon2Lib = await this.getArgon2Lib();
+		const hashResult = IS_BROWSER ? await argon2Lib.hash(params) : await argon2Lib.hash(pass, params);
+		if (!hashResult) return false;
+	
+		const encoded = hashResult.encoded || hashResult;
+		const result = this.#standardizeArgon2FromEncoded(encoded);
+		if (!result) return false;
+	
+		return result;
+	}
+	async getArgon2Lib() {
+		if (this.argon2) return this.argon2;
+
+		if (!IS_BROWSER) { try {
+			const a = await import('argon2');
+			this.argon2 = a;
+		} catch (error) { throw new Error('Please install argon2 package: npm install argon2'); } }
+		if (this.argon2) return this.argon2;
+
+		try { if (argon2) {
+			console.log('Argon2 loaded as a global variable');
+			this.argon2 = argon2;
+			return this.argon2;
+		}} catch (error) { }
+		if (this.argon2) return this.argon2;
+
+		console.log('trying import argon2 ES6 and inject in window');
+		const argon2ES6 = await import('../libs/argon2-ES6.min.mjs');
+		window.argon2 = argon2ES6.default; // EXPOSE TO GLOBAL SCOPE
+		this.argon2 = argon2ES6.default;
+		return this.argon2;
+	};
+	#createArgon2Params(pass = "averylongpassword123456", salt = "saltsaltsaltsaltsalt", time = 1, mem = 2**10, parallelism = 1, type = 2, hashLen = 32) {
+		const fixedSalt = salt.padEnd(20, '0').substring(0, 16); // 16 bytes minimum
+		return {
+			type, pass, parallelism,
+			time, timeCost: time, 			// we preserve both for compatibility
+			mem, memoryCost: mem, 			// we preserve both for compatibility
+			hashLen, hashLength: hashLen, 	// we preserve both for compatibility
+			salt: IS_BROWSER ? fixedSalt : Buffer.from(fixedSalt),
+		};
+	}
+	#standardizeArgon2FromEncoded(encoded = '$argon2id$v=19$m=1048576,t=1,p=1$c2FsdHNhbHRzYWx0c2FsdHNhbHQ$UamPN/XTTX4quPewQNw4/s3y1JJeS22cRroh5l7OTMM') {
+		const base64 = encoded.split('$').pop();
+		const hash = this.converter.base64toBytes(base64);
+		const hex = this.converter.bytesToHex(hash);
+		/** @type {string} */
+		const bitsString = Converter.hexToBits(hex, 'string');
+		if (!bitsString) return false;
+		return { encoded, hash, hex, bitsString };
+	}
+}
+//-----------------------------------------------------------------------------