webpeerjs 0.0.1

package/dist/esm/webpeerjs.js

@@ -0,0 +1,1600 @@
+import { Peer } from '#/pubsub-peer-discovery/peer.js';
+import { Key } from 'interface-datastore';
+import { sha256 } from 'multiformats/hashes/sha2';
+import { createLibp2p } from 'libp2p';
+import { IDBDatastore } from 'datastore-idb';
+import { webTransport } from '@libp2p/webtransport';
+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 { kadDHT, removePrivateAddressesMapper } from '@libp2p/kad-dht';
+import { simpleMetrics } from '@libp2p/simple-metrics';
+
+const prefix$1 = 'webpeerjs';
+const CONFIG_PREFIX = prefix$1;
+const CONFIG_DBSTORE_PATH = prefix$1+'-dbstore';
+const CONFIG_MAX_CONNECTIONS = 50;
+const CONFIG_MIN_CONNECTIONS = 0;
+const CONFIG_DISCOVER_RELAYS = 2;
+const CONFIG_PEER_DISCOVERY_UNIVERSAL_CONNECTIVITY = 'universal-connectivity-browser-peer-discovery';
+const CONFIG_PUBSUB_PEER_DISCOVERY = ['_peer-discovery._p2p._pubsub',CONFIG_PEER_DISCOVERY_UNIVERSAL_CONNECTIVITY,prefix$1+'-peer-discovery'];
+
+const CONFIG_KNOWN_BOOTSTRAP_PEERS_ADDRS = [
+	{
+	  "Peers": [
+		{
+		  "Addrs": [
+			"/ip4/147.28.186.157/udp/9091/quic-v1",
+			"/ip4/147.28.186.157/udp/9090/webrtc-direct/certhash/uEiBbC9bbdvraVWDvcvCEdJAWDymmUqiJQ964FuyEq0hELw"
+		  ],
+		  "ID": "12D3KooWGahRw3ZnM4gAyd9FK75v4Bp5keFYTvkcAwhpEm28wbV3",
+		  "Schema": "peer"
+		}
+	  ]
+	},
+	{
+	  "Peers": [
+		{
+		  "Addrs": [
+			"/ip6/2604:1380:4642:6600::3/udp/9095/quic-v1/webtransport/certhash/uEiCU6MjDlUhqtik_vc8Ps5_MJtGhJKn-XSqvuzn8SJGL9A/certhash/uEiDlk15VyYoXwTaB608Y80ch3OptpMiKFblYdduSVLy2sQ",
+			"/ip4/147.28.186.157/udp/9095/quic-v1",
+			"/ip6/2604:1380:4642:6600::3/udp/9095/quic-v1",
+			"/ip4/147.28.186.157/udp/9095/quic-v1/webtransport/certhash/uEiCU6MjDlUhqtik_vc8Ps5_MJtGhJKn-XSqvuzn8SJGL9A/certhash/uEiDlk15VyYoXwTaB608Y80ch3OptpMiKFblYdduSVLy2sQ"
+		  ],
+		  "ID": "12D3KooWFhXabKDwALpzqMbto94sB7rvmZ6M28hs9Y9xSopDKwQr",
+		  "Schema": "peer"
+		}
+	  ]
+	},
+	{
+		"Peers": [
+			{
+				"Addrs": [
+					"/ip6/2607:f2f8:a880:0:5054:ff:fe9f:4913/udp/4001/quic-v1/webtransport/certhash/uEiD84ZvAnGWTQx_WlOAqreebO036a5RRB5zfJBo9QJfDBA/certhash/uEiAOMkIVxeNye76-f5ADnLCSNqNlnhOYdkwyRlqLFbhIkQ",
+					"/ip6/2607:f2f8:a880::70/udp/4001/quic-v1/webtransport/certhash/uEiD84ZvAnGWTQx_WlOAqreebO036a5RRB5zfJBo9QJfDBA/certhash/uEiAOMkIVxeNye76-f5ADnLCSNqNlnhOYdkwyRlqLFbhIkQ",
+					"/ip6/2607:f2f8:a880:0:5054:ff:fe9f:4913/tcp/4001",
+					"/ip6/2607:f2f8:a880:0:5054:ff:fe9f:4913/udp/4001/quic-v1",
+					"/ip4/174.136.97.180/udp/4001/quic-v1/webtransport/certhash/uEiD84ZvAnGWTQx_WlOAqreebO036a5RRB5zfJBo9QJfDBA/certhash/uEiAOMkIVxeNye76-f5ADnLCSNqNlnhOYdkwyRlqLFbhIkQ",
+					"/ip4/174.136.97.180/udp/4001/quic-v1",
+					"/ip6/2607:f2f8:a880::70/udp/4001/quic-v1",
+					"/ip4/174.136.97.180/tcp/4001"
+				],
+				"ID": "12D3KooWPEDBmt7vm6FNNYuqaA4n2qMUZ6wPK5NcRc8t6KpqgRkV",
+				"Schema": "peer"
+			}
+		]
+	},
+	{
+		"Peers": [
+			{
+				"Addrs": [
+					"/ip4/174.136.97.179/udp/4001/quic-v1",
+					"/ip6/2607:f2f8:a880::50/udp/4002/quic-v1/webtransport/certhash/uEiBF7KOka9hhb2IjhUd-OkfgTFOf-VpgV7fwvMkKOkMrdQ/certhash/uEiDxVhDwzFlnorujU_rjTnO_TTLRMlXxzPLEgaG-1xOPkA",
+					"/ip4/174.136.97.179/udp/4001/quic-v1/webtransport/certhash/uEiBF7KOka9hhb2IjhUd-OkfgTFOf-VpgV7fwvMkKOkMrdQ/certhash/uEiDxVhDwzFlnorujU_rjTnO_TTLRMlXxzPLEgaG-1xOPkA",
+					"/ip6/2607:f2f8:a880::50/udp/4001/quic-v1",
+					"/ip4/174.136.97.179/udp/4002/quic-v1/webtransport/certhash/uEiBF7KOka9hhb2IjhUd-OkfgTFOf-VpgV7fwvMkKOkMrdQ/certhash/uEiDxVhDwzFlnorujU_rjTnO_TTLRMlXxzPLEgaG-1xOPkA",
+					"/ip6/2607:f2f8:a880::50/tcp/4001",
+					"/ip6/2607:f2f8:a880::50/udp/4001/quic-v1/webtransport/certhash/uEiBF7KOka9hhb2IjhUd-OkfgTFOf-VpgV7fwvMkKOkMrdQ/certhash/uEiDxVhDwzFlnorujU_rjTnO_TTLRMlXxzPLEgaG-1xOPkA",
+					"/ip4/174.136.97.179/tcp/4001"
+				],
+				"ID": "12D3KooWSHbugDEQeWm2LjtRRMpNgLu6oZ8zkX8XcTwYMAewVekP",
+				"Schema": "peer"
+			}
+		]
+	},
+	{
+		"Peers": [
+			{
+				"Addrs": [
+					"/ip6/2a03:4000:46:26e::c17/udp/443/quic-v1/webtransport/certhash/uEiAortGu7HNi8-pV9onPFkTwykrnWuJEqYf7zbQVE1FEtg/certhash/uEiB5Z8j3pdTJU_TDYoJ-GgUQSaXOmvKIGmASL9s-p3VHQA",
+					"/ip4/45.83.104.156/udp/443/quic-v1",
+					"/ip4/45.83.104.156/udp/443/quic-v1/webtransport/certhash/uEiAortGu7HNi8-pV9onPFkTwykrnWuJEqYf7zbQVE1FEtg/certhash/uEiB5Z8j3pdTJU_TDYoJ-GgUQSaXOmvKIGmASL9s-p3VHQA",
+					"/ip6/2a03:4000:46:26e::c17/tcp/443",
+					"/ip6/2a03:4000:46:26e::c17/udp/443/quic-v1",
+					"/ip4/45.83.104.156/tcp/443"
+				],
+				"ID": "12D3KooWASoxFpwwy8JDdu4Tm57mhESsnbFPogam9VVmhR95FGXr",
+				"Schema": "peer"
+			}
+		]
+	},
+	{
+	  "Peers": [
+		{
+		  "Addrs": [
+			"/ip4/139.178.91.71/udp/4001/quic-v1",
+			"/ip6/2604:1380:45e3:6e00::1/tcp/4001",
+			"/ip4/139.178.91.71/tcp/4001",
+			"/ip4/139.178.91.71/udp/4001/quic-v1/webtransport/certhash/uEiDYGZMqjz8wsz59DHA4iJin4nqTUfuJhq9AeAZlHBrmvg/certhash/uEiBXLv0dkEqbhmcinRbwj8b_3vWs0kWwf1-fiaz5wS-tew",
+			"/ip6/2604:1380:45e3:6e00::1/udp/4001/quic-v1/webtransport/certhash/uEiDYGZMqjz8wsz59DHA4iJin4nqTUfuJhq9AeAZlHBrmvg/certhash/uEiBXLv0dkEqbhmcinRbwj8b_3vWs0kWwf1-fiaz5wS-tew",
+			"/dnsaddr/bootstrap.libp2p.io",
+			"/dns6/sv15.bootstrap.libp2p.io/tcp/443/wss",
+			"/ip6/2604:1380:45e3:6e00::1/udp/4001/quic-v1",
+			"/ip4/139.178.91.71/tcp/443/tls/sni/sv15.bootstrap.libp2p.io/ws",
+			"/ip6/2604:1380:45e3:6e00::1/tcp/443/tls/sni/sv15.bootstrap.libp2p.io/ws",
+			"/dns4/sv15.bootstrap.libp2p.io/tcp/443/wss"
+		  ],
+		  "ID": "QmNnooDu7bfjPFoTZYxMNLWUQJyrVwtbZg5gBMjTezGAJN",
+		  "Schema": "peer"
+		}
+	  ]
+	},
+	{
+	  "Peers": [
+		{
+		  "Addrs": [
+			"/ip4/139.178.65.157/udp/4001/quic-v1",
+			"/dns6/ny5.bootstrap.libp2p.io/tcp/443/wss",
+			"/ip6/2604:1380:45d2:8100::1/tcp/4001",
+			"/dns4/ny5.bootstrap.libp2p.io/tcp/443/wss",
+			"/ip4/139.178.65.157/tcp/4001",
+			"/ip6/2604:1380:45d2:8100::1/udp/4001/quic-v1"
+		  ],
+		  "ID": "QmQCU2EcMqAqQPR2i9bChDtGNJchTbq5TbXJJ16u19uLTa",
+		  "Schema": "peer"
+		}
+	  ]
+	},
+	{
+	  "Peers": [
+		{
+		  "Addrs": [
+			"/dns4/am6.bootstrap.libp2p.io/tcp/443/wss",
+			"/ip6/2604:1380:4602:5c00::3/udp/4001/quic-v1/webtransport/certhash/uEiD3Q2mfd5EYt6Y2M9rsge_nna4hVyCgUVlfSz3IjAK8ew/certhash/uEiAHt8JR08mlUCCGnN8VpqG9G4sfvdjAd0v5ZM5W1lqntw",
+			"/ip6/2604:1380:4602:5c00::3/tcp/4001",
+			"/ip4/147.75.87.27/udp/4001/quic-v1",
+			"/ip6/2604:1380:4602:5c00::3/udp/4001/quic-v1",
+			"/ip4/147.75.87.27/tcp/4001",
+			"/dns6/am6.bootstrap.libp2p.io/tcp/443/wss",
+			"/ip4/147.75.87.27/udp/4001/quic-v1/webtransport/certhash/uEiD3Q2mfd5EYt6Y2M9rsge_nna4hVyCgUVlfSz3IjAK8ew/certhash/uEiAHt8JR08mlUCCGnN8VpqG9G4sfvdjAd0v5ZM5W1lqntw"
+		  ],
+		  "ID": "QmbLHAnMoJPWSCR5Zhtx6BHJX9KiKNN6tpvbUcqanj75Nb",
+		  "Schema": "peer"
+		}
+	  ]
+	},
+	{
+	  "Peers": [
+		{
+		  "Addrs": [
+			"/ip6/2604:1380:40e1:9c00::1/udp/4001/quic-v1/webtransport/certhash/uEiBENNd9IIPnU1cTGoVATo6cly-O2fQAjKpIyFi0msoJew/certhash/uEiD8N0sSnHOUIsKxz4pDuVqx4szt-huTZWafW_EY19H7MQ",
+			"/ip6/2604:1380:40e1:9c00::1/tcp/4001",
+			"/dnsaddr/bootstrap.libp2p.io",
+			"/ip4/145.40.118.135/udp/4001/quic-v1/webtransport/certhash/uEiBENNd9IIPnU1cTGoVATo6cly-O2fQAjKpIyFi0msoJew/certhash/uEiD8N0sSnHOUIsKxz4pDuVqx4szt-huTZWafW_EY19H7MQ",
+			"/ip4/145.40.118.135/udp/4001/quic-v1",
+			"/dns4/sg1.bootstrap.libp2p.io/tcp/443/wss",
+			"/ip6/2604:1380:40e1:9c00::1/udp/4001/quic-v1",
+			"/ip4/145.40.118.135/tcp/4001",
+			"/dns6/sg1.bootstrap.libp2p.io/tcp/443/wss",
+			"/ip4/145.40.118.135/tcp/443/tls/sni/sg1.bootstrap.libp2p.io/ws",
+			"/ip6/2604:1380:40e1:9c00::1/tcp/443/tls/sni/sg1.bootstrap.libp2p.io/ws"
+		  ],
+		  "ID": "QmcZf59bWwK5XFi76CZX8cbJ4BhTzzA3gU1ZjYZcYW3dwt",
+		  "Schema": "peer"
+		}
+	  ]
+	},
+	{
+	  "Peers": [
+		{
+		  "Addrs": [
+			"/ip4/104.131.131.82/udp/4001/quic-v1/webtransport/certhash/uEiCIMEw_vvBwFLEqWbOj_wx7I90HmfMabSyVZ9Vn5srjPA/certhash/uEiBy22YtYUPU8T3aJ4rL3jC0lLR8MFZZNkFP-rWRxMrqQA",
+			"/ip4/104.131.131.82/udp/4001/quic-v1",
+			"/ip4/104.131.131.82/tcp/4001",
+			"/ip4/104.131.131.82/udp/4001/quic"
+		  ],
+		  "ID": "QmaCpDMGvV2BGHeYERUEnRQAwe3N8SzbUtfsmvsqQLuvuJ",
+		  "Schema": "peer"
+		}
+	  ]
+	},
+	{
+		"Peers": [
+			{
+				"Addrs": [
+					"/ip4/16.170.214.173/udp/4001/quic-v1/webtransport/certhash/uEiAKAeeOxU7ExDc81y7d53D96nFaRmmXwSFj0429Ij9T9A/certhash/uEiB4ttGGuaUzqF84q5RFhUTVArF4mb9t_UN_kcsfd4qYEQ",
+					"/ip4/16.170.214.173/tcp/4001",
+					"/ip4/16.170.214.173/udp/4001/quic-v1"
+				],
+				"ID": "12D3KooWHh98YpAkJsn3ULjMjK1n9QVkXmi8Sb3gTDMatHxCmDP5",
+				"Schema": "peer"
+			}
+		]
+	},
+	{
+		"Peers": [
+			{
+				"Addrs": [
+					"/ip4/18.119.248.24/udp/4001/quic-v1",
+					"/ip4/18.119.248.24/tcp/4001",
+					"/ip4/18.119.248.24/udp/4001/quic-v1/webtransport/certhash/uEiDwG2YnjoUpoKqmUMX-aYJeLi1UNEsqa8EFhpHFUVs0AQ/certhash/uEiCqy6-Pk3S2iYS0puQ0UhtTZ1s_nw-sIsoB-bX0Le6lFA"
+				],
+				"ID": "12D3KooWS79EhkPU7ESUwgG4vyHHzW9FDNZLoWVth9b5N5NSrvaj",
+				"Schema": "peer"
+			}
+		]
+	},
+	{
+		"Peers": [
+			{
+				"Addrs": [
+					"/ip4/83.173.236.99/udp/4001/quic-v1/webtransport/certhash/uEiD8mhYDW_6kgJAb07RlZnA-YSScG38df5wb9IxFtZmQwQ/certhash/uEiACG9e-sG_ild6y5t-jvb_dfsNi_gPgZ7nn7Qa5ctT-Wg",
+					"/ip6/2a02:121e:21e:1:546f:18ff:fea8:8e/tcp/4001",
+					"/ip4/83.173.236.99/tcp/10201",
+					"/dns4/ipfs-ws.neaweb.ch/tcp/443/wss",
+					"/ip4/89.251.251.195/udp/4001/quic-v1",
+					"/ip4/89.251.251.195/udp/4001/quic-v1/webtransport/certhash/uEiD8mhYDW_6kgJAb07RlZnA-YSScG38df5wb9IxFtZmQwQ/certhash/uEiACG9e-sG_ild6y5t-jvb_dfsNi_gPgZ7nn7Qa5ctT-Wg",
+					"/ip6/2a02:121e:21e:1:546f:18ff:fea8:8e/udp/4001/quic-v1",
+					"/ip4/89.251.251.195/tcp/4001/quic-v1/webtransport",
+					"/ip6/2a02:121e:21e:1:546f:18ff:fea8:8e/tcp/4011/ws",
+					"/ip4/89.251.251.195/tcp/4001",
+					"/dns4/ipfs-ws.neaweb.tech/tcp/443/wss",
+					"/ip4/89.251.251.195/tcp/4001/quic-v1",
+					"/ip4/83.173.236.99/tcp/4001",
+					"/ip6/2a02:121e:21e:1:546f:18ff:fea8:8e/udp/4001/quic-v1/webtransport/certhash/uEiD8mhYDW_6kgJAb07RlZnA-YSScG38df5wb9IxFtZmQwQ/certhash/uEiACG9e-sG_ild6y5t-jvb_dfsNi_gPgZ7nn7Qa5ctT-Wg",
+					"/ip4/83.173.236.99/udp/4001/quic-v1",
+					"/ip4/83.173.236.99/udp/19707/quic-v1",
+					"/ip4/83.173.236.99/udp/19707/quic-v1/webtransport/certhash/uEiD8mhYDW_6kgJAb07RlZnA-YSScG38df5wb9IxFtZmQwQ/certhash/uEiACG9e-sG_ild6y5t-jvb_dfsNi_gPgZ7nn7Qa5ctT-Wg"
+				],
+				"ID": "12D3KooWBbkCD5MpJhMc1mfPAVGEyVkQnyxPKGS7AHwDqQM2JUsk",
+				"Schema": "peer"
+			}
+		]
+	},
+	{
+		"Peers": [
+			{
+				"Addrs": [
+					"/ip4/89.58.11.155/udp/4001/quic-v1/webtransport/certhash/uEiDDgTBtcIstrvU4MRSfcD7tYDIsQrnGAxW6Oh5AoLm4Ig/certhash/uEiAXHXsg1wBb-sPvpBw8BVpRFxso1milPa801TxjPNYQ3w",
+					"/ip4/89.58.11.155/udp/4001/quic",
+					"/ip6/64:ff9b::593a:b9b/udp/4001/quic-v1/webtransport/certhash/uEiDDgTBtcIstrvU4MRSfcD7tYDIsQrnGAxW6Oh5AoLm4Ig/certhash/uEiAXHXsg1wBb-sPvpBw8BVpRFxso1milPa801TxjPNYQ3w",
+					"/ip6/64:ff9b::593a:b9b/udp/4001/quic-v1",
+					"/ip4/89.58.11.155/udp/4001/quic-v1",
+					"/ip4/89.58.11.155/tcp/4001"
+				],
+				"ID": "12D3KooWKLdecs31Zmo2pLBjR9HY2vWo3VwM4eBm21Czeucbe6FL",
+				"Schema": "peer"
+			}
+		]
+	},	
+	{
+		"Peers": [
+			{
+				"Addrs": [
+					"/ip4/205.198.64.76/tcp/4001",
+					"/ip4/205.198.64.76/udp/4001/quic-v1",
+					"/ip4/205.198.64.76/udp/4001/quic-v1/webtransport/certhash/uEiCT4khDdgvF2NHCw-fu3qUk2qRqx0AgTEt0PHZct8jq5g/certhash/uEiA2RYkSCyOOtJmrpm_Dn8jJr-LLwS0S7K3HX3dbJJlN_w"
+				],
+				"ID": "12D3KooWBdF3g6vSJFRPoZQo7BNnkNzaWb59gpyaVzsgtNTVeu8H",
+				"Schema": "peer"
+			}
+		]
+	},	
+];
+
+const CONFIG_KNOWN_BOOTSTRAP_PEER_IDS = [
+	'12D3KooWFhXabKDwALpzqMbto94sB7rvmZ6M28hs9Y9xSopDKwQr',
+	'12D3KooWGahRw3ZnM4gAyd9FK75v4Bp5keFYTvkcAwhpEm28wbV3',
+	'12D3KooWPEDBmt7vm6FNNYuqaA4n2qMUZ6wPK5NcRc8t6KpqgRkV',
+	'12D3KooWSHbugDEQeWm2LjtRRMpNgLu6oZ8zkX8XcTwYMAewVekP',
+	'12D3KooWASoxFpwwy8JDdu4Tm57mhESsnbFPogam9VVmhR95FGXr',
+	'QmNnooDu7bfjPFoTZYxMNLWUQJyrVwtbZg5gBMjTezGAJN',
+	'QmQCU2EcMqAqQPR2i9bChDtGNJchTbq5TbXJJ16u19uLTa',
+	'QmbLHAnMoJPWSCR5Zhtx6BHJX9KiKNN6tpvbUcqanj75Nb',
+	'QmcZf59bWwK5XFi76CZX8cbJ4BhTzzA3gU1ZjYZcYW3dwt',
+	'QmaCpDMGvV2BGHeYERUEnRQAwe3N8SzbUtfsmvsqQLuvuJ',
+	'12D3KooWHh98YpAkJsn3ULjMjK1n9QVkXmi8Sb3gTDMatHxCmDP5',
+	'12D3KooWS79EhkPU7ESUwgG4vyHHzW9FDNZLoWVth9b5N5NSrvaj',
+	'12D3KooWBbkCD5MpJhMc1mfPAVGEyVkQnyxPKGS7AHwDqQM2JUsk',
+	'12D3KooWKLdecs31Zmo2pLBjR9HY2vWo3VwM4eBm21Czeucbe6FL',
+	'12D3KooWBdF3g6vSJFRPoZQo7BNnkNzaWb59gpyaVzsgtNTVeu8H'
+	];
+
+const prefix = CONFIG_PREFIX;
+
+const mkErr = msg => new Error(`${prefix}: ${msg}`);
+
+function uint8ArrayToString(uint8Array){
+	const string = new TextDecoder().decode(uint8Array);
+	return string
+}
+
+function uint8ArrayFromString(string){
+	const uint8Array = new TextEncoder().encode(string);
+	return uint8Array
+}
+
+//Add id to pupsub message
+async function msgIdFnStrictNoSign(msg){
+  var enc = new TextEncoder();
+  const signedMessage = msg;
+  const encodedSeqNum = enc.encode(signedMessage.sequenceNumber.toString());
+  return await sha256.encode(encodedSeqNum)
+}
+
+let totals = {
+    readyErrored: 0,
+    noiseErrored: 0,
+    upgradeErrored: 0,
+    readyTimedout: 0,
+    noiseTimedout: 0,
+    success: 0
+};
+
+let stats = {
+    pending: 0,
+    open: 0,
+
+    ready_error: 0,
+    noise_error: 0,
+    upgrade_error: 0,
+
+    ready_timeout: 0,
+    noise_timeout: 0,
+
+    close: 0,
+    abort: 0,
+    remote_close: 0,
+};
+
+let lastStats = {
+    pending: 0,
+    ready_error: 0,
+    noise_error: 0,
+    upgrade_error: 0,
+    close: 0,
+    remote_close: 0,
+    ready: 0,
+    abort: 0,
+    ready_timeout: 0,
+    noise_timeout: 0,
+    open: 0
+};
+
+let isDialEnabled = true;
+let lastfailtreshold = 0;
+
+function metrics(data){
+	try{
+		const webTransportEvents = data.libp2p_webtransport_dialer_events_total;
+		
+		const newPending = (webTransportEvents.pending ?? 0) - (lastStats.pending ?? 0);
+		const newReadyError = (webTransportEvents.ready_error ?? 0) - (lastStats.ready_error ?? 0);
+		const newNoiseError = (webTransportEvents.noise_error ?? 0) - (lastStats.noise_error ?? 0);
+		const newUpgradeError = (webTransportEvents.upgrade_error ?? 0) - (lastStats.upgrade_error ?? 0);
+		const newClose = (webTransportEvents.close ?? 0) - (lastStats.close ?? 0);
+		const newReady = (webTransportEvents.ready ?? 0) - (lastStats.ready ?? 0);
+		const newAbort = (webTransportEvents.abort ?? 0) - (lastStats.abort ?? 0);
+		const newReadyTimeout = (webTransportEvents.ready_timeout ?? 0) - (lastStats.ready_timeout ?? 0);
+		const newNoiseTimeout = (webTransportEvents.noise_timeout ?? 0) - (lastStats.noise_timeout ?? 0);
+		const newOpen = (webTransportEvents.open ?? 0) - (lastStats.open ?? 0);
+		const newRemoteClose = (webTransportEvents.remote_close ?? 0) - (lastStats.remote_close ?? 0);
+
+		stats.pending += newPending;
+		stats.pending -= newReadyTimeout;
+		stats.pending -= newNoiseTimeout;
+		stats.pending -= newReadyError;
+		stats.pending -= newNoiseError;
+		stats.pending -= newUpgradeError;
+		stats.pending -= newOpen;
+
+		stats.open += newOpen;
+		stats.open -= newClose;
+		stats.open -= newRemoteClose;
+		stats.open -= newAbort;
+
+		stats.ready_error = newReadyError;
+		stats.noise_error = newNoiseError;
+		stats.upgrade_error = newUpgradeError;
+		stats.ready_timeout = newReadyTimeout;
+		stats.noise_timeout = newNoiseTimeout;
+		stats.close = newClose;
+		stats.abort = newAbort;
+		stats.remote_close = newRemoteClose;
+
+		totals.success += newReady;
+		totals.readyErrored += newReadyError;
+		totals.noiseErrored += newNoiseError;
+		totals.upgradeErrored += newUpgradeError;
+		totals.readyTimedout += newReadyTimeout;
+		totals.noiseTimedout += newNoiseTimeout;
+
+		const errors = totals.readyErrored + totals.noiseErrored + totals.upgradeErrored;
+		const timeouts = totals.readyTimedout + totals.noiseTimedout;
+		//const failureRate = ((errors + timeouts) / (errors + timeouts + totals.success) * 100).toFixed(2)
+		
+		lastStats = webTransportEvents;
+		
+		const fail = errors+timeouts;
+		const treshold = errors+timeouts+stats.open+stats.pending;
+		
+		if(treshold>50){
+			//console.log(`Treeshold hit : ${treshold}`)
+		}
+		
+		if(fail>50){
+			//console.log(`Open : ${stats.open} , Pending : ${stats.pending} , Succes : ${totals.success} , Fail : ${fail} `)
+
+		}
+		
+		if ((fail-lastfailtreshold)>50){
+			if(isDialEnabled){
+				isDialEnabled = false;
+				//const str = JSON.stringify({isDialEnabled,fail,lastfailtreshold})
+				//console.warn(str)
+				setTimeout(()=>{
+					if(!isDialEnabled){
+						isDialEnabled = true;
+						lastfailtreshold = fail;
+						//const str = JSON.stringify({isDialEnabled,fail,lastfailtreshold})
+						//console.warn(str)
+					}
+				},6*60*1000);
+			}
+		}
+		
+		return isDialEnabled
+		
+	}
+	catch{
+		console.debug('Metrics error');
+	}
+}
+
+/*
+onunhandledrejection = function(evt) {
+    console.warn(evt.reason);
+	return
+}
+*/
+
+class webpeerjs{
+	
+	//libp2p instance
+	#libp2p
+	
+	//map [id,addrs] of discovered peers (addrs is array of address)
+	#discoveredPeers
+	
+	//array of all webpeers id has been found
+	#webPeersId
+	
+	//map [id,addrs]
+	#webPeersAddrs
+	
+	//database of best peers has been found
+	#dbstore
+	#dbstoreData
+	
+	//map of [id,number_of_dialed] of good peers on #connectionTracker
+	#dialedGoodPeers
+	
+	//boolean is dial websocket
+	#isDialWebsocket
+	
+	//map [id,mddrs] of dialed bootstrap address
+	#dialedKnownBootstrap
+	
+	//array of dialed discovered peers id
+	//#dialedDiscoveredPeers
+	
+	//object from joinRoom()
+	#rooms
+	
+	//map [id,addrs] of webpeers currently  connected  (addrs is array of address)
+	#connectedPeers
+	
+	//array of we peers id proxy of #connectedPeers
+	#connectedPeersArr
+	
+	//map [id,number_of_dialed] of #connectionTracker object store
+	#connectionTrackerStore
+	
+	//map [id,addr] of all peers connections (addr is string of address)
+	#connections
+	
+	//track disconnect event
+	#trackDisconnect
+	
+	//list of dial multiaddress queue
+	#dialQueue
+	
+	//is dial enabled
+	#isDialEnabled
+	
+	id
+	status
+	IPFS
+	address
+	peers
+	
+	constructor(libp2p,dbstore,onMetrics){
+		
+		this.#libp2p = libp2p;
+		this.#dbstore = dbstore;
+		this.#dbstoreData = new Map();
+		this.#discoveredPeers = new Map();
+		this.#webPeersId = [];
+		this.#webPeersAddrs = new Map();
+		this.#dialedGoodPeers = new Map();
+		this.#isDialWebsocket = false;
+		this.#dialedKnownBootstrap = new Map();
+		//this.#dialedDiscoveredPeers = []
+		this.address = [];
+		this.#rooms = {};
+		this.#connectedPeers = new Map();
+		this.#connectedPeersArr = [];
+		this.#connectionTrackerStore = new Map();
+		this.#connections = new Map();
+		this.#trackDisconnect = new Map();
+		this.#dialQueue = [];
+		this.#isDialEnabled = true;
+		
+		this.peers = (function(f) {
+			return f
+		})(this.#connectedPeersArr);
+		
+		this.status = (function(libp2p) {
+			return libp2p.status
+		})(this.#libp2p);
+
+		this.IPFS = (function(libp2p,discoveredPeers) {
+			const obj = {libp2p,discoveredPeers};
+			return obj
+		})(this.#libp2p,this.#discoveredPeers);
+		
+		this.id = this.#libp2p.peerId.toString();
+		
+		
+		//listen to peer connect event
+		this.#libp2p.addEventListener("peer:connect", (evt) => {
+			
+			//console.log(`Connected to ${connection.toString()}`);
+			
+			const connection = evt.detail;
+			const id = evt.detail.toString();
+			
+			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;
+			this.#connections.set(id,addr);
+			
+			//required by joinRoom version 1 to announce via universal connectivity
+			if(connection.toString() === CONFIG_KNOWN_BOOTSTRAP_PEER_IDS[0]){
+				setTimeout(()=>{
+					this.#announce();
+				},1000);
+			}
+			
+		});
+
+
+		//listen message from subscribed pupsub topic
+		this.#libp2p.services.pubsub.addEventListener('message', event => {
+			
+			//console.log('on:'+event.detail.topic,event.detail.data)
+			//console.log('from '+event.detail.from.toString(),event)
+			
+			if (event.detail.type !== 'signed') {
+			  return
+			}
+			{
+				const topic = event.detail.topic;
+				const senderPeerId = event.detail.from.toString();
+				if(CONFIG_PUBSUB_PEER_DISCOVERY.includes(topic)){
+					try{
+						
+						//if it is webpeer 
+						if(this.#webPeersId.includes(senderPeerId)){
+							
+							if(this.#connectedPeers.has(senderPeerId)){
+								//reset this last seen
+								const address = this.#connectedPeers.get(senderPeerId).addrs;
+								const now = new Date().getTime();
+								const metadata = {addrs:address,last:now};
+								this.#connectedPeers.set(senderPeerId,metadata);
+							}
+							else {
+								//add to connected webpeers
+								this.#onConnectFn(senderPeerId);
+								const address = this.#webPeersAddrs.get(senderPeerId);
+								const now = new Date().getTime();
+								const metadata = {addrs:address,last:now};
+								this.#connectedPeers.set(senderPeerId,metadata);
+							}
+
+							//dial if not connected
+							if(!this.#isConnected(senderPeerId)){
+								if(this.#connections.has(senderPeerId)){
+									let mddrs = [];
+									const addr = this.#connections.get(senderPeerId);
+									const mddr = multiaddr(addr);
+									mddrs.push(mddr);
+									this.#dialMultiaddress(mddrs);
+								}
+								else if(this.#discoveredPeers.has(senderPeerId)){
+									const addrs = this.#discoveredPeers.get(senderPeerId);
+									let mddrs = [];
+									for(const addr of addrs){
+										const mddr = multiaddr(addr);
+										mddrs.push(mddr);
+									}
+									this.#dialMultiaddress(mddrs);
+								}
+								else {
+									const addrs = this.#connectedPeers.get(senderPeerId).addrs;
+									let mddrs = [];
+									for(const addr of addrs){
+										const mddr = multiaddr(addr);
+										mddrs.push(mddr);
+									}
+									this.#dialMultiaddress(mddrs);
+								}
+							}
+
+
+						}
+						
+						//parse the message over pupsub peer discovery
+						const peer = Peer.decode(event.detail.data);
+						const msg = uint8ArrayToString(peer.addrs[0]);
+						const json = JSON.parse(msg);
+						const prefix = json.prefix;
+						const room = json.room;
+						const message = json.message;
+						const signal = json.signal;
+						const id = json.id;
+						//console.log(`from ${id}:${signal} = ${message}`)
+						if(id != senderPeerId)return
+						let address = json.address;
+						
+						//detect special webpeer identity
+						if(prefix === CONFIG_PREFIX){
+
+							//add to webpeers id
+							if(!this.#webPeersId.includes(id))this.#webPeersId.push(id);
+							
+							//add to connected webpeers
+							if(!this.#connectedPeers.has(id)){
+								this.#onConnectFn(id);
+								address = [];
+								const now = new Date().getTime();
+								const metadata = {addrs:address,last:now};
+								this.#connectedPeers.set(id,metadata);
+								this.#webPeersAddrs.set(id,address);
+								this.#connectedPeersArr.length = 0;
+								for(const peer of this.#connectedPeers){	
+									const item = {id:peer[0],address:peer[1].addrs};
+									this.#connectedPeersArr.push(item);
+								}
+							}
+
+							
+							if(room){
+								if(this.#rooms[room]){
+									
+									//inbound message
+									this.#rooms[room].onMessage(message,id);
+									
+									//update room members
+									if(!this.#rooms[room].members.includes(id)){
+										this.#rooms[room].members.push(id);
+										this.#rooms[room].onMembers(this.#rooms[room].members);
+									}
+								}
+							}
+							
+							if(signal){
+								
+								//repply announce with ping
+								if(signal == 'announce'){
+									setTimeout(()=>{this.#ping();},1000);
+								}
+								
+								if(signal == 'ping'){
+									//do nothing
+								}
+								
+								//update connected webpeers
+								const now = new Date().getTime();
+								const metadata = {addrs:address,last:now};
+								this.#connectedPeers.set(id,metadata);
+								this.#webPeersAddrs.set(id,address);
+								this.#connectedPeersArr.length = 0;
+								for(const peer of this.#connectedPeers){	
+									const item = {id:peer[0],address:peer[1].addrs};
+									this.#connectedPeersArr.push(item);
+								}
+									
+							}
+						}
+
+					}catch(err){
+						//console.log('from '+event.detail.from.toString())
+						console.debug(err);
+					}
+				}else {
+					const json = JSON.parse(topic);
+					const room = json.room;
+					const message = new TextDecoder().decode(event.detail.data);
+					this.#rooms[room].onMessage(message);
+				}
+			}
+			
+		});
+		
+		
+		//listen to peer discovery event
+		this.#libp2p.addEventListener('peer:discovery', (evt) => {
+
+			//console.log('Discovered:', evt.detail.id.toString())
+			//console.log('Discovered: '+evt.detail.id.toString(), evt.detail.multiaddrs.toString())
+			
+			//save peer discover
+			
+			const multiaddrs = evt.detail.multiaddrs;
+			const id = evt.detail.id;
+			
+			if(multiaddrs.length != 0){
+				let addrs = [];
+				for(const addr of multiaddrs){
+					let peeraddr;
+					if(multiaddrs.toString().includes(evt.detail.id.toString())){
+						//console.log('Discovered:', evt.detail.multiaddrs.toString())
+						//peer from pupsub peer discovery already has included self id
+						peeraddr = addr.toString();
+					}
+					else {
+						//other need to add Id
+						peeraddr = addr.toString()+'/p2p/'+id;
+					}
+					addrs.push(peeraddr);
+				}
+				//save the new format multiaddrs
+				this.#discoveredPeers.set(id.toString(), addrs);
+
+				//track if peer come from relay then dial it because there is a chance it is from other browser node
+				if(multiaddrs.toString().includes('certhash')&& multiaddrs.toString().includes('webtransport') && multiaddrs.toString().includes('p2p-circuit')){
+					//console.log(addrs)
+					if(!this.#connections.has(id)){
+						for(const addr of addrs){
+							multiaddr(addr);
+						}
+						//this.#dialMultiaddress(mddrs)
+					}
+				}
+			}
+			
+		});
+
+		
+		//listen to peer disconnect event
+		this.#libp2p.addEventListener("peer:disconnect",async (evt) => {
+			
+			//const connection = evt.detail;
+			//console.log(`Disconnected from ${connection.toCID().toString()}`);
+			const id = evt.detail.string;
+			
+			//track disconnect event
+			if(this.#trackDisconnect.has(id)){
+				let count = this.#trackDisconnect.get(id);
+				count++;
+				this.#trackDisconnect.set(id,count);
+				//console.log(this.#trackDisconnect)
+				if(count>5){
+					if(this.#dbstoreData.has(id)){
+						//await this.#dbstore.delete(new Key(id))
+						this.#dbstoreData.delete(id);
+					}
+					
+					if(!this.#webPeersId.includes(id) && !this.#dialedKnownBootstrap.has(id)){
+						return
+					}
+				}
+			}
+			else {
+				this.#trackDisconnect.set(id,0);
+			}
+			
+			//if this disconnected peer is web peer redial it
+			if(this.#webPeersId.includes(id)){
+				const addr = this.#connections.get(id);
+				let mddrs = [];
+				const mddr = multiaddr(addr);
+				mddrs.push(mddr);
+				this.#dialMultiaddress(mddrs);
+			}
+			
+			//if this disconnected peer is known bootstrap redial it
+			else if(this.#dialedKnownBootstrap.has(id)){
+				const addr = this.#connections.get(id);
+				let mddrs = [];
+				const addrs = multiaddr(addr);
+				mddrs.push(addrs);
+				this.#dialMultiaddress(mddrs);
+			}
+			
+			//redial if this disconnected peer is regular peer
+			else {
+				const addr = this.#connections.get(id);
+				let mddrs = [];
+				const addrs = multiaddr(addr);
+				mddrs.push(addrs);
+				this.#dialMultiaddress(mddrs);
+			}
+		});
+		
+		
+		//listen to self peer update
+		this.#libp2p.addEventListener('self:peer:update', ({ detail: { peer } }) => {
+			//const multiaddrs = peer.addresses.map(({ multiaddr }) => multiaddr)
+			//console.log(`changed multiaddrs: peer ${peer.id.toString()} multiaddrs: ${multiaddrs}`)
+			const id = peer.id.toString();
+			const mddrs = [];
+			peer.addresses.forEach((addr)=>{
+				const maddr = addr.multiaddr.toString()+'/p2p/'+id;
+				if(maddr.includes('webtransport') && maddr.includes('certhash')){
+					mddrs.push(maddr);
+				}
+			});
+			//this.#ListenAddressChange(mddrs)
+			this.address = mddrs;
+			this.#ping();
+		});
+		
+		//dial known peers from configuration
+		this.#dialKnownPeers();
+	
+		//watch connection every 30s if none dial known peers again from configuration
+		this.#watchConnection();		
+	
+		//if found good peers save to storage and reconnect if disconnect
+		this.#connectionTracker();
+		
+		//periodically dial saved bootstrap address if disconnect
+		this.#dialRandomBootstrap();
+		
+		//dial random discovered peers
+		//this.#dialdiscoveredpeers()
+
+		onMetrics((data)=>{
+			const signal = metrics(data);
+			this.#isDialEnabled = signal;
+			
+		});
+		
+		setInterval(()=>{
+			this.#dialQueueList();
+		},5e3);
+		
+		setInterval(()=>{
+			this.#trackLastSeen();
+		},5e3);
+		
+	}
+
+
+
+
+	/*
+	PUBLIC FUNCTION
+	*/
+
+	//Listen on new peer connection
+	#onConnectFn = () => {}
+	onJoin = f => (this.#onConnectFn = f)
+
+
+	//Listen on peer disconnect
+	#onDisconnectFn = () => {}
+	onLeave = f => (this.#onDisconnectFn = f)	
+
+
+
+
+	/*
+	PRIVATE FUNCTION
+	*/
+	
+	
+	//check the last seen in web peer
+	#trackLastSeen(){
+		const timeout = 25*1000;
+		const now = new Date().getTime();
+		
+		//if webpeer last seen grather then timeout send onDisconnect
+		for(const peer of this.#connectedPeers){
+			const id = peer[0];
+			const last = peer[1].last;
+			const time = now-last;
+			if(time>timeout){
+				this.#connectedPeers.delete(id);
+				this.#connectedPeersArr.length = 0;
+				for(const peer of this.#connectedPeers){	
+					const item = {id:peer[0],address:peer[1].addrs};
+					this.#connectedPeersArr.push(item);
+				}
+				this.#onDisconnectFn(id);
+				
+				//remove id from room member
+				const rooms = Object.keys(this.#rooms);
+				for(const room of rooms){
+					if(this.#rooms[room].members.includes(id)){
+						const index = this.#rooms[room].members.indexOf(id);
+						this.#rooms[room].members.splice(index,1);
+						this.#rooms[room].onMembers(this.#rooms[room].members);
+					}
+				}
+			}
+		}
+	}
+	
+	//check if this id is connected
+	#isConnected(id){
+			let peers = [];
+			for(const peer of this.#libp2p.getPeers()){
+				peers.push(peer.toString());
+			}
+			if(peers.includes(id)){
+				return true
+			}
+			else {
+				return false
+			}
+	}
+
+	
+	//add multiaddr address to queue list
+	#dialMultiaddress(mddrs){
+		if(mddrs.length>0){
+			
+			const id = mddrs[0].toString().split('/').pop();
+			
+			const ids = this.#dialQueue.map((arr)=> arr[0].toString().split('/').pop());
+			
+			//if peer id is already in the queque cancel queque
+			if(ids.includes(id)){
+				return
+			}
+			
+			if(this.#webPeersId.includes(id) || id == CONFIG_KNOWN_BOOTSTRAP_PEER_IDS[0] ){
+				this.#dialQueue.unshift(mddrs);
+			}
+			else {
+				this.#dialQueue.push(mddrs);
+			}
+			
+		}
+	}
+	
+	//dial multiaddr address in queue list
+	#dialQueueList(){
+		
+		if(!this.#isDialEnabled)return
+		
+		const mddrsToDial = 3;
+		
+		let queue = [];
+		for(const item of this.#libp2p.getDialQueue()){
+			const id = item.peerId.string;
+			queue.push(id);
+		}
+		
+		if (queue.length > mddrsToDial)return
+		
+		for(let i = 0; i < mddrsToDial; i++){
+			const mddrs = this.#dialQueue.shift();
+			if(mddrs != undefined && mddrs.length>0){
+				
+				const id = mddrs[0].toString().split('/').pop();
+				
+				if(this.#isConnected(id))continue
+				if(queue.includes(id)){continue;}
+
+				//dial with webtransport
+				this.#dialWebtransport(mddrs);
+				
+				//fallback dial with websocket if enabled
+				if(this.#isDialWebsocket){
+					this.#dialWebsocket(mddrs);
+				}
+				
+			}
+			else {
+				break
+			}
+		}
+
+	}
+	
+
+	//announce and ping via pupsub peer discovery
+	async #announce(){
+			const topics = CONFIG_PUBSUB_PEER_DISCOVERY;
+			const data = JSON.stringify({prefix:CONFIG_PREFIX,signal:'announce',id:this.#libp2p.peerId.toString(),address:this.address});
+			const peer = {
+			  publicKey: this.#libp2p.peerId.publicKey,
+			  addrs: [uint8ArrayFromString(data)],
+			};
+			const encodedPeer = Peer.encode(peer);
+			for(const topic of topics){
+				await this.#libp2p.services.pubsub.publish(topic, encodedPeer);
+			}
+	}
+	async #ping(){
+			const topics = CONFIG_PUBSUB_PEER_DISCOVERY;
+			const data = JSON.stringify({prefix:CONFIG_PREFIX,signal:'ping',id:this.#libp2p.peerId.toString(),address:this.address});
+			const peer = {
+			  publicKey: this.#libp2p.peerId.publicKey,
+			  addrs: [uint8ArrayFromString(data)],
+			};
+			const encodedPeer = Peer.encode(peer);
+			for(const topic of topics){
+				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
+		{
+
+			const topics = CONFIG_PUBSUB_PEER_DISCOVERY;
+			
+			this.#rooms[room] = {
+				onMessage : () => {},
+				listenMessage : f => (this.#rooms[room] = {...this.#rooms[room], onMessage: f}),
+				sendMessage : async (message) => {
+					const data = JSON.stringify({prefix:CONFIG_PREFIX,room,message,id:this.#libp2p.peerId.toString()});
+					const peer = {
+					  publicKey: this.#libp2p.peerId.publicKey,
+					  addrs: [uint8ArrayFromString(data)],
+					};
+					const encodedPeer = Peer.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);},
+			};
+		}
+		
+		return [
+			this.#rooms[room].sendMessage,
+			this.#rooms[room].listenMessage,
+			this.#rooms[room].onMembersChange
+		]
+	}
+	
+	
+	//dial discovered peers
+	/*#dialdiscoveredpeers(){
+		setInterval(()=>{
+			const keys = Array.from(this.#discoveredPeers.keys())
+			for(const key of keys){
+				if(!this.#dialedDiscoveredPeers.includes(key)){
+					this.#dialedDiscoveredPeers.push(key)
+					const addrs = this.#discoveredPeers.get(key)
+					let mddrs = []
+					for(const addr of addrs){
+						const mddr = multiaddr(addr)
+						mddrs.push(mddr)
+					}
+					this.#dialMultiaddress(mddrs)
+					break
+				}
+			}
+		},30*1000)
+	}*/
+	
+	
+	//dial random known bootstrap periodically
+	#dialRandomBootstrap(){
+		setInterval(()=>{
+			//const keys = Array.from(this.#dialedKnownBootstrap.keys())
+			const keys = CONFIG_KNOWN_BOOTSTRAP_PEER_IDS;
+			const randomKey = Math.floor(Math.random() * keys.length);
+			let ids = [];
+			ids.push(keys[randomKey]);
+			
+			//universal connectivity id for webpeer discovery and joinRoom version 1 to work
+			ids.push(CONFIG_KNOWN_BOOTSTRAP_PEER_IDS[0]);
+			
+			for(const id of ids){
+				if(id == undefined)continue
+				//const addrs = this.#dialedKnownBootstrap.get(id)
+
+				if(!this.#isConnected(id)){
+					if(this.#connections.has(id))
+					{
+						let mddrs = [];
+						const addr = this.#connections.get(id);
+						const mddr = multiaddr(addr);
+						mddrs.push(mddr);
+						this.#dialMultiaddress(mddrs);
+					}
+					else if (this.#dialedKnownBootstrap.has(id)){
+						let mddrs = [];
+						const addrs = this.#dialedKnownBootstrap.get(id);
+						for(const addr of addrs){
+							const mddr = multiaddr(addr);
+							mddrs.push(mddr);
+						}
+						this.#dialMultiaddress(mddrs);
+					}
+					else {
+						const bootstrap = CONFIG_KNOWN_BOOTSTRAP_PEERS_ADDRS;
+						const index = bootstrap.findIndex((peer)=>peer.Peers[0].ID == id);
+						const addrs = bootstrap[index].Peers[0].Addrs;
+						let mddrs = [];
+						for(const addr of addrs){
+							const peeraddr = addr+'/p2p/'+id;
+							const mddr = multiaddr(peeraddr);
+							mddrs.push(mddr);
+						}
+						this.#dialMultiaddress(mddrs);
+					}
+				}
+			}
+		},45*1000);
+	}
+	
+	
+	//track for good connection
+	async #connectionTracker(){
+		
+		for await (const { key, value } of this.#dbstore.query({})) {
+			const id = key.toString().split('/')[1];
+			const addr = new TextDecoder().decode(value);
+			this.#dbstoreData.set(id,addr);
+		}	
+		
+		setInterval(async ()=>{
+			
+			//save peer address if connection is good
+			const connections = this.#libp2p.getConnections();
+			for(const connect of connections){
+				const peer = connect.remotePeer;
+				const remote = connect.remoteAddr;
+				const upgraded = connect.timeline.upgraded;
+				const bestlimit = 5*60*1000;
+				const now = new Date().getTime();
+				const besttime = now-upgraded;
+				if(besttime>bestlimit){
+					const addr = remote.toString();
+					const id = peer.toString();
+					if(!this.#webPeersId.includes(id) && !CONFIG_KNOWN_BOOTSTRAP_PEER_IDS.includes(id) && !this.#dbstoreData.get(id) && !addr.includes('p2p-circuit')){
+						//await this.#dbstore.delete(new Key(id))
+						await this.#dbstore.put(new Key(id), new TextEncoder().encode(addr));
+						this.#dbstoreData.set(id,addr);
+					}
+				}
+				const goodlimit = 60*1000;
+				const goodtime = now-upgraded;
+				if(goodtime>goodlimit){
+					const id = peer.toString();
+					if(!this.#dialedGoodPeers.has(id))this.#dialedGoodPeers.set(id,0);
+				}
+				
+			}
+			
+			
+			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)){
+					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);
+					}
+					else {
+						this.#connectionTrackerStore.set(id,0);
+					}
+					let mddrs = [];
+					const mddr = multiaddr(addr);
+					mddrs.push(mddr);
+					this.#dialMultiaddress(mddrs);
+				}
+			}
+			
+			//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)){
+					this.#dialedGoodPeers.set(id,0);
+					continue
+				}
+				else {					
+					
+					let count = this.#dialedGoodPeers.get(id);
+					if (count < 15 || (count < 25 && this.#dialedKnownBootstrap.has(id))){
+						const addr = this.#connections.get(id);
+						let mddrs = [];
+						const mddr = multiaddr(addr);
+						mddrs.push(mddr);
+						this.#dialMultiaddress(mddrs);
+						count++;
+						this.#dialedGoodPeers.set(id,count);
+					}
+				}
+			}
+			
+		},30*1000);
+	}
+
+	
+	//update listen address on change
+	//#ListenAddressChange = () => {}
+	//#onSelfAddress = f => (this.#ListenAddressChange = f)
+	
+	
+	//Periodically watch for connection
+	#watchConnection(){
+		setInterval(()=>{
+			const peers = this.#libp2p.getPeers().length;
+			if(peers == 0){
+				this.#dialKnownPeers();
+			}
+		},60*1000);
+	}
+	
+	
+	//dial to all known bootstrap peers and DNS
+	#dialKnownPeers(){
+		this.#dialKnownBootstrap();
+		setTimeout(()=>{
+			const peers = this.#libp2p.getPeers().length;
+			if(peers == 0){
+				//currently not needed
+				//this.#dialKnownID()
+				setTimeout(()=>{
+					const peers = this.#libp2p.getPeers().length;
+					if(peers == 0){
+						//currently not needed
+						//this.#dialKnownDNS()
+						setTimeout(()=>{
+							this.#libp2p.getPeers().length;
+						},15000);
+					}
+				},15000);
+			}
+		},15000);
+	}
+	
+	
+	//dial based on known bootsrap peers address
+	#dialKnownBootstrap(){
+		const bootstrap = 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);
+			}
+			
+		}
+	}
+	
+	
+	//dial based on known peers ID
+	/*async #dialKnownID(){
+		const api = config.CONFIG_DELEGATED_API
+		const delegatedClient = createDelegatedRoutingV1HttpApiClient(api)
+		const BOOTSTRAP_PEER_IDS = config.CONFIG_KNOWN_BOOTSTRAP_PEER_IDS
+		const peers = await Promise.all(
+			BOOTSTRAP_PEER_IDS.map((peerId) => first(delegatedClient.getPeers(peerIdFromString(peerId)))),
+		)
+		for(const peer of peers){
+			if(!peer)return
+			const address = peer.Addrs
+			const id = peer.ID
+			let mddrs = []
+			let addrs = []
+			for(const addr of address){
+				const peeraddr = addr.toString()+'/p2p/'+id.toString()
+				const peermddr = multiaddr(peeraddr)
+				addrs.push(peeraddr)
+				mddrs.push(peermddr)
+			}
+			
+			this.#dialedKnownBootstrap.set(id,addrs)
+			if(!this.#isConnected(id)){
+				this.#dialMultiaddress(mddrs)
+			}
+		}
+	}*/
+	
+	
+	//dial based on known bootstrap DNS
+	/*async #dialKnownDNS(){
+		const dnsresolver = config.CONFIG_DNS_RESOLVER
+		const bootstrapdns = config.CONFIG_KNOWN_BOOTSTRAP_DNS
+		const response = await fetch(dnsresolver+'?name='+bootstrapdns+'&type=txt')
+		const json = await response.json()
+		const dns = json.Answer
+		const BOOTSTRAP_PEER_IDS = []
+		for(const dnsaddr of dns){
+			const id = dnsaddr.data.split('/').pop()
+			BOOTSTRAP_PEER_IDS.push(id)
+		}
+		const api = config.CONFIG_DELEGATED_API
+		const delegatedClient = createDelegatedRoutingV1HttpApiClient(api)
+		const peers = await Promise.all(
+			BOOTSTRAP_PEER_IDS.map((peerId) => first(delegatedClient.getPeers(peerIdFromString(peerId)))),
+		)
+		for(const peer of peers){
+			const address = peer.Addrs
+			const id = peer.ID
+			let mddrs = []
+			let addrs = []
+			for(const addr of address){
+				const peeraddr = addr.toString()+'/p2p/'+id.toString()
+				const peermddr = multiaddr(peeraddr)
+				addrs.push(peeraddr)
+				mddrs.push(peermddr)
+			}
+			
+			this.#dialedKnownBootstrap.set(id,addrs)
+			if(!this.#isConnected(id)){
+				this.#dialMultiaddress(mddrs)
+			}
+		}
+		
+	}*/
+	
+	
+	//dial based on known bootstrap DNS using DNS resolver only
+	/*async #dialKnownDNSonly(){
+		const dnsresolver = config.CONFIG_DNS_RESOLVER
+		const bootstrapdns = config.CONFIG_KNOWN_BOOTSTRAP_DNS
+		const response = await fetch(dnsresolver+'?name='+bootstrapdns+'&type=txt')
+		const json = await response.json()
+		const dns = json.Answer
+		
+		for(const dnsitem of dns){
+			const arr = dnsitem.data.split('/')
+			const id = arr.pop()
+			const dnsaddr = '_dnsaddr.'+arr[2]
+			this.#dialDNSWebsocketWebtransport(id,dnsaddr)
+		}
+	}*/
+	
+	
+	//dial DNS with webtransport and websocket
+	/*async #dialDNSWebsocketWebtransport(id,dnsaddr){
+		const dnsresolver = config.CONFIG_DNS_RESOLVER
+		const response = await fetch(dnsresolver+'?name='+dnsaddr+'&type=txt')
+		const json = await response.json()
+		const dns = json.Answer
+		let mddrs = []
+		let addrs = []
+		for(const dnsitem of dns){
+			const arr = dnsitem.data.split('=')
+			const dnsaddr = arr[1]
+			const maddr = multiaddr(dnsaddr)
+			mddrs.push(maddr)
+			addrs.push(dnsaddr)
+		}
+		
+		
+		this.#isDialWebsocket = true
+		this.#dialedKnownBootstrap.set(id,addrs)
+		
+		this.#dialedKnownBootstrap.set(id,addrs)
+		if(!this.#isConnected(id)){
+			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) {
+				try {
+				  //console.log(`attempting to dial webtransport multiaddr: %o`, addr.toString())
+				  await this.#libp2p.dial(addr);
+				  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.debug(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) {
+				try {
+				  //console.log(`attempting to dial websocket multiaddr: %o`, addr)
+				  await this.#libp2p.dial(addr);
+				  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.debug(error);
+				}
+			  }
+	}
+	
+	
+	//entry point to webpeerjs
+	static async createWebpeer(){
+
+		// all libp2p debug logs
+		localStorage.setItem('debug', 'libp2p:*');
+		
+		const dbstore = new IDBDatastore(CONFIG_DBSTORE_PATH);
+		await dbstore.open();
+		
+		//let addrs = []
+		const getbootstrap = CONFIG_KNOWN_BOOTSTRAP_PEERS_ADDRS;
+		for(const peer of getbootstrap){
+			const addrs = peer.Peers[0].Addrs;
+			peer.Peers[0].ID;
+			//let mddrs = []
+			for(const addr of addrs){
+				if(addr.includes('webtransport')&&addr.includes('certhash'));
+			}
+		}
+
+		let onMetricsFn = () => {};
+		const onMetrics = f => (onMetricsFn = f);
+		
+		//create libp2p instance
+		const libp2p = await createLibp2p({
+			addresses: {
+				listen: [
+				],
+			},
+			transports:[
+				webTransport(),		
+				circuitRelayTransport({
+					discoverRelays: CONFIG_DISCOVER_RELAYS,
+					reservationConcurrency: 1,
+					maxReservationQueueLength: 3
+				}),
+			],
+			connectionManager: {
+				maxConnections: CONFIG_MAX_CONNECTIONS,
+				minConnections: CONFIG_MIN_CONNECTIONS,
+				autoDialInterval:60e3,
+				autoDialConcurrency:0,
+				autoDialMaxQueueLength:0,
+				autoDialPriority:1000,
+				autoDialDiscoveredPeersDebounce:30e3,
+				maxParallelDials: 3,
+				dialTimeout: 5e3,
+				maxIncomingPendingConnections: 5,
+				maxDialQueueLength:10,
+				inboundConnectionThreshold:3,
+				maxPeerAddrsToDial:2,
+				inboundUpgradeTimeout:5e3
+			},
+			connectionEncryption: [noise()],
+			streamMuxers: [
+				yamux({
+					maxInboundStreams: 50,
+					maxOutboundStreams: 50,
+				})
+			],
+			connectionGater: {
+				filterMultiaddrForPeer: async (peer, multiaddrTest) => {
+					const multiaddrString = multiaddrTest.toString();
+					if (
+						multiaddrString.includes("/ip4/127.0.0.1") ||
+						multiaddrString.includes("/ip6/")
+					) {
+						return false;
+					}
+					return true;
+				},
+				denyDialMultiaddr: async (multiaddrTest) => {
+					const multiaddrString = multiaddrTest.toString();
+					if (
+						multiaddrString.includes("/ip4/127.0.0.1") ||
+						multiaddrString.includes("/ip6/")
+					) {
+						return true;
+					}
+					return false;
+				},
+			},
+			peerDiscovery: [
+				pubsubPeerDiscovery({
+					interval: 10_000,
+					topics: CONFIG_PUBSUB_PEER_DISCOVERY,
+					listenOnly: false,
+				}),
+				
+			],
+			services: {
+				pubsub: gossipsub({
+					allowPublishToZeroTopicPeers: true,
+					msgIdFn: msgIdFnStrictNoSign,
+					ignoreDuplicatePublishError: true,
+				}),
+				identify: identify(),
+				identifyPush: identifyPush(),
+				aminoDHT: kadDHT({
+					protocol: '/ipfs/kad/1.0.0',
+					peerInfoMapper: removePrivateAddressesMapper,
+					clientMode: false
+				}),
+
+			},
+			peerStore: {
+				persistence: true,
+				threshold: 1
+			},
+			metrics: simpleMetrics({
+				onMetrics: (metrics) => {onMetricsFn(metrics);},
+				intervalMs: 1000
+			})
+		});
+		
+		
+		
+		//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)
+	}
+}
+
+export { webpeerjs };