hive-p2p 1.0.7 → 1.0.9

package/core/arbiter.mjs

@@ -1,4 +1,4 @@
-import { CLOCK, NODE, GOSSIP, UNICAST, LOG_CSS } from './parameters.mjs';
+import { CLOCK, NODE, GOSSIP, UNICAST, LOG_CSS } from './config.mjs';
 
 // TRUST_BALANCE = seconds of ban if negative - never exceed MAX_TRUST if positive
 // Growing each second by 1000ms until 0

package/core/config.mjs

@@ -0,0 +1,227 @@
+const isNode = (typeof window === 'undefined');
+if (!isNode && window.SimplePeer === undefined)
+	throw new Error('SimplePeer is not available in the browser, make sure to include it via a script tag or a bundler.');
+import { Clock } from '../services/clock.mjs';
+
+// HOLD: GLOBAL CONFIG FOR THE LIBRARY
+// AVOID: CIRCULAR DEPENDENCIES AND TOO MANY FUNCTION/CONSTRUCTOR CONFIG
+// SIMPLIFY: IMPORTS, SIMULATOR AND BROWSER SUPPORT
+
+/** Synchronized clock that can be used outside the library */
+export const CLOCK = Clock.instance;
+
+export const SIMULATION = {
+	/** Specify setInterval() avoidance for faster simulation (true = avoid intervals) | Default: true */
+	AVOID_INTERVALS: false,
+	/** Use test transports (WebSocket server and SimplePeer replacement) | Default: false */
+	USE_TEST_TRANSPORTS: false,
+	/** Ice candidates delay simulation | Default: { min: 250, max: 3000 } */
+	ICE_DELAY: { min: 250, max: 3000 },
+	/** ICE offer failure rate simulation (0 to 1) | Default: .2 (20%) */
+	ICE_OFFER_FAILURE_RATE: .2,
+	/** ICE answer failure rate simulation (0 to 1) | Default: .15 (15%) */
+	ICE_ANSWER_FAILURE_RATE: .15,
+	// -------------------------------------------------|
+	/** Avoid creating follower nodes | Default: false */
+	AVOID_FOLLOWERS_NODES: false,
+	/** Auto start the simulation when creating the first node | Default: true */
+	AUTO_START: true,				// auto start the simulation, false to wait the frontend | Default: true
+	/** Number of public nodes to create in the simulation
+	 * - Default: 100
+	 * - min: 1, medium: 3, strong: 20, hardcore: 100 */
+	PUBLIC_PEERS_COUNT: 100,
+	/** Number of standard nodes to create in the simulation
+	 * - Default: 1860
+	 * - stable: 12, medium: 250, strong: 2000, hardcore: 5000 */
+	PEERS_COUNT: 1860,
+	/** Number of bootstrap(public) nodes to provide as bootstrap to each peer on creation | Default: 10, null = all of them */
+	BOOTSTRAPS_PER_PEER: 10,
+	/** Delay between each peer.start() in milliseconds
+	 * - Default: 60 (60sec to start 1000 peers)
+	 * - 0 = faster for simulating big networks but > 0 = should be more realistic */
+	DELAY_BETWEEN_INIT: 10,
+	/** Random unicast(direct) messages to send per second | Default: 0, max: 1 (per peer) */
+	RANDOM_UNICAST_PER_SEC: 0,
+	/** Random gossip(to all) messages to send per second | Default: 0, max: 1 (per peer) */
+	RANDOM_GOSSIP_PER_SEC: 0,
+	/** Delay between each diffusion test in milliseconds | Default: 10_000 (10 seconds) */
+	DIFFUSION_TEST_DELAY: 10_000,
+}
+
+export const NODE = {
+	/** 0: none, 1: errors, 2: +important info, 3: +debug, 4: +everything | Can be bypass by some constructors */
+	DEFAULT_VERBOSE: 1,
+	/** Timeout for upgrading a "connecting" peer to "connected" | Default: 15_000 (15 seconds) */
+	CONNECTION_UPGRADE_TIMEOUT: 15_000,
+	/** Flag to indicate if we are running in a browser environment | DON'T MODIFY THIS VALUE */
+	IS_BROWSER: isNode ? false : true,
+}
+
+export const SERVICE = {
+	/** If the node is a public node (domain provided), it will start a WebSocket server on this port | Default: 8080 */
+	PORT: 8080,
+	/** The public node kicking basis delay | Default: 60_000 (1 minute) */
+	AUTO_KICK_DELAY: 60_000,
+	/** The public node kicking duration | Default: 30_000 (30 seconds) */
+	AUTO_KICK_DURATION: 30_000,
+	/** The public node will limit the maximum incoming connections to this value | Default: 20 */
+	MAX_WS_IN_CONNS: 20,
+}
+
+export const IDENTITY = {
+	/** Difficulty level for anti-sybil measures, based on Argon2id Proof-of-Work
+	 * - Follow a logarithmic scale (2^x)
+	 * - Default: 0 (disabled)
+	 * - RECOMMENDED: 7 (medium security, reasonable CPU usage)
+	 * - HIGH SECURITY: 10 (high security, significant CPU usage)
+	 * - Note: This setting is applied only if ARE_IDS_HEX = TRUE */
+	DIFFICULTY: 0,
+	/** Memory usage in KiB for Argon2
+	 * - Follow a logarithmic scale (2^x)
+	 * - Default: 2**16 = 65_536 (64 MiB)
+	 * - RECOMMENDED: 2**17 = 131_072 (128 MiB)
+	 * - HIGH SECURITY: 2**18 = 262_144 (256 MiB)
+	 * - VERY HIGH SECURITY: 2**19 = 524_288 (512 MiB)
+	 * - Note: This setting is applied only if ARE_IDS_HEX = TRUE */
+	ARGON2_MEM: 2**16,
+	/** Boolean to indicate if we use hex ids, Default: true = hex | false = strings as Bytes (can involve in serialization failures) */
+	ARE_IDS_HEX: true,
+	/** Identifier prefix for public nodes | Default: '0' */
+	PUBLIC_PREFIX: '0',
+	/** Identifier prefix for standard nodes | Default: '1' */
+	STANDARD_PREFIX: '1',
+	/** !!EVEN NUMBER ONLY!! length of peer id | Default: 16 */
+	ID_LENGTH: 16,
+	PUBKEY_LENGTH: 32,
+	PRIVATEKEY_LENGTH: 32,
+	SIGNATURE_LENGTH: 64,
+}
+
+export const TRANSPORTS = {
+	/** Maximum SDP offers to create in advance to be ready for new connections | Default: 2 */
+	MAX_SDP_OFFERS: 2,
+	/** Time to wait for ICE gathering to complete | Default: 1_000 (1 second) */
+	ICE_COMPLETE_TIMEOUT: 1_000,
+	/** Time to wait for signal before destroying WTRC connection | Default: 8_000 (8 seconds) */
+	SIGNAL_CREATION_TIMEOUT: 8_000,
+	/** Time to consider an SDP offer as valid | Default: 40_000 (40 seconds) */
+	SDP_OFFER_EXPIRATION: 40_000, 
+	
+	WS_CLIENT: WebSocket,
+	WS_SERVER: isNode ? (await import('ws')).WebSocketServer : null,
+	PEER: isNode ? (await import('simple-peer')).default : SimplePeer
+}
+
+export const DISCOVERY = {
+	/** Delay between two peer declaring their connection to each other | Default: 10_000 (10 seconds) */
+	PEER_LINK_DELAY: 10_000,
+	/** Time to consider a peer connection as valid | Default: 60_000 (60 seconds) */
+	PEER_LINK_EXPIRATION: 60_000,
+	/** Delay between two discovery loops | Default: 2_500 (2.5 seconds) */
+	LOOP_DELAY: 2_500,
+	/** Target number of neighbors to maintain, higher values improve connectivity/resilience but increase resource usage
+	 * - Default: 5
+	 * - Light: 4, Medium: 5, Strong: 8, Hardcore: 12 */
+	TARGET_NEIGHBORS_COUNT: 5,
+
+	ON_CONNECT_DISPATCH: {		// => on Node.#onConnect() // DEPRECATING
+		DELAY: 0, 					// delay before dispatching events | Default: 100 (.1 seconds)
+		BROADCAST_EVENT: false,		// Boolean to indicate if we broadcast 'peer_connected'
+		OVER_NEIGHBORED: true,		// Boolean to indicate if we broadcast 'over_neighbored' event when we are over neighbored | Default: true
+		SHARE_HISTORY: false,		// Boolean to indicate if we broadcastToPeer some gossip history to the new peer | Default: true
+	},
+	ON_DISCONNECT_DISPATCH: {	// => on Node.#onDisconnect() // DEPRECATING
+		DELAY: 0, 					// delay before dispatching the 'disconnected' event | Default: 500 (.5 seconds)
+		BROADCAST_EVENT: false,		// Boolean to indicate if we broadcast 'peer_disconnected'
+	},
+	ON_UNICAST: {				// => UnicastMessager.handleDirectMessage()
+		DIGEST_TRAVELED_ROUTE: true, // Boolean to indicate if we digest the traveled route for each unicast message | Default: true
+	}
+}
+
+export const UNICAST = { // MARKERS RANGE: 0-127
+	/** Maximum number of hops(relaying) for direct message | Default: 8
+	 * - Default: 8, light: 6, super-light: 4, direct-only: 2 */
+	MAX_HOPS: 8,
+	/** Maximum number of nodes to consider during BFS
+	 * - Default: 1728 (12³), light: 512 (8³), super-light: 144 (8²) */
+	MAX_NODES: 256,
+	/** Maximum number of routes to consider during BFS
+	 * - Default: 5, light: 3, super-light: 1 */
+	MAX_ROUTES: 5,
+	/** First byte markers for unicast messages | RANGE: 0-127 */
+	MARKERS_BYTES: {
+		message: 0,
+		'0': 'message',
+		handshake: 1,
+		'1': 'handshake',
+		signal_answer: 2,
+		'2': 'signal_answer',
+		signal_offer: 3,
+		'3': 'signal_offer',
+	},
+}
+
+export const GOSSIP = { // MARKERS RANGE: 128-255
+	/** Time to consider a message as valid | Default: 10_000 (10 seconds) */
+	EXPIRATION: 10_000,
+	/** Time to keep messages in cache to avoid reprocessing | Default: 20_000 (20 seconds) */
+	CACHE_DURATION: 20_000,
+	/** Maximum number of hops for gossip messages | Default: 20 
+	 * - Here you can set different max hops for different message types */
+	HOPS: {
+		default: 20, 		// 16 should be the maximum
+		signal_offer: 6, 	// works with 3 ?
+		diffusion_test: 100, // must be high to reach all peers
+		over_neighbored: 6,
+		// peer_connected: 3,
+		// peer_disconnected: 3,
+	},
+	/** Ponderation to lower the transmission rate based on neighbors count
+	 * - Lowering the transmission rate based on neighbors count, but involve a lower gossip diffusion
+	 * - As well you can apply different ponderation factors for different message types */
+	TRANSMISSION_RATE: {
+		/** Minimum neighbors to apply ponderation, Default: 2
+		 * - Decrease to apply ponderation sooner */
+		MIN_NEIGHBOURS_TO_APPLY_PONDERATION: 2,
+		/** Ponderation factor based on neighbors count, Default: 5
+		 * - Decrease to lower transmission rate based on neighbors count */
+		NEIGHBOURS_PONDERATION: 5,
+
+		Default: 1, 				// 1 === 100%
+		signal_offer: .618, 		// .618 === 61.8%
+		// peer_connected: .5, 		// we can reduce this, but lowering the map quality
+		// peer_disconnected: .618
+	},
+	/** First byte markers for gossip messages | RANGE: 128-255 */
+	MARKERS_BYTES: {
+		gossip: 128,
+		'128': 'gossip',
+		signal_offer: 129,
+		'129': 'signal_offer',
+		peer_connected: 130,
+		'130': 'peer_connected',
+		peer_disconnected: 131,
+		'131': 'peer_disconnected',
+		diffusion_test: 132,
+		'132': 'diffusion_test',
+		over_neighbored: 133,
+		'133': 'over_neighbored',
+	},
+}
+
+/** CSS styles for console logging */
+export const LOG_CSS = {
+	SIMULATOR: 'color: yellow; font-weight: bold;',
+	ARBITER: 'color: white;',
+	CRYPTO_CODEX: 'color: green;',
+	GOSSIP: 'color: fuchsia;',
+	UNICAST: 'color: cyan;',
+	PEER_STORE: 'color: orange;',
+	SERVICE: 'color: teal;',
+	PUNISHER: { BAN: 'color: red; font-weight: bold;', KICK: 'color: darkorange; font-weight: bold;' },
+}
+
+export default {
+	CLOCK, SIMULATION, NODE, TRANSPORTS, DISCOVERY, IDENTITY, UNICAST, GOSSIP, LOG_CSS
+};

package/core/crypto-codex.mjs

@@ -1,4 +1,4 @@
-import { CLOCK, SIMULATION, NODE, IDENTITY, GOSSIP, UNICAST, LOG_CSS } from './parameters.mjs';
+import { CLOCK, SIMULATION, NODE, IDENTITY, GOSSIP, UNICAST, LOG_CSS } from './config.mjs';
 import { GossipMessage } from './gossip.mjs';
 import { DirectMessage, ReroutedDirectMessage } from './unicast.mjs';
 import { Converter } from '../services/converter.mjs';
@@ -14,7 +14,8 @@ export class CryptoCodex {
     /** @type {Uint8Array} */ privateKey;
 
 	/** @param {string} [nodeId] If provided: used to generate a fake keypair > disable crypto operations */
-	constructor(nodeId) {
+	constructor(nodeId, verbose = NODE.DEFAULT_VERBOSE) {
+		this.verbose = verbose;
 		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);
@@ -23,6 +24,13 @@ export class CryptoCodex {
 		for (let i = 0; i < IDENTITY.ID_LENGTH; i++) this.publicKey[i] = idBytes[i];
 	}
 
+	/** @param {boolean} asPublicNode Default: false @param {Uint8Array} seed PrivateKey *-optional* */
+	static async createCryptoCodex(asPublicNode, seed) {
+		const cryptoCodex = new CryptoCodex(undefined, this.verbose);
+		await cryptoCodex.generate(asPublicNode, seed);
+		return cryptoCodex;
+	}
+
 	// IDENTITY
 	/** @param {string} id Check the first character against the PUBLIC_PREFIX */
 	static isPublicNode(id) { return (IDENTITY.ARE_IDS_HEX ? Converter.hexToBits(id[0]) : id).startsWith(IDENTITY.PUBLIC_PREFIX); }

package/core/gossip.mjs

@@ -1,4 +1,4 @@
-import { CLOCK, GOSSIP, DISCOVERY } from './parameters.mjs';
+import { CLOCK, GOSSIP, DISCOVERY } from './config.mjs';
 import { xxHash32 } from '../libs/xxhash32.mjs';
 
 export class GossipMessage { // TYPE DEFINITION

package/core/ice-offer-manager.mjs

@@ -1,6 +1,10 @@
-import { CLOCK, NODE, TRANSPORTS, LOG_CSS } from './parameters.mjs';
+import { CLOCK, NODE, TRANSPORTS, LOG_CSS } from './config.mjs';
 import { xxHash32 } from '../libs/xxhash32.mjs';
-import wrtc from 'wrtc';
+async function getWrtc() {
+    if (typeof globalThis.RTCPeerConnection !== 'undefined') return undefined;
+    return (await import('wrtc')).default;
+}
+const wrtc = await getWrtc();
 
 /** - 'OfferObj' Definition
  * @typedef {Object} OfferObj
@@ -84,7 +88,8 @@ export class OfferManager { // Manages the creation of SDP offers and handling o
 		this.offerInstanceByExpiration[expiration] = instance;
 	};
 	#createOffererInstance(expiration) {
-		const instance = new TRANSPORTS.PEER({ initiator: true, trickle: false, wrtc, config: { iceServers: this.stunUrls } });
+		const iceCompleteTimeout = TRANSPORTS.ICE_COMPLETE_TIMEOUT || 1_000;
+		const instance = new TRANSPORTS.PEER({ initiator: true, trickle: false, iceCompleteTimeout, wrtc, config: { iceServers: this.stunUrls } });
 		instance.on('error', error => this.#onError(error));
 		instance.on('signal', data => { // trickle: false => only one signal event with the full offer
 			const { candidate, type } = data; // with trickle, we need to adapt the approach.
@@ -158,7 +163,8 @@ export class OfferManager { // Manages the creation of SDP offers and handling o
 			}
 			
 			// type === 'offer' => CREATE ANSWERER INSTANCE
-			const instance = new TRANSPORTS.PEER({ initiator: false, trickle: false, wrtc, config: { iceServers: this.stunUrls } });
+			const iceCompleteTimeout = TRANSPORTS.ICE_COMPLETE_TIMEOUT || 1_000;
+			const instance = new TRANSPORTS.PEER({ initiator: false, trickle: false, iceCompleteTimeout, wrtc, config: { iceServers: this.stunUrls } });
 			instance.on('error', (error) => this.#onError(error));
 			instance.on('signal', (data) => this.onSignalAnswer(remoteId, data, offerHash));
 			instance.on('connect', () => this.onConnect(remoteId, instance));

package/core/node-services.mjs

@@ -1,7 +1,10 @@
-import { NODE, SIMULATION, TRANSPORTS, DISCOVERY } from './parameters.mjs';
+import { SIMULATION, NODE, SERVICE, TRANSPORTS, DISCOVERY, LOG_CSS } from './config.mjs';
 import { PeerConnection } from './peer-store.mjs';
 import { Converter } from '../services/converter.mjs';
-const dgram = !NODE.IS_BROWSER ? await import('dgram') : null; // Node.js only
+const dgram = !NODE.IS_BROWSER ? await import('dgram') : null;
+/*const dgram = !NODE.IS_BROWSER ? 
+  await import('dgram').catch(() => null) : 
+  null;*/
 
 export class NodeServices {
 	id;
@@ -20,7 +23,7 @@ export class NodeServices {
 		this.cryptoCodex = cryptoCodex;
 	}
 	
-	start(domain = 'localhost', port = NODE.SERVICE.PORT) {
+	start(domain = 'localhost', port = SERVICE.PORT) {
 		this.publicUrl = `ws://${domain}:${port}`;
 		this.#startWebSocketServer(domain, port);
 		if (!SIMULATION.USE_TEST_TRANSPORTS) this.#startSTUNServer(domain, port + 1);
@@ -30,22 +33,22 @@ export class NodeServices {
 		if (maxKick <= 0) return; // nothing to do
 		
 		let kicked = 0;
-		const delay = NODE.SERVICE.AUTO_KICK_DELAY;
+		const delay = SERVICE.AUTO_KICK_DELAY;
 		for (const peerId  in this.peerStore.connected) {
 			const conn = this.peerStore.connected[peerId];
 			const nonPublicNeighborsCount = this.peerStore.getUpdatedPeerConnectionsCount(peerId, false);
 			if (nonPublicNeighborsCount > DISCOVERY.TARGET_NEIGHBORS_COUNT) { // OVER CONNECTED
-				this.peerStore.kickPeer(peerId, NODE.SERVICE.AUTO_KICK_DURATION, 'freePublicNode');
+				this.peerStore.kickPeer(peerId, SERVICE.AUTO_KICK_DURATION, 'freePublicNode');
 				if (this.peerStore.neighborsList.length <= DISCOVERY.TARGET_NEIGHBORS_COUNT) break;
 				else continue; // Don't count in maxKick
 			}
 
 			if (conn.getConnectionDuration() < (nonPublicNeighborsCount > 2 ? delay : delay * 2)) continue;
-			this.peerStore.kickPeer(peerId, NODE.SERVICE.AUTO_KICK_DURATION, 'freePublicNode');
+			this.peerStore.kickPeer(peerId, SERVICE.AUTO_KICK_DURATION, 'freePublicNode');
 			if (++kicked >= maxKick) break;
 		}
 	}
-	#startWebSocketServer(domain = 'localhost', port = NODE.SERVICE.PORT) {
+	#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) => {
@@ -70,10 +73,10 @@ export class NodeServices {
 			});
 		});
 	}
-	#startSTUNServer(host = 'localhost', port = NODE.SERVICE.PORT + 1) {
+	#startSTUNServer(host = 'localhost', port = SERVICE.PORT + 1) {
 		this.stunServer = dgram.createSocket('udp4');
 		this.stunServer.on('message', (msg, rinfo) => {
-			if (this.verbose > 1) console.log(`%cSTUN message from ${rinfo.address}:${rinfo.port} - ${msg.toString('hex')}`, 'color: blue;');
+			if (this.verbose > 2) console.log(`%cSTUN message from ${rinfo.address}:${rinfo.port} - ${msg.toString('hex')}`, LOG_CSS.SERVICE);
 			if (!this.#isValidSTUNRequest(msg)) return;
 			this.stunServer.send(this.#buildSTUNResponse(msg, rinfo), rinfo.port, rinfo.address);
 		});
@@ -102,7 +105,7 @@ export class NodeServices {
 		response.writeUInt16BE(rinfo.port, 26); // Port
 		response.writeUInt32BE(Converter.ipToInt(rinfo.address), 28); // IP
 		
-		if (this.verbose > 1) console.log(`%cSTUN Response: client will discover IP ${rinfo.address}:${rinfo.port}`, 'color: green;');
+		if (this.verbose > 2) console.log(`%cSTUN Response: client will discover IP ${rinfo.address}:${rinfo.port}`, 'color: green;');
 		return response;
 	}
 	/** @param {Array<{id: string, publicUrl: string}>} bootstraps */

package/core/node.mjs

@@ -1,4 +1,4 @@
-import { CLOCK, SIMULATION, NODE, DISCOVERY } from './parameters.mjs';
+import { CLOCK, SIMULATION, NODE, SERVICE, DISCOVERY } from './config.mjs';
 import { Arbiter } from './arbiter.mjs';
 import { OfferManager } from './ice-offer-manager.mjs';
 import { PeerStore } from './peer-store.mjs';
@@ -8,7 +8,47 @@ import { Topologist } from './topologist.mjs';
 import { CryptoCodex } from './crypto-codex.mjs';
 import { NodeServices } from './node-services.mjs';
 
-export class NodeP2P {
+/** Create and start a new PublicNode instance.
+ * @param {Object} options
+ * @param {Array<{id: string, publicUrl: string}>} options.bootstraps List of bootstrap nodes used as P2P network entry
+ * @param {boolean} [options.autoStart] If true, the node will automatically start after creation (default: true)
+ * @param {CryptoCodex} [options.cryptoCodex] Identity of the node; if not provided, a new one will be generated
+ * @param {string} [options.domain] If provided, the node will operate as a public node and start necessary services (e.g., WebSocket server)
+ * @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) {		
+	const verbose = options.verbose !== undefined ? options.verbose : NODE.DEFAULT_VERBOSE;
+	const domain = options.domain || undefined;
+	const codex = options.cryptoCodex || new CryptoCodex(undefined, verbose);
+	if (!codex.publicKey) await codex.generate(domain ? true : false);
+	
+	const node = new Node(codex, options.bootstraps || [], verbose);
+	if (domain) {
+		node.services = new NodeServices(codex, node.peerStore, undefined, verbose);
+		node.services.start(domain, options.port || SERVICE.PORT);
+		node.topologist.services = node.services;
+	}
+	if (options.autoStart !== false) await node.start();
+	return node;
+}
+
+/** Create and start a new Node instance.
+ * @param {Object} options
+ * @param {Array<{id: string, publicUrl: string}>} options.bootstraps List of bootstrap nodes used as P2P network entry
+ * @param {CryptoCodex} [options.cryptoCodex] Identity of the node; if not provided, a new one will be generated
+ * @param {boolean} [options.autoStart] If true, the node will automatically start after creation (default: true)
+ * @param {number} [options.verbose] Verbosity level for logging (default: NODE.DEFAULT_VERBOSE) */
+export async function createNode(options = {}) {
+	const verbose = options.verbose !== undefined ? options.verbose : NODE.DEFAULT_VERBOSE;
+	const codex = options.cryptoCodex || new CryptoCodex(undefined, verbose);
+	if (!codex.publicKey) await codex.generate(false);
+
+	const node = new Node(codex, options.bootstraps || [], verbose);
+	if (options.autoStart !== false) await node.start();
+	return node;
+}
+
+export class Node {
 	started = false;
 	id; cryptoCodex; verbose; arbiter;
 	/** class managing ICE offers */ offerManager;
@@ -23,15 +63,16 @@ export class NodeP2P {
 	 * @param {Array<Record<string, string>>} bootstraps List of bootstrap nodes used as P2P network entry */
 	constructor(cryptoCodex, bootstraps = [], verbose = NODE.DEFAULT_VERBOSE) {
 		this.verbose = verbose;
+		if (this.topologist?.services) this.topologist.services.verbose = verbose;
 		this.cryptoCodex = cryptoCodex;
 		this.id = this.cryptoCodex.id;
-		const stunUrls = NodeServices.deriveSTUNServers(bootstraps);
+		const stunUrls = NodeServices.deriveSTUNServers(bootstraps || []);
 		this.offerManager = new OfferManager(this.id, stunUrls, verbose);
 		this.arbiter = new Arbiter(this.id, cryptoCodex, verbose);
 		this.peerStore = new PeerStore(this.id, this.cryptoCodex, this.offerManager, this.arbiter, verbose);
 		this.messager = new UnicastMessager(this.id, this.cryptoCodex, this.arbiter, this.peerStore, verbose);
 		this.gossip = new Gossip(this.id, this.cryptoCodex, this.arbiter, this.peerStore, verbose);
-		this.topologist = new Topologist(this.id, this.gossip, this.messager, this.peerStore, bootstraps);
+		this.topologist = new Topologist(this.id, this.gossip, this.messager, this.peerStore, bootstraps || []);
 		const { arbiter, peerStore, messager, gossip, topologist } = this;
 
 		// SETUP TRANSPORTS LISTENERS
@@ -47,7 +88,7 @@ export class NodeP2P {
 		// GOSSIP LISTENERS
 		gossip.on('signal_offer', (senderId, data, HOPS) => topologist.handleIncomingSignal(senderId, data, HOPS));
 
-		if (verbose > 2) console.log(`NodeP2P initialized: ${this.id}`);
+		if (verbose > 2) console.log(`Node initialized: ${this.id}`);
 	}
 
 	// PRIVATE METHODS
@@ -95,21 +136,11 @@ export class NodeP2P {
 
 	// PUBLIC API
 	get publicUrl() { return this.services?.publicUrl; }
+	get publicIdentity() { return { id: this.id, publicUrl: this.publicUrl }; }
 
-	/** @param {Array<string>} bootstraps @param {CryptoCodex} [cryptoCodex] - Identity of the node; if not provided, a new one will be generated @param {boolean} [start] default: false @param {string} [domain] public node only, ex: 'localhost' @param {number} [port] public node only, ex: 8080 */
-	static async createNode(bootstraps, cryptoCodex, start = true, domain, port = NODE.SERVICE.PORT, verbose = NODE.DEFAULT_VERBOSE) {
-		const codex = cryptoCodex || new CryptoCodex();
-		if (!codex.publicKey) await codex.generate(domain ? true : false);
-
-		const node = new NodeP2P(codex, bootstraps, verbose);
-		if (domain) {
-			node.services = new NodeServices(codex, node.peerStore, undefined, verbose);
-			node.services.start(domain, port);
-			node.topologist.services = node.services;
-		}
-		if (start) await node.start();
-		return node;
-	}
+	onMessageData(callback) { this.messager.on('message', callback); }
+	onGossipData(callback) { this.gossip.on('gossip', callback); }
+	
 	async start() {
 		await CLOCK.sync(this.verbose);
 		this.started = true;

package/core/peer-store.mjs

@@ -1,4 +1,4 @@
-import { CLOCK, SIMULATION, NODE, DISCOVERY, LOG_CSS } from './parameters.mjs';
+import { CLOCK, SIMULATION, NODE, DISCOVERY, LOG_CSS } from './config.mjs';
 const { SANDBOX, ICE_CANDIDATE_EMITTER, TEST_WS_EVENT_MANAGER } = SIMULATION.ENABLED ? await import('../simulation/test-transports.mjs') : {};
 
 export class KnownPeer { // known peer, not necessarily connected

package/core/topologist.mjs

@@ -1,4 +1,4 @@
-import { CLOCK, SIMULATION, TRANSPORTS, NODE, DISCOVERY, GOSSIP } from './parameters.mjs';
+import { CLOCK, SIMULATION, TRANSPORTS, NODE, DISCOVERY, GOSSIP } from './config.mjs';
 import { PeerConnection } from './peer-store.mjs';
 import { CryptoCodex } from './crypto-codex.mjs';
 const { SANDBOX, ICE_CANDIDATE_EMITTER, TEST_WS_EVENT_MANAGER } = SIMULATION.ENABLED ? await import('../simulation/test-transports.mjs') : {};

package/core/unicast.mjs

@@ -1,4 +1,4 @@
-import { SIMULATION, DISCOVERY, UNICAST } from "./parameters.mjs";
+import { SIMULATION, DISCOVERY, UNICAST } from "./config.mjs";
 import { TRUST_VALUES } from "./arbiter.mjs";
 import { RouteBuilder_V2 } from "./route-builder.mjs";
 const { SANDBOX, ICE_CANDIDATE_EMITTER, TEST_WS_EVENT_MANAGER } = SIMULATION.ENABLED ? await import('../simulation/test-transports.mjs') : {};