hive-p2p 1.0.31 → 1.0.32

package/README.md

@@ -9,7 +9,7 @@
 - **.min (unpkg):** [unpkg.com/@hive-p2p/browser@latest/hive-p2p.min.js](https://unpkg.com/@hive-p2p/browser@1.0.19/hive-p2p.min.js)
 - **.min (cdn):** [cdn.jsdelivr.net/npm/@hive-p2p/browser@latest/hive-p2p.min.js](https://cdn.jsdelivr.net/npm/@hive-p2p/browser@latest/hive-p2p.min.js)
 - **Stats:** [ghloc.vercel.app/Seigneur-Machiavel/hive-p2p](https://ghloc.vercel.app/Seigneur-Machiavel/hive-p2p?branch=main)
-- **DEMO-REPO :** [github.com/Seigneur-Machiavel/hive-p2p-demo](https://github.com/Seigneur-Machiavel/hive-p2p-demo)
+- **demos-repo :** [github.com/Seigneur-Machiavel/hive-p2p-demo](https://github.com/Seigneur-Machiavel/hive-p2p-demo)
 
 ## What is HiveP2P?
 
@@ -45,27 +45,31 @@ npm install @hive-p2p/browser
 ### Basic Usage
 
 ```javascript
-import { Node } from 'hive-p2p';
+import HiveP2P from "hive-p2p"; // using full lib (server + client)
 
-// Create a node
-const node = new Node();
+// Create a public node
+const publicNode = await HiveP2P.createPublicNode({ domain: 'localhost', port: 12345 });
 
-// Start with bootstrap nodes
-await node.start([
-  { id: '0abc...', publicUrl: 'ws://seed1.example.com:8080' },
-  { id: '0def...', publicUrl: 'ws://seed2.example.com:8080' }
-]);
+// Use public node as bootstrap by extracting its url
+const bootstraps = [publicNode.publicUrl];
 
-// Send messages
-node.on('message', (senderId, data) => {
-  console.log(`Message from ${senderId}:`, data);
-});
+// Create nodes with bootstrap node
+const bee1 = await HiveP2P.createNode({ bootstraps });
+const bee2 = await HiveP2P.createNode({ bootstraps });
+
+// Listen for unicast messages (target id)
+for (const node of [publicNode, bee1, bee2])
+	node.onMessageData((fromId, message) => console.log(`[${node.id}] from [${fromId}]: ${message}`));
 
-// Broadcast to network
-node.gossip.broadcastToAll({ type: 'announcement', value: 'Hello Hive!' });
+// Listen for gossip messages (broadcast to all)
+for (const node of [publicNode, bee1, bee2])
+	node.onGossipData((fromId, message) => console.log(`[${node.id}]: from [${fromId}]: ${message}`));
 
-// Direct message
-node.messager.sendUnicast(targetId, { type: 'private', content: 'Direct message' });
+while (true) {
+	bee1.sendMessage(bee2.id, `Hello bee2!`); 			// Send direct unicast message
+	bee2.broadcast("Hello everyone! I'm bee bee2"); 	// Broadcast message to all
+	await new Promise((resolve) => setTimeout(resolve, 1_000));
+}
 ```
 
 ## How It Works
@@ -110,23 +114,12 @@ Real simulation results with 2000 nodes:
 ┌──────────────────────────────────────────────────────────┐
 │ 10 minutes (600s)                                        │
 ├──────────────────────────────────────────────────────────┤
-│ Active nodes:    2002/2002 (1902 established)           │
+│ Active nodes:    2002/2002 (1902 established)            │
 │ Avg neighbors:   4.7                                     │
 │ Network coverage: 100% (T: 10571)                        │
 │ Avg latency:     169ms                                   │
-│ Gossip rate:     0.4 msg/s                              │
-│ Bandwidth:       856 bytes/s                            │
-└──────────────────────────────────────────────────────────┘
-
-┌──────────────────────────────────────────────────────────┐
-│ 1 hour (602s - continued sim)                           │
-├──────────────────────────────────────────────────────────┤
-│ Active nodes:    2003/2003 (1903 established)           │
-│ Avg neighbors:   4.8                                     │
-│ Network coverage: 100% (T: 8225)                        │
-│ Avg latency:     223ms                                   │
-│ Gossip rate:     0.2 msg/s                              │
-│ Bandwidth:       396 bytes/s                            │
+│ Gossip rate:     0.4 msg/s                               │
+│ Bandwidth:       856 bytes/s                             │
 └──────────────────────────────────────────────────────────┘
 ```
 
@@ -284,10 +277,6 @@ Check our [contribution guide](CONTRIBUTING.md) to get started.
 
 HiveP2P embodies this principle - simple components (gossip, routing, topology awareness) combine to create a complex, self-organizing system that surpasses traditional approaches.
 
-## License
-
-GNU General Public License v3.0 - See [LICENSE](LICENSE) for details.
-
 ---
 
 *HiveP2P - Because the internet deserves better than client-server*
@@ -571,10 +560,6 @@ Consultez notre [guide de contribution](CONTRIBUTING.md) pour commencer.
 
 HiveP2P incarne ce principe - des composants simples (gossip, routage, conscience topologique) se combinent pour créer un système complexe et auto-organisant qui surpasse les approches traditionnelles.
 
-## Licence
-
-GNU General Public License v3.0 - Voir [LICENSE](LICENSE) pour les détails.
-
 ---
 
 *HiveP2P - Parce qu'Internet mérite mieux que client-serveur*

package/core/node-services.mjs

@@ -121,11 +121,13 @@ export class NodeServices {
 	static deriveSTUNServers(bootstraps) {
 		/** @type {Array<{urls: string}>} */
 		const stunUrls = [];
-		for (const b of bootstraps) { // {urls: 'stun:42312:NaN'}
+		for (const b of bootstraps) {
 			if (!b.includes(':')) continue;
-			const url = b.replace('/ws', '/signal'); // in case someone put domain/ws
-			url.replace('/wss', '/signal'); // in case someone put domain/wss
-			url.replace('ws://', 'stun:');
+			if (b.endsWith('/ws') || b.endsWith('/wss')) continue; // ugly hardcode
+			// useless ? => proxy can't serve as stun server
+			//const url = b.replace('/ws', '/signal'); // in case someone put domain/ws
+			//url.replace('/wss', '/signal'); // in case someone put domain/wss
+			const url = b.replace('ws://', 'stun:');
 			url.replace('wss://', 'stun:');
 			if (!url.includes('stun:')) continue;
 			stunUrls.push({ urls: url });

package/core/node.mjs

@@ -17,12 +17,13 @@ import { NodeServices } from './node-services.mjs';
  * @param {number} [options.port] If provided, the node will listen on this port (default: SERVICE.PORT)
  * @param {number} [options.verbose] Verbosity level for logging (default: NODE.DEFAULT_VERBOSE) */
 export async function createPublicNode(options) {
-	await CLOCK.sync(this.verbose);
 	const verbose = options.verbose !== undefined ? options.verbose : NODE.DEFAULT_VERBOSE;
 	const domain = options.domain || undefined;
 	const codex = options.cryptoCodex || new CryptoCodex(undefined, verbose);
+	const clockSync = CLOCK.sync(verbose);
 	if (!codex.publicKey) await codex.generate(domain ? true : false);
 	
+	await clockSync;
 	const node = new Node(codex, options.bootstraps || [], verbose);
 	if (domain) {
 		node.services = new NodeServices(codex, node.peerStore, undefined, verbose);
@@ -42,8 +43,10 @@ export async function createPublicNode(options) {
 export async function createNode(options = {}) {
 	const verbose = options.verbose !== undefined ? options.verbose : NODE.DEFAULT_VERBOSE;
 	const codex = options.cryptoCodex || new CryptoCodex(undefined, verbose);
+	const clockSync = CLOCK.sync(verbose);
 	if (!codex.publicKey) await codex.generate(false);
 
+	await clockSync;
 	const node = new Node(codex, options.bootstraps || [], verbose);
 	if (options.autoStart !== false) await node.start();
 	return node;
@@ -145,10 +148,13 @@ export class Node {
 		await CLOCK.sync(this.verbose);
 		this.started = true;
 		if (SIMULATION.AVOID_INTERVALS) return true; // SIMULATOR CASE
-		this.topologist.tryConnectNextBootstrap(); // first shot ASAP
+
 		this.arbiterInterval = setInterval(() => this.arbiter.tick(), 1000);
-		this.enhancerInterval = setInterval(() => this.topologist.tick(), DISCOVERY.LOOP_DELAY);
 		this.peerStoreInterval = setInterval(() => { this.peerStore.cleanupExpired(); this.peerStore.offerManager.tick(); }, 2500);
+		if (this.publicUrl) return true;
+		
+		this.enhancerInterval = setInterval(() => this.topologist.tick(), DISCOVERY.LOOP_DELAY);
+		this.topologist.tryConnectNextBootstrap(); // first shot ASAP
 		return true;
 	}
 	/** Broadcast a message to all connected peers or to a specified peer

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hive-p2p",
-  "version": "1.0.31",
+  "version": "1.0.32",
   "publishConfig": {
     "access": "public"
   },

package/simulation/simulator.mjs

@@ -1,5 +1,7 @@
 import path from 'path';
+import { join } from 'path';
 import express from 'express';
+import { readFileSync } from 'fs';
 import { fileURLToPath } from 'url';
 import { WebSocketServer } from 'ws';
 import { io } from 'socket.io-client'; // used for twitch events only
@@ -229,13 +231,19 @@ if (SIMULATION.RANDOM_UNICAST_PER_SEC) randomMessagesLoop('U', SIMULATION.RANDOM
 if (SIMULATION.RANDOM_GOSSIP_PER_SEC) randomMessagesLoop('G', SIMULATION.RANDOM_GOSSIP_PER_SEC);
 
 const app = express(); // simple server to serve texts/p2p_simulator.html
-app.use('../rendering/visualizer.mjs', (req, res, next) => {
-    res.set({ 'Cache-Control': 'no-cache, no-store, must-revalidate', 'Pragma': 'no-cache', 'Expires': '0' });
-    next();
+const server = app.listen(3000, () => console.log('%cServer listening on http://localhost:3000', LOG_CSS.SIMULATOR));
+app.get('/core/config.mjs', (req, res) => { // CONFIG PATCH FOR SIMULATOR
+    const configPath = join(packageRoot, 'core/config.mjs');
+    let content = readFileSync(configPath, 'utf8');
+    content = content // Patch the values
+	.replace(/ARE_IDS_HEX:\s*true/g, 'ARE_IDS_HEX: false')
+	.replace(/PUBLIC_PREFIX:\s*'0'/g, "PUBLIC_PREFIX: 'P_'")
+	.replace(/STANDARD_PREFIX:\s*'1'/g, "STANDARD_PREFIX: 'N_'");
+    
+    res.set({ 'Content-Type': 'application/javascript', 'Cache-Control': 'no-cache, no-store, must-revalidate'});
+    res.send(content);
 });
-
 app.use(express.static(packageRoot));
-const server = app.listen(3000, () => console.log('%cServer listening on http://localhost:3000', LOG_CSS.SIMULATOR));
 app.get('/', (req, res) => res.sendFile('rendering/visualizer.html', { root: packageRoot }));
 app.get('/the-gossip-grail', (req, res) => res.sendFile('resources/the-gossip-grail.html', { root: packageRoot }));
 
@@ -316,7 +324,7 @@ class TwitchChatCommandInterpreter {
 			.replace(/[^\w-]/g, '_')             // remplacer chars spéciaux par _
 
 		const cryptoCodex = IDENTITY.ARE_IDS_HEX ? new CryptoCodex() : new CryptoCodex(`F_${cleanUser}`);
-		const peer = await createPublicNode({ bootstraps: pickUpRandomBootstraps(), cryptoCodex, domain: 'localhost', port: 9000 + Object.keys(this.userNodes).length * 2, verbose: 2 });
+		const peer = await createNode({ bootstraps: pickUpRandomBootstraps(), cryptoCodex, verbose: 2 });
 		this.userNodes[user] = peer;
 		peers.all[peer.id] = peer;
 		peers.standard.unshift(peer);