@hive-p2p/server 1.0.19 → 1.0.21

package/rendering/visualizer.mjs

@@ -0,0 +1,254 @@
+import { NetworkRenderer } from './NetworkRenderer.mjs';
+import { CryptoCodex } from '../core/crypto-codex.mjs';
+window.CryptoCodex = CryptoCodex; // Expose for debugging
+
+class SimulationInterface {
+	#connectingWs = false;
+	#ws;
+	currentPeerId;
+	onSettings;
+	onPeersIds;
+	onPeerInfo;
+	onPeerMessage;
+
+	responseReceivedByType = {};
+
+	/** @param {function} onSettings @param {function} onPeersIds @param {function} onPeerInfo */
+	constructor(onSettings, onPeersIds, onPeerInfo) {
+		if (!onSettings || !onPeersIds || !onPeerInfo) return console.error('SimulationInterface requires three callback functions: onSettings, onPeersIds, onPeerInfo');
+		this.onSettings = onSettings;
+		this.onPeersIds = onPeersIds;
+		this.onPeerInfo = onPeerInfo;
+		this.#setupWs();
+		window.addEventListener('beforeunload', () => this.#ws ? this.#ws.close() : null);
+		setInterval(() => { if (this.currentPeerId) this.getPeerInfo(this.currentPeerId) }, 300);
+		setInterval(() => { this.getPeerIds() }, 5000);
+	}
+
+	#setupWs(url = 'ws://localhost:3000') {
+		if (this.#ws) this.#ws.close();
+		this.#connectingWs = true;
+		this.#ws = new WebSocket(url);
+		this.#ws.onmessage = (event) => {
+			const msg = JSON.parse(event.data);
+
+			if (msg.type === 'settings') this.onSettings(msg.data);
+			if (msg.type === 'peersIds') this.onPeersIds(msg.data);
+			if (msg.type === 'peerInfo') this.onPeerInfo(msg.data);
+			if (msg.type === 'peerMessage' && this.onPeerMessage) this.onPeerMessage(msg.remoteId, msg.data);
+		};
+		this.#connectingWs = false;
+	}
+
+	start(settings) { this.#sendWsMessage({ type: 'start', settings }); }
+	getPeerInfo() {
+		this.#sendWsMessage({ type: 'getPeerInfo', peerId: this.currentPeerId });
+	}
+	getPeerIds() {
+		this.#sendWsMessage({ type: 'getPeersIds' });
+	}
+	tryToConnectNode(fromId, targetId) {
+		if (!fromId || !targetId) return;
+		this.#sendWsMessage({ type: 'tryToConnectNode', fromId, targetId });
+	}
+	#sendWsMessage(msg, avoidSendingIfNotAnswered = false) {
+		if (this.#ws?.readyState === WebSocket.OPEN) {
+			if (avoidSendingIfNotAnswered && this.responseReceivedByType[msg.type] === false) return;
+			this.responseReceivedByType[msg.type] = false;
+			this.#ws.send(JSON.stringify(msg));
+		} else {
+			console.error(`WebSocket is not connected. ${this.#connectingWs ? 'Trying to connect...' : ''}`);
+			setTimeout(() => { if (!this.#connectingWs) this.#setupWs(); }, 2000);
+		}
+	}
+}
+
+class NetworkVisualizer {
+	autoSelectCurrentPeerCategory = ['standard', 'public']; // 'public' | 'standard' | false
+	currentPeerId;
+	lastPeerInfo;
+	networkRenderer = new NetworkRenderer();
+	simulationInterface;
+
+	peersList = {};
+	elements = {
+		peersList: document.getElementById('peersList'),
+		simulationSettings: document.getElementById('simulationSettings'),
+
+		publicPeersCount: document.getElementById('publicPeersCount'),
+		peersCount: document.getElementById('peersCount'),
+		startSimulation: document.getElementById('startSimulation'),
+	}
+
+	constructor(isSimulation = true) {
+		if (isSimulation) {
+			this.elements.peersList.style.display = 'block';
+			this.elements.simulationSettings.style.display = 'block';
+			this.simulationInterface = new SimulationInterface(
+				(settings) => this.#handleSettings(settings), // event: onSettings
+				(peersIds) => this.#updatePeersList(peersIds), // event: onPeersIds
+				(data) => { if (data.peerId === this.currentPeerId) this.#updateNetworkFromPeerInfo(data.peerInfo); } // event: onPeerInfo
+			);
+
+			this.simulationInterface.onPeerMessage = (remoteId, data) => {
+				if (data.route) this.networkRenderer.displayDirectMessageRoute(remoteId, data.route);
+				else if (data.topic) this.networkRenderer.displayGossipMessageRoute(remoteId, data.senderId, data.topic, data.data);
+			};
+
+			this.networkRenderer.onNodeLeftClick = (nodeId) => this.simulationInterface.tryToConnectNode(this.currentPeerId,nodeId);
+			this.networkRenderer.onNodeRightClick = (nodeId) => this.#setSelectedPeer(nodeId);
+			this.elements.startSimulation.onclick = () => {
+				this.mockRunning = false;
+				this.networkRenderer.clearNetwork();
+				this.simulationInterface.start(this.#getSimulatorSettings());
+			}
+		}
+
+		setInterval(() => this.networkRenderer.updateStats(), 200);
+
+		window.addEventListener('keydown', (e) => {
+			if (e.key === 'ArrowUp') this.#selectPreviousPeer();
+			if (e.key === 'ArrowDown') this.#selectNextPeer();
+		});
+	}
+
+	#setSelectedPeer(peerId) {
+		if (!peerId) return;
+		if (this.networkRenderer.currentPeerId !== peerId) {
+			console.log(`Selected peer changed, now => ${peerId}`);
+			this.networkRenderer.maxDistance = 0; // reset maxDistance to show all nodes
+			this.networkRenderer.avoidAutoZoomUntil = Date.now() + 2000; // avoid auto-zoom for 2 seconds
+			this.networkRenderer.lastAutoZoomDistance = 0;
+			this.networkRenderer.clearNetwork(); // Clear network and scroll peerId into view
+
+			for (const peerItem of document.querySelectorAll(`#peersList div[data-peer-id]`))
+				if (peerItem.dataset.peerId === peerId) peerItem.classList.add('selected');
+				else peerItem.classList.remove('selected');
+				
+			const selectedItem = document.querySelector(`#peersList div[data-peer-id="${peerId}"]`);
+			if (selectedItem) {
+				const listRect = this.elements.peersList.getBoundingClientRect();
+				const itemRect = selectedItem.getBoundingClientRect();
+				if (itemRect.top < listRect.top || itemRect.bottom > listRect.bottom) {
+					this.elements.peersList.scrollTop = selectedItem.offsetTop - this.elements.peersList.offsetTop - this.elements.peersList.clientHeight / 2 + selectedItem.clientHeight / 2;
+				}
+			}
+		}
+		this.networkRenderer.currentPeerId = peerId;
+
+		this.#setCurrentPeer(peerId);
+		this.simulationInterface.getPeerInfo();
+
+	}
+	#selectNextPeer() {
+		const peerIds = Object.keys(this.peersList);
+		if (peerIds.length === 0) return;
+		if (!this.currentPeerId) return this.#setSelectedPeer(peerIds[0]);
+		const currentIndex = peerIds.indexOf(this.currentPeerId);
+		const nextIndex = (currentIndex + 1) % peerIds.length;
+		this.#setSelectedPeer(peerIds[nextIndex]);
+	}
+	#selectPreviousPeer() {
+		const peerIds = Object.keys(this.peersList);
+		if (peerIds.length === 0) return;
+		if (!this.currentPeerId) return this.#setSelectedPeer(peerIds[0]);
+		const currentIndex = peerIds.indexOf(this.currentPeerId);
+		const previousIndex = (currentIndex - 1 + peerIds.length) % peerIds.length;
+		this.#setSelectedPeer(peerIds[previousIndex]);
+	}
+	#setCurrentPeer(id, clearNetworkOneChange = true) {
+		this.currentPeerId = id;
+		this.simulationInterface.currentPeerId = id;
+		this.networkRenderer.setCurrentPeer(id, clearNetworkOneChange);
+	}
+	#getSimulatorSettings() {
+		return {
+			publicPeersCount: parseInt(this.elements.publicPeersCount.value),
+			peersCount: parseInt(this.elements.peersCount.value)
+		};
+	}
+	// LIVE METHODS
+	#updateNetworkFromPeerInfo(peerInfo) {
+		if (!peerInfo) return;
+		this.lastPeerInfo = peerInfo;
+
+		const newlyUpdated = {};
+		const digestPeerUpdate = (id = 'toto', status = 'unknown', neighbors = []) => {
+			const isPublic = CryptoCodex.isPublicNode(id);
+			this.networkRenderer.addOrUpdateNode(id, status, isPublic, neighbors);
+			newlyUpdated[id] = true;
+		}
+
+		const getNeighbors = (peerId) => {
+			const knownPeer = peerInfo.store.known[peerId];
+			return knownPeer ? Object.keys(knownPeer.neighbors || {}) : [];
+		}
+		
+		const knownToIgnore = {};
+		knownToIgnore[this.currentPeerId] = true;
+		for (const id of peerInfo.store.connecting) knownToIgnore[id] = true;
+		for (const id of peerInfo.store.connected) knownToIgnore[id] = true;
+		for (const id in peerInfo.store.known)
+			if (!knownToIgnore[id]) digestPeerUpdate(id, 'known', getNeighbors(id));
+		
+		for (const id of peerInfo.store.connecting) digestPeerUpdate(id, 'connecting', getNeighbors(id));
+		for (const id of peerInfo.store.connected) digestPeerUpdate(id, 'connected', getNeighbors(id));
+
+	
+		const nodes = this.networkRenderer.nodesStore.store;
+		const nodeIds = this.networkRenderer.nodesStore.getNodesIds();
+		for (const id of nodeIds) // filter absent nodes
+			if (!newlyUpdated[id] && id !== this.currentPeerId) this.networkRenderer.removeNode(id);
+
+		// ensure current peer is updated
+		if (peerInfo.id === this.currentPeerId) digestPeerUpdate(peerInfo.id, 'current', getNeighbors(peerInfo.id));
+
+		// Create connections
+		const connections = [];
+		for (const id in nodes)
+			for (const neighborId of nodes[id].neighbors) connections.push([id, neighborId]);
+
+		//console.log(`Updated network map: ${Object.keys(nodes).length} nodes | ${Object.keys(connections).length} connections`);
+		this.networkRenderer.digestConnectionsArray(connections);
+	}
+	// SIMULATION METHODS
+	#handleSettings(settings = { publicPeersCount: 2, peersCount: 5 }) {
+		if (settings.publicPeersCount) this.elements.publicPeersCount.value = settings.publicPeersCount;
+		if (settings.peersCount) this.elements.peersCount.value = settings.peersCount;
+		if (settings.autoStart) this.simulationInterface.getPeerIds();
+	}
+	#createPeerItem(peerId) {
+		const peerItem = document.createElement('div');
+		peerItem.dataset.peerId = peerId;
+		peerItem.textContent = peerId;
+		peerItem.onclick = () => this.#setSelectedPeer(peerId);
+		return peerItem;
+	}
+	#updatePeersList(peersData, element = this.elements.peersList) {
+		//element.innerHTML = '<h3>Peers list</h3>';
+
+		const peerIds = {};
+		for (const category in peersData)
+			for (const peerId of peersData[category]) {
+				peerIds[peerId] = true;
+				if (this.peersList[peerId]) continue; // already listed
+				const peerItem = this.#createPeerItem(peerId);
+				element.appendChild(peerItem);
+				this.peersList[peerId] = peerItem;
+			}
+		
+		for (const peerId of Object.keys(this.peersList)) // remove absent peers
+			if (!peerIds[peerId]) { this.peersList[peerId].remove(); delete this.peersList[peerId]; }
+
+		if (this.currentPeerId) return this.#setSelectedPeer(this.currentPeerId); // Auto-select current peer
+
+		for (const category of this.autoSelectCurrentPeerCategory)
+			for (const peerId of peersData[category] || []) return this.#setSelectedPeer(peerId);
+	}
+}
+
+const networkVisualizer = new NetworkVisualizer(true);
+if (typeof window !== 'undefined') {
+	window.networkVisualizer = networkVisualizer; // Expose for debugging
+	window.networkRenderer = networkVisualizer.networkRenderer; // Expose for debugging
+}

package/services/clock-v2.mjs

@@ -0,0 +1,196 @@
+/**
+ * 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'];
+	#browserSources = [
+		'worldtimeapi.org/api/timezone/UTC',
+		'timeapi.io/api/Time/current/zone?timeZone=UTC', 
+		'api.github.com'
+	];
+
+	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; }
+	get time() { 
+		if (this.mockMode) return Date.now();
+		if (this.#offset === null) return null; 
+		return Date.now() + Math.round(this.#offset); 
+	}
+
+	async sync(verbose) {
+		if (verbose !== undefined) this.verbose = verbose;
+		if (this.mockMode) return Date.now();
+
+		if (this.#syncing) {
+			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();
+
+			if (samples.length < this.#sources.length) 
+				setTimeout(() => this.#backgroundRefine(), 100);
+			return this.time;
+		} catch (error) {
+			console.error('[Clock] Sync failed:', error);
+			this.#offset = 0;
+			return this.time;
+		} finally { 
+			this.#syncing = false; 
+		}
+	}
+
+	get status() {
+		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() {
+		const sources = (typeof window !== 'undefined') ? this.#browserSources : this.#sources;
+		const promises = sources.map(source => this.#fetchTimeFromSource(source));
+		const results = await Promise.allSettled(promises);
+		
+		const samples = [];
+		for (const result of results) {
+			if (result.status === 'fulfilled' && result.value) {
+				samples.push(result.value);
+			}
+		}
+		return samples;
+	}
+
+	async #fetchTimeFromSource(source) {
+		const controller = new AbortController();
+		const timeoutId = setTimeout(() => controller.abort(), 5000); // Plus de timeout
+
+		try {
+			const startTime = Date.now();
+			const url = source.startsWith('http') ? source : `https://${source}`;
+			
+			const response = await fetch(url, { 
+				method: source.includes('api.github.com') ? 'HEAD' : 'GET',
+				signal: controller.signal, 
+				cache: 'no-cache',
+				mode: 'cors' // Explicit CORS
+			});
+			
+			const networkLatency = (Date.now() - startTime) / 2;
+			if (!response.ok) throw new Error(`HTTP ${response.status}`);
+
+			let serverTime;
+			
+			if (source.includes('worldtimeapi')) {
+				const data = await response.json();
+				serverTime = new Date(data.utc_datetime).getTime();
+			} else if (source.includes('timeapi')) {
+				const data = await response.json();
+				serverTime = new Date(data.dateTime).getTime();
+			} else {
+				const dateHeader = response.headers.get('date');
+				if (!dateHeader) throw new Error('No date header');
+				serverTime = new Date(dateHeader).getTime();
+			}
+
+			if (isNaN(serverTime)) throw new Error('Invalid time data');
+
+			return {
+				source,
+				serverTime: serverTime + networkLatency,
+				localTime: Date.now(),
+				latency: networkLatency * 2
+			};
+		} catch (error) {
+			if (this.verbose) console.warn(`[Clock] Failed to fetch time from ${source}:`, error.message);
+			return null; // Retourne explicitement null au lieu d'undefined
+		} finally { 
+			clearTimeout(timeoutId); 
+		}
+	}
+
+	#calculateOffset(samples) {
+		// Filter out null samples (au cas où)
+		const validSamples = samples.filter(sample => sample !== null);
+		if (validSamples.length === 0) return 0;
+		if (validSamples.length === 1) return validSamples[0].serverTime - validSamples[0].localTime;
+		
+		validSamples.sort((a, b) => a.latency - b.latency);
+
+		const offsets = [];
+		for (const sample of validSamples) 
+			offsets.push(sample.serverTime - sample.localTime);
+		
+		offsets.sort((a, b) => a - b);
+		const mid = Math.floor(offsets.length / 2);
+
+		if (offsets.length % 2 === 0) 
+			return (offsets[mid - 1] + offsets[mid]) / 2;
+		return offsets[mid];
+	}
+
+	async #backgroundRefine() {
+		if (this.#syncing) return;
+
+		try {
+			const samples = await this.#fetchTimeSamples();
+			if (samples.length === 0) return;
+			
+			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() {
+	const startTime = Date.now();
+	const clock = new Clock(1); // Verbose pour debug
+	
+	try {
+		await clock.sync();
+		console.log('Synchronized in:', Date.now() - startTime, 'ms');
+		console.log('Synchronized time:', new Date(clock.time).toISOString());
+		console.log('Clock status:', clock.status);
+	} catch (error) {
+		console.error('Sync failed:', error);
+	}
+}

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); }
+}