webpeerjs 0.1.10 → 0.2.1

package/src/{webpeerjs.js → webpeer.js}

@@ -1,6 +1,6 @@
 //! WebPEER.js -- https://github.com/nuzulul/webpeerjs
 
-import * as config from  './config'
+import * as config from  './config.js'
 import { 
 	mkErr,
 	PBPeer,
@@ -16,8 +16,8 @@ import {
 	pipe,
 	lp,
 	map
-} from './utils'
-import { createDelegatedRoutingV1HttpApiClient } from '@helia/delegated-routing-v1-http-api-client'
+} from './utils.js'
+import { delegatedRoutingV1HttpApiClient } from '@helia/delegated-routing-v1-http-api-client'
 import { createLibp2p } from 'libp2p'
 import { IDBDatastore } from 'datastore-idb'
 import { webTransport } from '@libp2p/webtransport'
@@ -28,13 +28,18 @@ 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 { gossipsub } from '@libp2p/gossipsub'
 import { identify, identifyPush } from '@libp2p/identify'
 import { peerIdFromString } from '@libp2p/peer-id'
 import { kadDHT, removePrivateAddressesMapper } from '@libp2p/kad-dht'
 import { simpleMetrics } from '@libp2p/simple-metrics'
+import { ping } from '@libp2p/ping';
+import { defaultLogger } from '@libp2p/logger';
+import {createSignalingServer} from 'signalingserver.js';
 
-
+/**************************************************************************
+ * Main class
+ **************************************************************************/
 class webpeerjs{
 	
 	//libp2p instance
@@ -108,16 +113,13 @@ class webpeerjs{
 	//callback to websocket dialable
 	#onWebsocketFn
 	
-	//time tracker for sending message
-	#sendMessageTimeTracker
-	
 	id
 	status
 	IPFS
 	address
 	peers
 	
-	constructor(libp2p,dbstore,onMetrics,onWebsocketFn,onDialFn){
+	constructor(signalingserver,libp2p,dbstore,onMetrics,onWebsocketFn,onDialFn){
 		
 		this.#libp2p = libp2p
 		this.#dbstore = dbstore
@@ -127,7 +129,7 @@ class webpeerjs{
 		this.#webPeersId = []
 		this.#webPeersAddrs = new Map()
 		this.#dialedGoodPeers = new Map()
-		this.#isDialWebsocket = false
+		this.#isDialWebsocket = false;
 		this.#dialedKnownBootstrap = new Map()
 		//this.#dialedDiscoveredPeers = []
 		this.address = []
@@ -145,7 +147,6 @@ class webpeerjs{
 		this.#lastTimeReceiveData = new Date().getTime()
 		this.#onConnectQueue = []
 		this.#msgTimeTracker = new Map()
-		this.#sendMessageTimeTracker = 0
 		
 		this.peers = (function(f) {
 			return f
@@ -155,7 +156,7 @@ class webpeerjs{
 			return libp2p.status
 		})(this.#libp2p);
 		
-		this.status = 'unconnected'
+		this.status = 'disconnected'
 
 		this.IPFS = (function(libp2p,discoveredPeers) {
 			const obj = {libp2p,discoveredPeers}
@@ -170,9 +171,43 @@ class webpeerjs{
 
 		for(const topic of config.CONFIG_PUBSUB_PEER_DISCOVERY_HYBRID){
 			this.#libp2p.services.pubsub.subscribe(topic)
-		}		
+		}
+
+
+		/**************************************************************************
+		 * Signaling server
+		 **************************************************************************/
+		signalingserver.data((signal,signal_id)=>{
+			if(!this.#connections.has(signal.id)){
+				let mddrs = []
+				for(const addr of signal.address){
+					if(!addr.includes('webrtc'))continue
+					const mddr = multiaddr(addr)
+					mddrs.push(mddr)
+				}
+				this.#dialMultiaddress(mddrs)
+			}
+		})	
+
+		const broadcast = {
+			id : this.id,
+			address : this.address
+		}			
+		signalingserver.send(broadcast);		
+
+		setInterval(()=>{
+			const broadcast = {
+				id : this.id,
+				address : this.address
+			}			
+			signalingserver.send(broadcast);
+		},15*1000)		
+		
 		
-		//listen to peer connect event
+		
+		/**************************************************************************
+		 * Listen on incoming connection
+		 **************************************************************************/
 		this.#libp2p.addEventListener("peer:connect",async (evt) => {
 			
 			//const connection = evt.detail;
@@ -240,7 +275,10 @@ class webpeerjs{
 		});
 
 
-		//listen message from subscribed pupsub topic
+
+		/**************************************************************************
+		 * Listen message from subscribed pupsub topic
+		 **************************************************************************/		
 		this.#libp2p.services.pubsub.addEventListener('message', event => {
 			
 			//console.log('on:'+event.detail.topic,event.detail.data)
@@ -410,13 +448,14 @@ class webpeerjs{
 
 									//inbound message
 									//use #msgIdtracker to prevent double message
-									//use #msgTimeTracker to limit inbound message 1msg/s
+									//use #msgTimeTracker to limit inbound message count /s
 									if(message){
 										const msgID = msgId+id
 										let oldmsgtime = 0
 										let newmsgtime = new Date().getTime()
 										if(this.#msgTimeTracker.has(id))oldmsgtime = this.#msgTimeTracker.get(id)
-										const msgtimelimit = 1000
+										//const msgtimelimit = 1000
+										const msgtimelimit = -1
 										if(!this.#msgIdtracker.has(msgID) && newmsgtime-oldmsgtime>msgtimelimit){
 											this.#msgIdtracker.set(msgID,newmsgtime)
 											this.#msgTimeTracker.set(id,newmsgtime)
@@ -484,7 +523,10 @@ class webpeerjs{
 		})
 		
 		
-		//listen to peer discovery event
+
+		/**************************************************************************
+		 * Listen to peer discovery event
+		 **************************************************************************/		
 		this.#libp2p.addEventListener('peer:discovery', (evt) => {
 
 			//console.log('Discovered:', evt.detail.id.toString())
@@ -535,7 +577,10 @@ class webpeerjs{
 		})
 
 		
-		//listen to peer disconnect event
+		
+		/**************************************************************************
+		 * Listen to peer disconnect event
+		 **************************************************************************/		
 		this.#libp2p.addEventListener("peer:disconnect",async (evt) => {
 			
 			//const connection = evt.detail;
@@ -610,10 +655,16 @@ class webpeerjs{
 		});
 		
 		
-		//listen to self peer update
+
+		/**************************************************************************
+		 * Listen to listen address change
+		 **************************************************************************/		
 		this.#libp2p.addEventListener('self:peer:update', ({ detail: { peer } }) => {
+			
+			//console.log('peer',peer)
 			//const multiaddrs = peer.addresses.map(({ multiaddr }) => multiaddr)
 			//console.log(`changed multiaddrs: peer ${peer.id.toString()} multiaddrs: ${multiaddrs}`)
+			
 			const id = peer.id.toString()
 			const addrs = []
 			peer.addresses.forEach((address)=>{
@@ -627,8 +678,22 @@ class webpeerjs{
 			this.address = addrs
 			this.#ping()
 			this.#peerDiscoveryHybrid()
+			if(addrs.length > 0){
+				const broadcast = {
+					id : this.id,
+					address : this.address
+				}			
+				signalingserver.send(broadcast);				
+				this.status = 'connected'
+			}else{
+				this.status = 'disconnected'
+			}
 		})
 		
+		
+		/**************************************************************************
+		 * Listen on identity service
+		 **************************************************************************/		
 		this.#libp2p.addEventListener('peer:identify', async (evt) => {
 			//console.log('peer:identify '+evt.detail.peerId.toString(),evt.detail)
 			
@@ -672,10 +737,9 @@ class webpeerjs{
 					//reset this last seen
 					const now = new Date().getTime()
 					const metadata = {addrs:address,last:now}
-					this.#connectedPeers.set(id,metadata)
+					this.#connectedPeers.set(id,metadata);
 				}
 				
-				
 				const command = 'peer-exchange'
 				this.#dialProtocol(id,command)
 				
@@ -757,8 +821,10 @@ class webpeerjs{
 		},30e3)*/
 		
 	}
-
-
+	
+	//this.#getAddress = (function(address) {
+		///return this.address
+	//})(this.address);	
 
 
 	/*
@@ -776,17 +842,17 @@ class webpeerjs{
 
 	joinRoom = room => {
 		if (this.#rooms[room]) {
-			return [
-				this.#rooms[room].sendMessage,
-				this.#rooms[room].listenMessage,
-				this.#rooms[room].onMembersChange
-			]
+			return {
+				sendMessage : this.#rooms[room].sendMessage,
+				onMessage : this.#rooms[room].listenMessage,
+				onMembersChange : this.#rooms[room].onMembersChange
+		}
 			
 
 		}
 
 		if (!room) {
-			throw mkErr('room is required')
+			throw mkErr('Room name is required')
 		}
 		
 		//join room version 1 user pupsub via pupsub peer discovery
@@ -805,17 +871,12 @@ class webpeerjs{
 				onMessage : () => {},
 				listenMessage : f => (this.#rooms[room] = {...this.#rooms[room], onMessage: f}),
 				sendMessage : async (message) => {
-					const now = (new Date()).getTime()
-					if(now-this.#sendMessageTimeTracker < 1000){
-						throw mkErr('can not send more than 1 message/s')
-					}
-					this.#sendMessageTimeTracker = now
-					const msgId = (new Date()).getTime()
+					const msgId = crypto.randomUUID();
 					const data = JSON.stringify({prefix:config.CONFIG_PREFIX,room,message,id:this.#libp2p.peerId.toString(),msgId})
 					const arr = uint8ArrayFromString(data)
 					const sizelimit = config.CONFIG_MESSAGE_SIZE_LIMIT
 					if(arr.byteLength > sizelimit){
-						throw mkErr('message too large')
+						throw mkErr(`Only message less than ${sizelimit} byte allowed`);
 					}
 					const peer = {
 					  publicKey: this.#libp2p.peerId.publicKey,
@@ -832,11 +893,11 @@ class webpeerjs{
 			}
 		}
 		
-		return [
-			this.#rooms[room].sendMessage,
-			this.#rooms[room].listenMessage,
-			this.#rooms[room].onMembersChange
-		]
+		return {
+			sendMessage : this.#rooms[room].sendMessage,
+			onMessage : this.#rooms[room].listenMessage,
+			onMembersChange : this.#rooms[room].onMembersChange
+		}
 	}
 	
 	dial(addr){
@@ -922,18 +983,20 @@ class webpeerjs{
 			const item = {id:peer[0],address:peer[1].addrs}
 			this.#connectedPeersArr.push(item)
 		}
-		if(this.#connectedPeers.size > 0){
-			this.status = 'connected'
-		}
-		else{
-			this.status = 'unconnected'
-		}
 		this.#ping()
 	}
-	
+
+
+
+	/**************************************************************************
+	 * Handle custom protocol
+	 **************************************************************************/	
 	async #registerProtocol(){
 		
 		const handler = async ({ connection, stream }) => {
+			
+			//console.log('onprotocol',connection);
+			
 			try{
 				const output = await pipe(
 					stream.source,
@@ -1021,7 +1084,7 @@ class webpeerjs{
 		await this.#libp2p.handle(config.CONFIG_PROTOCOL, handler, {
 		  maxInboundStreams: 100,
 		  maxOutboundStreams: 100,
-		  runOnTransientConnection:config.CONFIG_RUN_ON_TRANSIENT_CONNECTION
+		  runOnLimitedConnection:config.CONFIG_RUN_ON_TRANSIENT_CONNECTION
 		})
 
 		await this.#libp2p.register(config.CONFIG_PROTOCOL, {
@@ -1036,7 +1099,11 @@ class webpeerjs{
 		})
 
 	}
-	
+
+
+	/**************************************************************************
+	 * Dial custom protocol
+	 **************************************************************************/		
 	async #dialProtocol(id,command){
 
 		const connections = this.#libp2p.getConnections().map((con)=>{return {id:con.remotePeer.toString(),addr:con.remoteAddr.toString()}})
@@ -1068,7 +1135,7 @@ class webpeerjs{
 
 		try{
 			
-			const stream = await this.#libp2p.dialProtocol(mddr, config.CONFIG_PROTOCOL,{runOnTransientConnection:config.CONFIG_RUN_ON_TRANSIENT_CONNECTION})
+			const stream = await this.#libp2p.dialProtocol(mddr, config.CONFIG_PROTOCOL,{runOnLimitedConnection:config.CONFIG_RUN_ON_TRANSIENT_CONNECTION})
 			
 			const output = await pipe(
 				message,
@@ -1127,42 +1194,6 @@ class webpeerjs{
 		}
 	}
 	
-	async #findHybridPeer(){
-
-		if(!navigator.onLine)return
-		if(!this.#isDialEnabled)return
-		if(this.#connectedPeers.size > 5)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)
-						}
-					}
-				}
-			}
-		}
-	}
-	
 	
 	//check the last seen in web peer
 	#trackLastSeen(){
@@ -1597,6 +1628,45 @@ class webpeerjs{
 		},5000)
 	}
 	
+	async #findHybridPeer(){
+		
+		this.#dialKnownID();
+		return;
+
+		if(!navigator.onLine)return
+		if(!this.#isDialEnabled)return
+		if(this.#connectedPeers.size > 5)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)
+						}
+					}
+				}
+			}
+		}
+	} 	
+	
 	async #dialSavedKnownID(){
 
 		if(!navigator.onLine)return
@@ -1622,7 +1692,7 @@ class webpeerjs{
 		if(firsttime){
 			for(const target of config.CONFIG_KNOWN_BOOTSTRAP_PEERS_IDS){
 				const api = config.CONFIG_DELEGATED_API
-				const delegatedClient = createDelegatedRoutingV1HttpApiClient(api)
+				const delegatedClient = delegatedRoutingV1HttpApiClient({url:api})({logger: defaultLogger()})
 				const peer = await first(delegatedClient.getPeers(peerIdFromString(target)))
 				if(!peer)continue
 				const address = peer.Addrs
@@ -1657,7 +1727,7 @@ class webpeerjs{
 			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 delegatedClient = delegatedRoutingV1HttpApiClient({url:api})({logger: defaultLogger()})
 				const peer = await first(delegatedClient.getPeers(peerIdFromString(target)))
 				if(!peer){
 					if (navigator.onLine) {
@@ -1693,7 +1763,7 @@ class webpeerjs{
 		
 		//console.log('#dialKnownID()')
 		const api = config.CONFIG_DELEGATED_API
-		const delegatedClient = createDelegatedRoutingV1HttpApiClient(api)
+		const delegatedClient = delegatedRoutingV1HttpApiClient({url:api})({logger: defaultLogger()})
 		const BOOTSTRAP_PEER_IDS = config.CONFIG_KNOWN_BOOTSTRAP_PEERS_IDS
 		const peers = await Promise.all(
 			BOOTSTRAP_PEER_IDS.map((peerId) => first(delegatedClient.getPeers(peerIdFromString(peerId)))),
@@ -1766,7 +1836,7 @@ class webpeerjs{
 			BOOTSTRAP_PEER_IDS.push(id)
 		}
 		const api = config.CONFIG_DELEGATED_API
-		const delegatedClient = createDelegatedRoutingV1HttpApiClient(api)
+		const delegatedClient = delegatedRoutingV1HttpApiClient({url:api})({logger: defaultLogger()})
 		const peers = await Promise.all(
 			BOOTSTRAP_PEER_IDS.map((peerId) => first(delegatedClient.getPeers(peerIdFromString(peerId)))),
 		)
@@ -1845,7 +1915,7 @@ class webpeerjs{
 	
 	//dial only webtransport multiaddrs
 	async #dialWebtransport(multiaddrs){
-			const webTransportMadrs = multiaddrs.filter((maddr) => maddr.protoNames().includes('webtransport')&&maddr.protoNames().includes('certhash'))
+			const webTransportMadrs = multiaddrs.filter((maddr) => maddr.toString().includes('webtransport')&&maddr.toString().includes('certhash'))
 			  for (const mddr of webTransportMadrs) {
 				try {
 				  //console.log(`attempting to dial webtransport multiaddr: %o`, mddr.toString())
@@ -1860,7 +1930,7 @@ class webpeerjs{
 	
 	//dial only websocket multiaddrs
 	async #dialWebsocket(multiaddrs){
-			const webSocketMadrs = multiaddrs.filter((maddr) => maddr.protoNames().includes('wss'))
+			const webSocketMadrs = multiaddrs.filter((maddr) => maddr.toString().includes('wss'))
 			  for (const mddr of webSocketMadrs) {
 				try {
 				  //console.log(`attempting to dial websocket multiaddr: %o`, mddr)
@@ -1872,293 +1942,183 @@ class webpeerjs{
 				}
 			  }
 	}
-	
-	
-	//entry point to webpeerjs
-	static async createWebpeer(){
-
-		// all libp2p debug logs
-		//localStorage.setItem('debug', 'libp2p:*')
-		
-		const dbstore = new IDBDatastore(config.CONFIG_DBSTORE_PATH)
-		await dbstore.open()
-		
-		const bootstrapAddrs = []
-		
-		//let addrs = []
-		const getbootstrap = config.CONFIG_KNOWN_BOOTSTRAP_PEERS_ADDRS
-		for(const peer of getbootstrap){
-			const addrs = peer.Peers[0].Addrs
-			const id = peer.Peers[0].ID
-			//let mddrs = []
-			for(const addr of addrs){
-				if(addr.includes('webtransport')&&addr.includes('certhash')){
-					bootstrapAddrs.push(addr+'/p2p/'+id)
-				}
-			}
-		}
-
-		let onMetricsFn = () => {}
-		const onMetrics = f => (onMetricsFn = f)
-
-		let isWebsocket = false
-		let onWebsocketFn = () => {}
-		const onWebsocket = f => (onWebsocketFn = f)
-		onWebsocket((data)=>{
-			isWebsocket = data
-		})
-		
-		let isDial = true
-		let onDialFn = () => {}
-		const onDial = f => (onDialFn = f)
-		onDial((data)=>{
-			//if(isDial!=data)console.warn('isDial',data)
-			isDial = data
-		})
-		
-		let listenaddress = []
-		
-		if(config.CONFIG_RUN_ON_TRANSIENT_CONNECTION == false){
-			listenaddress.push('/webrtc')
-		}
-		
-		const stunurls = config.CONFIG_WEBRTC_STUN_URLS
-		const stunurlsbackup = config.CONFIG_WEBRTC_STUN_URLS_BACKUP
-		
-		const turnurls = atob(config.CONFIG_WEBRTC_TURN_HOST)
-		const turnusername = atob(config.CONFIG_WEBRTC_TURN_USER)
-		const turncredential = atob(config.CONFIG_WEBRTC_TURN_PWD)
-
-		const turnurlsbackup = atob(config.CONFIG_WEBRTC_TURN_HOST_BACKUP)
-		const turnusernamebackup = atob(config.CONFIG_WEBRTC_TURN_USER_BACKUP)
-		const turncredentialbackup = atob(config.CONFIG_WEBRTC_TURN_PWD_BACKUP)
-		
-		async function checkice(stunurls,turnurls,turnusername,turncredential,time){
-			return new Promise((resolve)=>{
-				
-				let stun = false
-				let turn = false
-				
-				const timeout = setTimeout(()=>{
-					let ice = []
-					ice.push(stun)
-					ice.push(turn)
-					resolve(ice)
-				},time)
-				
-				function check(){
-					if(stun && turn){
-						let ice = []
-						ice.push(stun)
-						ice.push(turn)
-						clearTimeout(timeout)
-						resolve(ice)
-					}
-				}
-				
-				//test ice servers
-				
-				const iceServers = [
-					{
-						urls: stunurls
-					},
-					{
-						urls: turnurls, 
-						username: turnusername, 
-						credential: turncredential
-					}
-				];
 
-				const pc = new RTCPeerConnection({
-					iceServers
-				});
-
-				pc.onicecandidate = (e) => {
-					if (!e.candidate) return;
+}
 
-					//console.log(e.candidate.candidate);
 
-					// stun works
-					if(e.candidate.type == "srflx"){
-						//console.log('publicip',e.candidate.address);
-						stun = 	{
-									urls: stunurls
-								}
-						check()
-					}
-
-					// turn works
-					if(e.candidate.type == "relay"){
-						turn =  {
-									urls: turnurls, 
-									username: turnusername, 
-									credential: turncredential
-								}
-						check()
-					}
-				};
+/**************************************************************************
+ * Entry point to create a new peer
+ **************************************************************************/
+const createWebPEER = async (configuration) => {
 
-				pc.onicecandidateerror = (e) => {
-					console.debug(e);
-				};
-
-				pc.createDataChannel('webpeerjs');
-				pc.createOffer().then(offer => pc.setLocalDescription(offer));
-			})
-		}
-		
-		let ice = []
-		
-		let configuration = {}
-		
-		if(arguments.length > 0){
-			configuration = arguments[0]
+	// all libp2p debug logs
+	if(config.CONFIG_DEBUG_ENABLED){
+		localStorage.setItem('debug', 'libp2p:*');
+	}
+	
+	let signalconfig = {};
+	if(configuration && configuration.networkName){
+		signalconfig['appid'] = configuration.networkName;
+	}else{
+		signalconfig['appid'] = config.CONFIG_PREFIX;
+	}
+	
+	const signalingserver = createSignalingServer(signalconfig);
+	
+	const dbstore = new IDBDatastore(config.CONFIG_DBSTORE_PATH)
+	await dbstore.open()
+	
+	const bootstrapAddrs = []
+	
+	//let addrs = []
+	const getbootstrap = config.CONFIG_KNOWN_BOOTSTRAP_PEERS_ADDRS
+	for(const peer of getbootstrap){
+		const addrs = peer.Peers[0].Addrs
+		const id = peer.Peers[0].ID
+		//let mddrs = []
+		for(const addr of addrs){
+			if(addr.includes('webtransport')&&addr.includes('certhash')){
+				bootstrapAddrs.push(addr+'/p2p/'+id)
+			}
 		}
-		
-		//set rtc configuration
-		if(configuration.rtcConfiguration === undefined){
-			
-			ice = await checkice(stunurls,turnurls,turnusername,turncredential,5000)
+	}
 
-			//console.log(ice)
-			
-			//recheck ice
-			if(!ice[0] && !ice[1]){
-				ice = await checkice(stunurlsbackup,turnurlsbackup,turnusernamebackup,turncredentialbackup,5000)
-			}else if (ice[0] && !ice[1]){
-				ice = await checkice(stunurls,turnurlsbackup,turnusernamebackup,turncredentialbackup,5000)
-			}else if (!ice[0] && ice[1]){
-				ice = await checkice(stunurlsbackup,turnurls,turnusername,turncredential,5000)
-			}
-			
-			//console.log(ice)
-			
-			//final ice remove false value
-			ice.forEach(function(value, index) {
-			  if(!value){
-				  this.splice(index, 1)
-			  }
-			}, ice);
-			
-			//console.log(ice)
+	let onMetricsFn = () => {}
+	const onMetrics = f => (onMetricsFn = f)
+
+	let isWebsocket = false
+	let onWebsocketFn = () => {}
+	const onWebsocket = f => (onWebsocketFn = f)
+	onWebsocket((data)=>{
+		isWebsocket = data
+	})
+	
+	let isDial = true
+	let onDialFn = () => {}
+	const onDial = f => (onDialFn = f)
+	onDial((data)=>{
+		//if(isDial!=data)console.warn('isDial',data)
+		isDial = data
+	})
+	
+	let listenaddress = ['/p2p-circuit']
+	
+	if(config.CONFIG_RUN_ON_TRANSIENT_CONNECTION == false){
+		listenaddress.push('/webrtc')
+	}
+	
+	let webrtcconfig = {}
 			
-			configuration.rtcConfiguration = {
-				iceServers: ice,
-			}
-		}
-		
-		
-		//create libp2p instance
-		const libp2p = await createLibp2p({
-			addresses: {
-				listen: listenaddress,
-			},
-			transports:[
-				webTransport(),
-				webSockets(),
-				webRTC({
-					rtcConfiguration: configuration.rtcConfiguration,
-				}),
-				circuitRelayTransport({
-					discoverRelays: config.CONFIG_DISCOVER_RELAYS,
-					reservationConcurrency: 1,
-					maxReservationQueueLength: 3
-				}),
-			],
-			connectionManager: {
-				maxConnections: config.CONFIG_MAX_CONNECTIONS,
-				minConnections: config.CONFIG_MIN_CONNECTIONS,
-				autoDialInterval:60e3,
-				autoDialConcurrency:0,
-				autoDialMaxQueueLength:0,
-				autoDialPriority:1000,
-				autoDialDiscoveredPeersDebounce:60e3,
-				maxParallelDials: 3,
-				dialTimeout: 5e3,
-				maxIncomingPendingConnections: 5,
-				maxDialQueueLength:10,
-				inboundConnectionThreshold:3,
-				maxPeerAddrsToDial:2,
-				inboundUpgradeTimeout:5e3
-			},
-			connectionEncryption: [noise()],
-			streamMuxers: [
-				yamux({
-					maxInboundStreams: 100,
-					maxOutboundStreams: 100,
-				})
-			],
-			connectionGater: {
-				filterMultiaddrForPeer: async (peer, multiaddrTest) => {
-					const multiaddrString = multiaddrTest.toString()
-					if (
-						multiaddrString.includes("/ip4/127.0.0.1") ||
-						multiaddrString.includes("/ip6/")
-					) {
-						return false
-					}
-					if(multiaddrString.includes("/ws/") || multiaddrString.includes("/wss/"))return isWebsocket
-					return isDial
-				},
-				denyDialMultiaddr: async (multiaddrTest) => {
-					const multiaddrString = multiaddrTest.toString()
-					if (
-						multiaddrString.includes("/ip4/127.0.0.1") ||
-						multiaddrString.includes("/ip6/")
-					) {
-						return true
-					}
-					if(multiaddrString.includes("/ws/") || multiaddrString.includes("/wss/"))return !isWebsocket
-					return !isDial
-				},
-			},
-			peerDiscovery: [
-				pubsubPeerDiscovery({
-					interval: 5_000,
-					topics: config.CONFIG_PUBSUB_PEER_DISCOVERY_WEBPEER,
-					listenOnly: false,
-				}),
-				
-			],
-			services: {
-				pubsub: gossipsub({
-					allowPublishToZeroTopicPeers: true,
-					msgIdFn: msgIdFnStrictNoSign,
-					ignoreDuplicatePublishError: true,
-					runOnTransientConnection:config.CONFIG_RUN_ON_TRANSIENT_CONNECTION,
-				}),
-				identify: identify(),
-				identifyPush: identifyPush(),
-				aminoDHT: kadDHT({
-					protocol: '/ipfs/kad/1.0.0',
-					peerInfoMapper: removePrivateAddressesMapper,
-					clientMode: false
-				}),
-				dcutr: dcutr()
+	if(configuration && configuration.rtcConfiguration){
+		webrtcconfig[rtcConfiguration] = configuration.rtcConfiguration
+	}
+	
+	
+	//create libp2p instance
+	const libp2p = await createLibp2p({
+		addresses: {
+			listen: listenaddress,
+		},
+		transports:[
+			webTransport(),
+			webSockets(),
+			webRTC(webrtcconfig),
+			circuitRelayTransport({
+				reservationConcurrency: config.CONFIG_DISCOVER_RELAYS
+			}),
+		],
+		connectionManager: {
+			maxConnections: config.CONFIG_MAX_CONNECTIONS,
+			minConnections: config.CONFIG_MIN_CONNECTIONS,
+			autoDialInterval:60e3,
+			autoDialConcurrency:0,
+			autoDialMaxQueueLength:0,
+			autoDialPriority:1000,
+			autoDialDiscoveredPeersDebounce:60e3,
+			maxParallelDials: 3,
+			dialTimeout: 5e3,
+			maxIncomingPendingConnections: 5,
+			maxDialQueueLength:10,
+			inboundConnectionThreshold:3,
+			maxPeerAddrsToDial:2,
+			inboundUpgradeTimeout:5e3
+		},
+		connectionEncrypters: [noise()],
+		streamMuxers: [
+			yamux({
+				maxInboundStreams: 100,
+				maxOutboundStreams: 100,
+			})
+		],
+		connectionGater: {
+			filterMultiaddrForPeer: async (peer, multiaddrTest) => {
+				const multiaddrString = multiaddrTest.toString()
+				if (
+					multiaddrString.includes("/ip4/127.0.0.1") ||
+					multiaddrString.includes("/ip6/")
+				) {
+					return false
+				}
+				if(multiaddrString.includes("/ws/") || multiaddrString.includes("/wss/"))return isWebsocket
+				return isDial
 			},
-			peerStore: {
-				persistence: true,
-				threshold: 1
+			denyDialMultiaddr: async (multiaddrTest) => {
+				const multiaddrString = multiaddrTest.toString()
+				if (
+					multiaddrString.includes("/ip4/127.0.0.1") ||
+					multiaddrString.includes("/ip6/")
+				) {
+					return true
+				}
+				if(multiaddrString.includes("/ws/") || multiaddrString.includes("/wss/"))return !isWebsocket
+				return !isDial
 			},
-			metrics: simpleMetrics({
-				onMetrics: (metrics) => {onMetricsFn(metrics)},
-				intervalMs: 1000
-			})
+		},
+		peerDiscovery: [
+			pubsubPeerDiscovery({
+				interval: 5_000,
+				topics: config.CONFIG_PUBSUB_PEER_DISCOVERY_WEBPEER,
+				listenOnly: false,
+			}),
+			
+		],
+		services: {
+			pubsub: gossipsub({
+				allowPublishToZeroTopicPeers: true,
+				msgIdFn: msgIdFnStrictNoSign,
+				ignoreDuplicatePublishError: true,
+				runOnLimitedConnection:config.CONFIG_RUN_ON_TRANSIENT_CONNECTION,
+			}),
+			identify: identify(),
+			ping: ping(),
+			identifyPush: identifyPush(),
+			aminoDHT: kadDHT({
+				protocol: '/ipfs/kad/1.0.0',
+				peerInfoMapper: removePrivateAddressesMapper,
+				clientMode: false
+			}),
+			dcutr: dcutr()
+		},
+		peerStore: {
+			persistence: true,
+			threshold: 1
+		},
+		metrics: simpleMetrics({
+			onMetrics: (metrics) => {onMetricsFn(metrics)},
+			intervalMs: 1000
 		})
-		
-		
-		
-		//console.log(`Node started with id ${libp2p.peerId.toString()}`)
+	})
+	
+	//console.log(`Node started with id ${libp2p.peerId.toString()}`)
 
-		//DHT server mode act as bootstrap peer in IPFS network
-		await libp2p.services.aminoDHT.setMode("server")
-		
-		
-		//return webpeerjs class
-		return new webpeerjs(libp2p,dbstore,onMetrics,onWebsocketFn,onDialFn)
-	}
+	//DHT server mode act as bootstrap peer in IPFS network
+	await libp2p.services.aminoDHT.setMode("server")
+	
+	
+	//return webpeerjs class
+	return new webpeerjs(signalingserver,libp2p,dbstore,onMetrics,onWebsocketFn,onDialFn)
 }
 
 
 //export module
-export {webpeerjs}
+export {createWebPEER}