webpeerjs 0.0.8 → 0.0.10

package/src/webpeerjs.js

@@ -9,19 +9,24 @@ import {
 	msgIdFnStrictNoSign,
 	metrics,
 	getDigest,
-	mkDebug
+	mkDebug,
+	multiaddr,
+	pipe,
+	lpStream,
+	lp,
+	map
 } from './utils'
 import { createDelegatedRoutingV1HttpApiClient } from '@helia/delegated-routing-v1-http-api-client'
 import { createLibp2p } from 'libp2p'
 import { IDBDatastore } from 'datastore-idb'
 import { webTransport } from '@libp2p/webtransport'
+import { webSockets } from '@libp2p/websockets'
 import { noise } from '@chainsafe/libp2p-noise'
 import { yamux } from '@chainsafe/libp2p-yamux'
 import { pubsubPeerDiscovery } from '@libp2p/pubsub-peer-discovery'
 import { circuitRelayTransport } from '@libp2p/circuit-relay-v2'
 import { gossipsub } from '@chainsafe/libp2p-gossipsub'
 import { identify, identifyPush } from '@libp2p/identify'
-import { multiaddr } from '@multiformats/multiaddr'
 import { peerIdFromString } from '@libp2p/peer-id'
 import { kadDHT, removePrivateAddressesMapper } from '@libp2p/kad-dht'
 import { simpleMetrics } from '@libp2p/simple-metrics'
@@ -84,6 +89,9 @@ class webpeerjs{
 	//message tracker avoid double
 	#msgIdtracker
 	
+	//map of peer exchange data
+	#peerexchangedata
+	
 	id
 	status
 	IPFS
@@ -112,6 +120,7 @@ class webpeerjs{
 		this.#dialQueue = []
 		this.#isDialEnabled = true
 		this.#msgIdtracker = []
+		this.#peerexchangedata = new Map()
 		
 		this.peers = (function(f) {
 			return f
@@ -143,8 +152,8 @@ class webpeerjs{
 			const connect = connections.find((con)=>con.id == id)
 			const addr = connect.addr
 
-			if(config.CONFIG_KNOWN_BOOTSTRAP_PEERS_IDS.includes(id) || config.CONFIG_KNOWN_BOOTSTRAP_HYBRID_IDS.includes(id)){
-				if(!this.#connections.has(id)&&addr.includes('webtransport')){
+			if(config.CONFIG_KNOWN_BOOTSTRAP_PEERS_IDS.includes(id)){
+				if((!this.#connections.has(id) || (this.#connections.get(id).includes('/wss/')))&&addr.includes('webtransport')){
 					await this.#dbstore.put(new Key(id), new TextEncoder().encode(addr))
 				}
 			}
@@ -410,9 +419,8 @@ class webpeerjs{
 				count++
 				this.#trackDisconnect.set(id,count)
 				//console.log(this.#trackDisconnect)
-				if(count>5){
+				if(count>10){
 					if(this.#dbstoreData.has(id)){
-						//await this.#dbstore.delete(new Key(id))
 						this.#dbstoreData.delete(id)
 					}
 					
@@ -425,6 +433,11 @@ class webpeerjs{
 				this.#trackDisconnect.set(id,0)
 			}
 			
+			let peerexchangelist = []
+			for(const peer of this.#peerexchangedata.values()){
+				peerexchangelist.push(peer.id)
+			}
+			
 			//if this disconnected peer is web peer redial it
 			if(this.#webPeersId.includes(id)){
 				const addr = this.#connections.get(id)
@@ -436,6 +449,15 @@ class webpeerjs{
 			
 			//if this disconnected peer is known bootstrap redial it
 			else if(this.#dialedKnownBootstrap.has(id)){
+				const addr = this.#connections.get(id)
+				if(addr.includes('/wss/'))return
+				let mddrs = []
+				const addrs = multiaddr(addr)
+				mddrs.push(addrs)
+				this.#dialMultiaddress(mddrs)
+			}
+
+			else if(peerexchangelist.includes(id)){
 				const addr = this.#connections.get(id)
 				let mddrs = []
 				const addrs = multiaddr(addr)
@@ -471,37 +493,56 @@ class webpeerjs{
 			this.#ping()
 		})
 		
-		this.#libp2p.addEventListener('peer:identify', (evt) => {
+		this.#libp2p.addEventListener('peer:identify', async (evt) => {
 			//console.log('peer:identify '+evt.detail.peerId.toString(),evt.detail)
+			
+			const id = evt.detail.peerId.toString()
+			
+			if(config.CONFIG_KNOWN_BOOTSTRAP_PUBLIC_IDS.includes(id)){
+				const remoteAddr = evt.detail.connection.remoteAddr.toString()
+				if(remoteAddr.includes('/wss/')){
+					 let addrs = []
+					 let mddrs = []
+					 for(const peer of evt.detail.listenAddrs){
+						 if(!peer.toString().includes('webtransport'))continue
+						 const addr = peer.toString()+'/p2p/'+id
+						 const mddr = multiaddr(addr)
+						 addrs.push(addr)
+						 mddrs.push(mddr)
+					 }
+					 this.#dialedKnownBootstrap.set(id,addrs)
+					 await this.#libp2p.hangUp(peerIdFromString(id))
+					 this.#dialMultiaddress(mddrs)
+				}
+			}
+			
 			if(evt.detail.protocols.includes(config.CONFIG_PROTOCOL)){
-				//console.log('peer:identify '+evt.detail.peerId.toString(),evt.detail)
+				//console.log('peer:identify '+evt.detail.peerId.toString(),evt)
 				
 				const id = evt.detail.peerId.toString()
 				let address = []
+				let mddrs = []
 				
 				for(const addrs of evt.detail.listenAddrs){
 					const addr = addrs.toString()+'/p2p/'+id
+					const mddr = multiaddr(addr)
 					if(addr.includes('webtransport')){
 						address.push(addr)
+						mddrs.push(mddr)
 					}
 				}
 				
-				if(!this.#webPeersId.includes(id))this.#webPeersId.push(id)
-
 				if(this.#connectedPeers.has(id)){
 					//reset this last seen
 					const now = new Date().getTime()
 					const metadata = {addrs:address,last:now}
 					this.#connectedPeers.set(id,metadata)
 				}
-				else{
-					//add to connected webpeers
-					this.#onConnectFn(id)
-					const now = new Date().getTime()
-					const metadata = {addrs:address,last:now}
-					this.#connectedPeers.set(id,metadata)
-					this.#updatePeers()
-				}
+				
+				
+				const command = 'peer-exchange'
+				this.#dialProtocol(id,command)
+				
 
 			}
 		})
@@ -582,14 +623,67 @@ class webpeerjs{
 
 	//Listen on new peer connection
 	#onConnectFn = () => {}
-	onJoin = f => (this.#onConnectFn = f)
+	onConnect = f => (this.#onConnectFn = f)
 
 
 	//Listen on peer disconnect
 	#onDisconnectFn = () => {}
-	onLeave = f => (this.#onDisconnectFn = f)	
+	onDisconnect = f => (this.#onDisconnectFn = f)	
+
+	joinRoom = room => {
+		if (this.#rooms[room]) {
+			return [
+				this.#rooms[room].sendMessage,
+				this.#rooms[room].listenMessage,
+				this.#rooms[room].onMembersChange
+			]
+			
+
+		}
 
+		if (!room) {
+			throw mkErr('room is required')
+		}
+		
+		//join room version 1 user pupsub via pupsub peer discovery
+		if(config.CONFIG_JOIN_ROOM_VERSION == 1){
 
+			const topics = config.CONFIG_PUBSUB_PEER_DISCOVERY
+			
+			this.#rooms[room] = {
+				onMessage : () => {},
+				listenMessage : f => (this.#rooms[room] = {...this.#rooms[room], onMessage: f}),
+				sendMessage : async (message) => {
+					const msgId = (new Date()).getTime()
+					const data = JSON.stringify({prefix:config.CONFIG_PREFIX,room,message,id:this.#libp2p.peerId.toString(),msgId})
+					const peer = {
+					  publicKey: this.#libp2p.peerId.publicKey,
+					  addrs: [uint8ArrayFromString(data)],
+					}
+					const encodedPeer = PBPeer.encode(peer)
+					for(const topic of topics){
+						await this.#libp2p.services.pubsub.publish(topic, encodedPeer)
+					}
+				},
+				members : [this.id],
+				onMembers : () => {},
+				onMembersChange : f => {this.#rooms[room] = {...this.#rooms[room], onMembers: f};this.#rooms[room].onMembers(this.#rooms[room].members);this.#ping()},
+			}
+		}
+		
+		return [
+			this.#rooms[room].sendMessage,
+			this.#rooms[room].listenMessage,
+			this.#rooms[room].onMembersChange
+		]
+	}
+	
+	dial(addr){
+		let mddrs = []
+		const mddr = multiaddr(addr)
+		mddrs.push(mddr)
+		this.#dialMultiaddress(mddrs)
+	}
 
 
 	/*
@@ -611,13 +705,96 @@ class webpeerjs{
 	}
 	
 	async #registerProtocol(){
-		const handler = ({ connection, stream, protocol }) => {
-		  // use stream or connection according to the needs
+		
+		const handler = async ({ connection, stream, protocol }) => {
+			try{
+				const output = await pipe(
+					stream.source,
+					(source) => lp.decode(source),
+					(source) => map(source, (buf) => uint8ArrayToString(buf.subarray())),
+					async function (source) {
+					  let string = ''
+					  for await (const msg of source) {
+						string += msg.toString()
+					  }
+					  return string
+					}
+				)
+				
+				const id = connection.remotePeer.toString()
+				
+				let json = JSON.parse(output)
+
+				let jsonMessage = {
+						protocol:config.CONFIG_PROTOCOL,
+						command:null,
+						data:null
+				}
+				
+				if(json.command === 'peer-exchange'){
+					
+					if(json.protocol == config.CONFIG_PROTOCOL){
+						const address = [connection.remoteAddr.toString()]
+						if(this.#connectedPeers.has(id)){
+							//reset this last seen
+							const now = new Date().getTime()
+							const metadata = {addrs:address,last:now}
+							this.#connectedPeers.set(id,metadata)
+						}
+						else{
+							if(!this.#webPeersId.includes(id))this.#webPeersId.push(id)
+								
+							//add to connected webpeers
+							this.#onConnectFn(id)
+							const now = new Date().getTime()
+							const metadata = {addrs:address,last:now}
+							this.#connectedPeers.set(id,metadata)
+							this.#updatePeers()
+						}
+					}
+					
+					if(json.data != null){
+						this.#peerexchangedata.set(id,json.data)
+						let mddrs = []
+						const dataaddr = json.data.addr
+						const datamddr = multiaddr(dataaddr)
+						const dataid = json.data.id
+						mddrs.push(datamddr)
+						this.#dialMultiaddress(mddrs)
+						if(!this.#dbstoreData.has(dataid)){
+							//await this.#dbstore.put(new Key(dataid), new TextEncoder().encode(dataaddr))
+							//this.#dbstoreData.set(dataid,dataaddr)
+						}
+					}
+					
+					const keys = Array.from(this.#dbstoreData.keys())
+					const randomKey = Math.floor(Math.random() * keys.length)
+					const key = keys[randomKey]
+					const addr = this.#dbstoreData.get(key)
+					
+					jsonMessage.command = json.command
+					jsonMessage.data = {id:key,addr}	
+				}
+				
+				const message = JSON.stringify(jsonMessage)
+				//console.log('answer message '+id,message)
+				
+				pipe(
+					message,
+					(source) => map(source, (string) => uint8ArrayFromString(string)),
+					(source) => lp.encode(source),
+					stream.sink
+				)
+			}
+			catch(err){
+				//console.warn(err)
+			}
 		}
 
 		await this.#libp2p.handle(config.CONFIG_PROTOCOL, handler, {
-		  maxInboundStreams: 5,
-		  maxOutboundStreams: 5
+		  maxInboundStreams: 50,
+		  maxOutboundStreams: 50,
+		  runOnTransientConnection:true
 		})
 
 		await this.#libp2p.register(config.CONFIG_PROTOCOL, {
@@ -633,37 +810,129 @@ class webpeerjs{
 
 	}
 	
-	#findHybridPeer(){
-		setTimeout(async()=>{
-			for(const target of config.CONFIG_KNOWN_BOOTSTRAP_HYBRID_IDS){
-				if(!this.#isConnected(target) && !this.#connections.has(target) && this.#isDialEnabled ){
-					//console.log('findPeer',target)
-					const peerId = peerIdFromString(target)
-					//const peerInfo = await this.#libp2p.services.aminoDHT.findPeer(peerId)
-
-					//console.info(peerInfo)
-					for await (const event of this.#libp2p.services.aminoDHT.findPeer(peerId)){
-						//console.info('findPeer',event)
-						if (event.name === 'FINAL_PEER'){
-							//console.log(event.peer.id.toString(),event.peer.multiaddrs.toString())
-							let mddrs = []
-							let addrs = []
-							const id = event.peer.id.toString()
-							for(const mddr of event.peer.multiaddrs){
-								const peeraddr = mddr.toString()+'/p2p/'+id
-								const peermddr = multiaddr(peeraddr)
-								addrs.push(peeraddr)
-								mddrs.push(peermddr)
-							}
-							this.#dialedKnownBootstrap.set(id,addrs)
-							if(!this.#isConnected(id)){
-								this.#dialMultiaddress(mddrs)
-							}
+	async #dialProtocol(id,command){
+
+		const connections = this.#libp2p.getConnections().map((con)=>{return {id:con.remotePeer.toString(),addr:con.remoteAddr.toString()}})
+		const connect = connections.find((con)=>con.id == id)
+		const addr = connect.addr
+		const mddr = multiaddr(addr)
+		
+		let jsonMessage = {
+				protocol:config.CONFIG_PROTOCOL,
+				command:null,
+				data:null
+		}
+		
+		if(command === 'peer-exchange'){
+			
+			if(this.#peerexchangedata.has(id))return
+			
+			const keys = Array.from(this.#dbstoreData.keys())
+			const randomKey = Math.floor(Math.random() * keys.length)
+			const key = keys[randomKey]
+			const addr = this.#dbstoreData.get(key)
+			
+			jsonMessage.command = command
+			jsonMessage.data = {id:key,addr}
+		}
+		
+		const message = JSON.stringify(jsonMessage)		
+		//console.log('ask message '+id,message)
+
+		try{
+			
+			const stream = await this.#libp2p.dialProtocol(mddr, config.CONFIG_PROTOCOL,{runOnTransientConnection:true})
+			
+			const output = await pipe(
+				message,
+				(source) => map(source, (string) => uint8ArrayFromString(string)),
+				(source) => lp.encode(source),
+				stream,
+				(source) => lp.decode(source),
+				(source) => map(source, (buf) => uint8ArrayToString(buf.subarray())),
+				async function (source) {
+				  let string = ''
+				  for await (const msg of source) {
+					string += msg.toString()
+				  }
+				  return string
+				}
+			)
+			
+			const json = JSON.parse(output)
+			if(json.protocol == config.CONFIG_PROTOCOL){
+				const address = [addr]
+				if(this.#connectedPeers.has(id)){
+					//reset this last seen
+					const now = new Date().getTime()
+					const metadata = {addrs:address,last:now}
+					this.#connectedPeers.set(id,metadata)
+				}
+				else{
+					if(!this.#webPeersId.includes(id))this.#webPeersId.push(id)
+						
+					//add to connected webpeers
+					this.#onConnectFn(id)
+					const now = new Date().getTime()
+					const metadata = {addrs:address,last:now}
+					this.#connectedPeers.set(id,metadata)
+					this.#updatePeers()
+				}
+			}
+			if(json.command == 'peer-exchange'){
+				if(json.data != null){
+					this.#peerexchangedata.set(id,json.data)
+					let mddrs = []
+					const dataaddr = json.data.addr
+					const datamddr = multiaddr(dataaddr)
+					const dataid = json.data.id
+					mddrs.push(datamddr)
+					this.#dialMultiaddress(mddrs)
+					if(!this.#dbstoreData.has(dataid)){
+						//await this.#dbstore.put(new Key(dataid), new TextEncoder().encode(dataaddr))
+						//this.#dbstoreData.set(dataid,dataaddr)
+					}
+				}
+			}
+		}
+		catch(err){
+			//console.warn(err)
+		}
+	}
+	
+	async #findHybridPeer(){
+
+		if(!navigator.onLine)return
+		if(!this.#isDialEnabled)return
+
+		for(const target of config.CONFIG_KNOWN_BOOTSTRAP_HYBRID_IDS){
+			if(!this.#isConnected(target) && !this.#connections.has(target)){
+				//console.log('findPeer',target)
+				const peerId = peerIdFromString(target)
+				//const peerInfo = await this.#libp2p.services.aminoDHT.findPeer(peerId)
+
+				//console.info(peerInfo)
+				for await (const event of this.#libp2p.services.aminoDHT.findPeer(peerId)){
+					//console.info('findPeer',event)
+					if (event.name === 'FINAL_PEER'){
+						//console.log(event.peer.id.toString(),event.peer.multiaddrs.toString())
+						let mddrs = []
+						let addrs = []
+						const id = event.peer.id.toString()
+						for(const mddr of event.peer.multiaddrs){
+							const peeraddr = mddr.toString()+'/p2p/'+id
+							const peermddr = multiaddr(peeraddr)
+							addrs.push(peeraddr)
+							mddrs.push(peermddr)
+						}
+						this.#dialedKnownBootstrap.set(id,addrs)
+						if(!this.#isConnected(id)){
+							this.#dialMultiaddress(mddrs)
 						}
 					}
 				}
 			}
-		},60e3)
+		}
 	}
 	
 	
@@ -719,13 +988,25 @@ class webpeerjs{
 			
 			const id = mddrs[0].toString().split('/').pop()
 			
-			const ids = this.#dialQueue.map((arr)=> arr[0].toString().split('/').pop())
+			const queueids = this.#dialQueue.map((arr)=> arr[0].toString().split('/').pop())
 			
 			//if peer id is already in the queque cancel queque
-			if(ids.includes(id)){
+			if(queueids.includes(id)){
 				return
 			}
 			
+			const webPeerCount = this.#connectedPeers.size
+			const allPeerCount = this.#libp2p.getPeers().length
+			const nodePeerCount = allPeerCount - webPeerCount
+			const limitCount = config.CONFIG_MAX_CONNECTIONS / 2
+			
+			if(this.#webPeersId.includes(id)){
+				if(webPeerCount>limitCount)return
+			}
+			else{
+				if(nodePeerCount>limitCount)return
+			}
+			
 			if(this.#webPeersId.includes(id) || config.CONFIG_KNOWN_BOOTSTRAP_PEERS_IDS.includes(id) || config.CONFIG_KNOWN_BOOTSTRAP_HYBRID_IDS.includes(id)){
 				this.#dialQueue.unshift(mddrs)
 			}
@@ -739,7 +1020,7 @@ class webpeerjs{
 	//dial multiaddr address in queue list
 	#dialQueueList(){
 		
-		if(!this.#isDialEnabled)return
+		if(!this.#isDialEnabled || !navigator.onLine)return
 		
 		const mddrsToDial = 5
 		
@@ -804,55 +1085,6 @@ class webpeerjs{
 				await this.#libp2p.services.pubsub.publish(topic, encodedPeer)
 			}
 	}
-
-	
-	joinRoom = room => {
-		if (this.#rooms[room]) {
-			return [
-				this.#rooms[room].sendMessage,
-				this.#rooms[room].listenMessage,
-				this.#rooms[room].onMembersChange
-			]
-			
-
-		}
-
-		if (!room) {
-			throw mkErr('room is required')
-		}
-		
-		//join room version 1 user pupsub via pupsub peer discovery
-		if(config.CONFIG_JOIN_ROOM_VERSION == 1){
-
-			const topics = config.CONFIG_PUBSUB_PEER_DISCOVERY
-			
-			this.#rooms[room] = {
-				onMessage : () => {},
-				listenMessage : f => (this.#rooms[room] = {...this.#rooms[room], onMessage: f}),
-				sendMessage : async (message) => {
-					const msgId = (new Date()).getTime()
-					const data = JSON.stringify({prefix:config.CONFIG_PREFIX,room,message,id:this.#libp2p.peerId.toString(),msgId})
-					const peer = {
-					  publicKey: this.#libp2p.peerId.publicKey,
-					  addrs: [uint8ArrayFromString(data)],
-					}
-					const encodedPeer = PBPeer.encode(peer)
-					for(const topic of topics){
-						await this.#libp2p.services.pubsub.publish(topic, encodedPeer)
-					}
-				},
-				members : [this.id],
-				onMembers : () => {},
-				onMembersChange : f => {this.#rooms[room] = {...this.#rooms[room], onMembers: f};this.#rooms[room].onMembers(this.#rooms[room].members);this.#ping()},
-			}
-		}
-		
-		return [
-			this.#rooms[room].sendMessage,
-			this.#rooms[room].listenMessage,
-			this.#rooms[room].onMembersChange
-		]
-	}
 	
 	
 	//dial discovered peers
@@ -955,8 +1187,7 @@ class webpeerjs{
 				if(besttime>bestlimit){
 					const addr = remote.toString()
 					const id = peer.toString()
-					if(!this.#webPeersId.includes(id) && !config.CONFIG_KNOWN_BOOTSTRAP_PEERS_IDS.includes(id) && !this.#dbstoreData.get(id) && !addr.includes('p2p-circuit') && addr.includes('webtransport')){
-						//await this.#dbstore.delete(new Key(id))
+					if(!this.#webPeersId.includes(id) && !config.CONFIG_KNOWN_BOOTSTRAP_PEERS_IDS.includes(id) && !this.#dbstoreData.has(id) && !addr.includes('p2p-circuit') && addr.includes('webtransport')){
 						await this.#dbstore.put(new Key(id), new TextEncoder().encode(addr))
 						this.#dbstoreData.set(id,addr)
 					}
@@ -971,26 +1202,31 @@ class webpeerjs{
 			}
 			
 			
-			let peers = []
-			for(const peer of this.#libp2p.getPeers()){
-				peers.push(peer.toString())
-			}
-			
-			
 			//connect to saved best peer address
 			//working great
 			for(const peer of this.#dbstoreData){
 				const id = peer[0]
 				const addr = peer[1]
-				if(peers.includes(id)){
+				if(this.#isConnected(id)){
 					this.#connectionTrackerStore.set(id,0)
 					continue
 				}else{
 					if(this.#connectionTrackerStore.has(id)){
 						let current = this.#connectionTrackerStore.get(id)
-						if(current>10)continue
 						current++
 						this.#connectionTrackerStore.set(id,current)
+						if(current>5){
+							if(!this.#connections.has(id) && !config.CONFIG_KNOWN_BOOTSTRAP_PEERS_IDS.includes(id) && navigator.onLine)
+							{
+								setTimeout(async ()=> {
+									if(this.#dbstoreData.has(id) && !this.#connections.has(id)){
+										this.#dbstoreData.delete(id)
+										await this.#dbstore.delete(new Key(id))
+									}
+								},60*1000)
+							}
+							continue
+						}
 					}
 					else{
 						this.#connectionTrackerStore.set(id,0)
@@ -1005,7 +1241,7 @@ class webpeerjs{
 			//connect to good peer address if it is disconnected
 			const goods = Array.from(this.#dialedGoodPeers.keys())
 			for(const id of goods){
-				if(peers.includes(id)){
+				if(this.#isConnected(id)){
 					this.#dialedGoodPeers.set(id,0)
 					continue
 				}
@@ -1040,66 +1276,52 @@ class webpeerjs{
 			if(peers == 0){
 				this.#dialKnownPeers()
 			}
-		},60*1000)
+		},120*1000)
 	}
 	
 	
 	//dial to all known bootstrap peers and DNS
 	#dialKnownPeers(){
-		//this.#dialKnownBootstrap()
 		setTimeout(()=>{
 			this.#dialSavedKnownID()
-			this.#findHybridPeer()
 			setTimeout(()=>{this.#dialUpdateSavedKnownID()},50000)
+			setTimeout(()=>{this.#findHybridPeer()},60000)
 			setTimeout(()=>{
 				const peers = this.#libp2p.getPeers().length
 				if(peers == 0){
 					this.#dialKnownID()
-					this.#findHybridPeer()
+					setTimeout(()=>{this.#findHybridPeer()},60000)
 					setTimeout(()=>{
 						const peers = this.#libp2p.getPeers().length
 						if(peers == 0){
-							//currently not needed
-							//this.#dialKnownDNS()
+							this.#dialKnownBootstrap()
+							setTimeout(()=>{this.#findHybridPeer()},15000)
 							setTimeout(()=>{
 								const peers = this.#libp2p.getPeers().length
 								if(peers == 0){
-									//currently not needed
-									//this.#dialKnownDNSonly()
+									this.#dialKnownDNS()
+									setTimeout(()=>{this.#findHybridPeer()},15000)
+									setTimeout(()=>{
+										const peers = this.#libp2p.getPeers().length
+										if(peers == 0){
+											this.#dialKnownDNSonly()
+											setTimeout(()=>{this.#findHybridPeer()},15000)
+										}
+									},config.CONFIG_TIMEOUT_DIAL_KNOWN_PEERS)
 								}
-							},15000)
+							},config.CONFIG_TIMEOUT_DIAL_KNOWN_PEERS)
 						}
-					},15000)
+					},config.CONFIG_TIMEOUT_DIAL_KNOWN_PEERS)
 				}
-			},15000)
+			},config.CONFIG_TIMEOUT_DIAL_KNOWN_PEERS)
 		},5000)
 	}
 	
-	
-	//dial based on known bootsrap peers address
-	#dialKnownBootstrap(){
-		const bootstrap = config.CONFIG_KNOWN_BOOTSTRAP_PEERS_ADDRS
-		for(const peer of bootstrap){
-			const address = peer.Peers[0].Addrs
-			const id = peer.Peers[0].ID
-			let mddrs = []
-			let addrs = []
-			for(const addr of address){
-				const peeraddr = addr+'/p2p/'+id
-				const peermddr = multiaddr(peeraddr)
-				addrs.push(peeraddr)
-				mddrs.push(peermddr)
-			}
-			
-			this.#dialedKnownBootstrap.set(id,addrs)
-			if(!this.#isConnected(id)){
-				this.#dialMultiaddress(mddrs)
-			}
-			
-		}
-	}
-	
 	async #dialSavedKnownID(){
+
+		if(!navigator.onLine)return
+		if(!this.#isDialEnabled)return
+
 		let firsttime = true
 		for(const target of config.CONFIG_KNOWN_BOOTSTRAP_PEERS_IDS){
 			if(this.#dbstoreData.has(target)){
@@ -1122,6 +1344,7 @@ class webpeerjs{
 				const api = config.CONFIG_DELEGATED_API
 				const delegatedClient = createDelegatedRoutingV1HttpApiClient(api)
 				const peer = await first(delegatedClient.getPeers(peerIdFromString(target)))
+				if(!peer)continue
 				const address = peer.Addrs
 				const id = peer.ID
 				let mddrs = []
@@ -1142,16 +1365,26 @@ class webpeerjs{
 	}
 	
 	async #dialUpdateSavedKnownID(){
+
+		if(!navigator.onLine)return
+		if(!this.#isDialEnabled)return
+
 		let firsttime = true
 		for(const target of config.CONFIG_KNOWN_BOOTSTRAP_PEERS_IDS){
 			if(this.#dbstoreData.has(target)){
 				firsttime = false
 			}
-			if(!this.#connections.has(target) && this.#isDialEnabled && (this.#dbstoreData.has(target) || firsttime)){
+			if(!this.#connections.has(target) && (this.#dbstoreData.has(target) || firsttime)){
 				//console.log('#dialUpdateSavedKnownID()',target)
 				const api = config.CONFIG_DELEGATED_API
 				const delegatedClient = createDelegatedRoutingV1HttpApiClient(api)
 				const peer = await first(delegatedClient.getPeers(peerIdFromString(target)))
+				if(!peer){
+					if (navigator.onLine) {
+						await this.#dbstore.delete(new Key(target))
+					}
+					continue
+				}
 				const address = peer.Addrs
 				const id = peer.ID
 				let mddrs = []
@@ -1174,6 +1407,10 @@ class webpeerjs{
 	
 	//dial based on known peers ID
 	async #dialKnownID(){
+		
+		if(!navigator.onLine)return
+		if(!this.#isDialEnabled)return
+		
 		//console.log('#dialKnownID()')
 		const api = config.CONFIG_DELEGATED_API
 		const delegatedClient = createDelegatedRoutingV1HttpApiClient(api)
@@ -1200,10 +1437,43 @@ class webpeerjs{
 			}
 		}
 	}
-	
+
+
+	//dial based on known bootsrap peers address using Websocket expected
+	#dialKnownBootstrap(){
+		
+		if(!navigator.onLine)return
+		if(!this.#isDialEnabled)return
+
+		const bootstrap = config.CONFIG_KNOWN_BOOTSTRAP_PEERS_ADDRS
+		for(const peer of bootstrap){
+			const address = peer.Peers[0].Addrs
+			const id = peer.Peers[0].ID
+			let mddrs = []
+			let addrs = []
+			for(const addr of address){
+				if(!addr.includes('wss'))continue
+				const peeraddr = addr+'/p2p/'+id
+				const peermddr = multiaddr(peeraddr)
+				addrs.push(peeraddr)
+				mddrs.push(peermddr)
+			}
+			
+			this.#dialedKnownBootstrap.set(id,addrs)
+			this.#isDialWebsocket = true
+			if(!this.#isConnected(id)){
+				this.#dialMultiaddress(mddrs)
+			}
+			
+		}
+	}	
 	
 	//dial based on known bootstrap DNS
-	/*async #dialKnownDNS(){
+	async #dialKnownDNS(){
+
+		if(!navigator.onLine)return
+		if(!this.#isDialEnabled)return
+
 		const dnsresolver = config.CONFIG_DNS_RESOLVER
 		const bootstrapdns = config.CONFIG_KNOWN_BOOTSTRAP_DNS
 		const response = await fetch(dnsresolver+'?name='+bootstrapdns+'&type=txt')
@@ -1232,16 +1502,21 @@ class webpeerjs{
 			}
 			
 			this.#dialedKnownBootstrap.set(id,addrs)
+			this.#isDialWebsocket = true
 			if(!this.#isConnected(id)){
 				this.#dialMultiaddress(mddrs)
 			}
 		}
 		
-	}*/
+	}
 	
 	
 	//dial based on known bootstrap DNS using DNS resolver only
-	/*async #dialKnownDNSonly(){
+	async #dialKnownDNSonly(){
+
+		if(!navigator.onLine)return
+		if(!this.#isDialEnabled)return
+
 		const dnsresolver = config.CONFIG_DNS_RESOLVER
 		const bootstrapdns = config.CONFIG_KNOWN_BOOTSTRAP_DNS
 		const response = await fetch(dnsresolver+'?name='+bootstrapdns+'&type=txt')
@@ -1254,11 +1529,11 @@ class webpeerjs{
 			const dnsaddr = '_dnsaddr.'+arr[2]
 			this.#dialDNSWebsocketWebtransport(id,dnsaddr)
 		}
-	}*/
+	}
 	
 	
 	//dial DNS with webtransport and websocket
-	/*async #dialDNSWebsocketWebtransport(id,dnsaddr){
+	async #dialDNSWebsocketWebtransport(id,dnsaddr){
 		const dnsresolver = config.CONFIG_DNS_RESOLVER
 		const response = await fetch(dnsresolver+'?name='+dnsaddr+'&type=txt')
 		const json = await response.json()
@@ -1282,41 +1557,34 @@ class webpeerjs{
 			this.#dialMultiaddress(mddrs)
 			this.#dialWebsocket(mddrs)
 		}
-	}*/
+	}
 	
 	
 	//dial only webtransport multiaddrs
 	async #dialWebtransport(multiaddrs){
 			const webTransportMadrs = multiaddrs.filter((maddr) => maddr.protoNames().includes('webtransport')&&maddr.protoNames().includes('certhash'))
-			  for (const addr of webTransportMadrs) {
+			  for (const mddr of webTransportMadrs) {
 				try {
-				  //console.log(`attempting to dial webtransport multiaddr: %o`, addr.toString())
-				  await this.#libp2p.dial(addr)
+				  //console.log(`attempting to dial webtransport multiaddr: %o`, mddr.toString())
+				  await this.#libp2p.dial(mddr)
 				  return // if we succeed dialing the peer, no need to try another address
 				} catch (error) {
-				  //console.log(`failed to dial webtransport multiaddr: %o`, addr.toString())
+				  //console.log(`failed to dial webtransport multiaddr: %o`, mddr.toString())
 				  mkDebug(error)
 				}
 			  }
 	}
-
-	//dial only webtransport multiaddrs
-	/*#dialWebtransport1(multiaddrs){
-			const webTransportMadrs = multiaddrs.filter((maddr) => maddr.protoNames().includes('webtransport')&&maddr.protoNames().includes('certhash'))
-			if(webTransportMadrs.length == 0)return
-			this.#libp2p.dial(webTransportMadrs).then((data)=>{console.warn(data)},(data)=>{console.warn(data)})
-	}*/
 	
 	//dial only websocket multiaddrs
 	async #dialWebsocket(multiaddrs){
 			const webSocketMadrs = multiaddrs.filter((maddr) => maddr.protoNames().includes('wss'))
-			  for (const addr of webSocketMadrs) {
+			  for (const mddr of webSocketMadrs) {
 				try {
-				  //console.log(`attempting to dial websocket multiaddr: %o`, addr)
-				  await this.#libp2p.dial(addr)
+				  //console.log(`attempting to dial websocket multiaddr: %o`, mddr)
+				  await this.#libp2p.dial(mddr)
 				  return // if we succeed dialing the peer, no need to try another address
 				} catch (error) {
-				  //console.log(`failed to dial websocket multiaddr: %o`, addr)
+				  //console.log(`failed to dial websocket multiaddr: %o`, mddr)
 				  mkDebug(error)
 				}
 			  }
@@ -1357,7 +1625,8 @@ class webpeerjs{
 				],
 			},
 			transports:[
-				webTransport(),		
+				webTransport(),
+				webSockets(),
 				circuitRelayTransport({
 					discoverRelays: config.CONFIG_DISCOVER_RELAYS,
 					reservationConcurrency: 1,