libp2p · achingbrain · Jul 28, 2023 · Nov 22, 2022 · May 4, 2023 · May 31, 2023
diff --git a/doc/CONFIGURATION.md b/doc/CONFIGURATION.md
@@ -4,7 +4,6 @@
 - [Modules](#modules)
   - [Transport](#transport)
   - [Stream Multiplexing](#stream-multiplexing)
-    - [Muxer Selection](#muxer-selection)
   - [Connection Encryption](#connection-encryption)
   - [Peer Discovery](#peer-discovery)
   - [Content Routing](#content-routing)
@@ -30,7 +29,6 @@
     - [Configuring Transport Manager](#configuring-transport-manager)
     - [Configuring Metrics](#configuring-metrics)
     - [Configuring PeerStore](#configuring-peerstore)
-    - [Customizing Transports](#customizing-transports)
     - [Configuring UPnP NAT Traversal](#configuring-upnp-nat-traversal)
       - [Browser support](#browser-support)
       - [UPnP and NAT-PMP](#upnp-and-nat-pmp)
@@ -72,7 +70,9 @@ Some available transports are:
 - [@libp2p/tcp](https://github.com/libp2p/js-libp2p-tcp) (not available in browsers)
 - [@libp2p/webrtc](https://github.com/libp2p/js-libp2p-webrtc)
 - [@libp2p/websockets](https://github.com/libp2p/js-libp2p-websockets)
-- [@libp2p/webtransport](https://github.com/libp2p/js-libp2p-webtransport) (Work in Progress)
+- [@libp2p/webtransport](https://github.com/libp2p/js-libp2p-webtransport)
+- [@libp2p/webrtc-star](https://github.com/libp2p/js-libp2p-webrtc-star) ([Archived](https://github.com/libp2p/js-libp2p-webrtc-star/blob/master/README.md#%EF%B8%8F%EF%B8%8F%EF%B8%8F%EF%B8%8F%EF%B8%8F%EF%B8%8F))
+- [@libp2p/webrtc-direct](https://github.com/libp2p/js-libp2p-webrtc-direct) ([Archived](https://github.com/libp2p/js-libp2p-webrtc-direct/blob/master/README.md#%EF%B8%8F%EF%B8%8F%EF%B8%8F%EF%B8%8F%EF%B8%8F%EF%B8%8F))
 
 If none of the available transports fulfils your needs, you can create a libp2p compatible transport. A libp2p transport just needs to be compliant with the [Transport Interface](https://github.com/libp2p/js-interfaces/tree/master/src/transport).
 
@@ -127,11 +127,9 @@ Some available peer discovery modules are:
 - [@libp2p/mdns](https://github.com/libp2p/js-libp2p-mdns)
 - [@libp2p/bootstrap](https://github.com/libp2p/js-libp2p-bootstrap)
 - [@libp2p/kad-dht](https://github.com/libp2p/js-libp2p-kad-dht)
-- [@libp2p/webrtc-star](https://github.com/libp2p/js-libp2p-webrtc-star)
+- [@libp2p/webrtc-star](https://github.com/libp2p/js-libp2p-webrtc-star) ([Archived](https://github.com/libp2p/js-libp2p-webrtc-star/blob/master/README.md#%EF%B8%8F%EF%B8%8F%EF%B8%8F%EF%B8%8F%EF%B8%8F%EF%B8%8F))
 - [@chainsafe/discv5](https://github.com/chainsafe/discv5)
 
-**Note**: `peer-discovery` services within transports (such as `js-libp2p-webrtc-star`) are automatically gathered from the `transport`, via it's `discovery` property. As such, they do not need to be added in the discovery modules. However, these transports can also be configured and disabled as the other ones.
-
 If none of the available peer discovery protocols fulfills your needs, you can create a libp2p compatible one. A libp2p peer discovery protocol just needs to be compliant with the [Peer Discovery Interface](https://github.com/libp2p/js-interfaces/tree/master/src/peer-discovery).
 
 If you want to know more about libp2p peer discovery, you should read the following content:
@@ -859,72 +857,6 @@ const node = await createLibp2p({
 })
 ```
 
-#### Customizing Transports
-
-Some Transports can be passed additional options when they are created. For example, `libp2p-webrtc-star` accepts an optional, custom `wrtc` implementation. In addition to libp2p passing itself and an `Upgrader` to handle connection upgrading, libp2p will also pass the options, if they are provided, from `config.transport`.
-
-```js
-import { createLibp2p } from 'libp2p'
-import { webRTCStar } from '@libp2p/webrtc-star'
-import { mplex } from '@libp2p/mplex'
-import { yamux } from '@chainsafe/libp2p-yamux'
-import { noise } from '@chainsafe/libp2p-noise'
-import wrtc from 'wrtc'
-
-const webRTC = webRTCStar({
-  wrtc
-})
-
-const node = await createLibp2p({
-  transports: [
-    webRTC.transport
-  ],
-  peerDiscovery: [
-    webRTC.discovery
-  ],
-  streamMuxers: [
-    yamux(),
-    mplex()
-  ],
-  connectionEncryption: [
-    noise()
-  ]
-})
-```
-
-During Libp2p startup, transport listeners will be created for the configured listen multiaddrs.  Some transports support custom listener options and you can set them using the `listenerOptions` in the transport configuration. For example, [libp2p-webrtc-star](https://github.com/libp2p/js-libp2p-webrtc-star) transport listener supports the configuration of its underlying [simple-peer](https://github.com/feross/simple-peer) ice server(STUN/TURN) config as follows:
-
-```js
-const webRTC = webRTCStar({
-  listenerOptions: {
-    config: {
-      iceServers: [
-        {"urls": ["turn:YOUR.TURN.SERVER:3478"], "username": "YOUR.USER", "credential": "YOUR.PASSWORD"},
-        {"urls": ["stun:YOUR.STUN.SERVER:3478"], "username": "", "credential": ""}]
-    }
-  }
-})
-
-const node = await createLibp2p({
-  transports: [
-    webRTC.transport
-  ],
-  peerDiscovery: [
-    webRTC.discovery
-  ],
-  streamMuxers: [
-    yamux(),
-    mplex()
-  ],
-  connectionEncryption: [
-    noise()
-  ],
-  addresses: {
-    listen: ['/dns4/your-wrtc-star.pub/tcp/443/wss/p2p-webrtc-star'] // your webrtc dns multiaddr
-  }
-})
-```
-
 #### Configuring UPnP NAT Traversal
 
 Network Address Translation (NAT) is a function performed by your router to enable multiple devices on your local network to share a single IPv4 address. It's done transparently for outgoing connections, ensuring the correct response traffic is routed to your computer, but if you wish to accept incoming connections some configuration is necessary.

diff --git a/doc/GETTING_STARTED.md b/doc/GETTING_STARTED.md
@@ -175,7 +175,6 @@ For each discovered peer libp2p will emit a `peer:discovery` event which include
 Looking at the [available peer discovery](./CONFIGURATION.md#peer-discovery) protocols, there are several options to be considered:
 - If you already know the addresses of some other network peers, you should consider using `@libp2p/bootstrap` as this is the easiest way of getting your peer into the network.
 - If it is likely that you will have other peers on your local network, `@libp2p/mdns` is a must if you're node is not running in the browser. It allows peers to discover each other when on the same local network.
-- If your application is browser based you can use the `@libp2p/webrtc-star` Transport, which includes a rendezvous based peer sharing service.
 - A random walk approach can be used via `@libp2p/kad-dht`, to crawl the network and find new peers along the way.
 
 For this guide we will configure `@libp2p/bootstrap` as this is useful for joining the public network.

diff --git a/doc/production/README.md b/doc/production/README.md
@@ -8,37 +8,28 @@ This guide aims to guide you from using the public infrastructure into setting u
 
 ## Table of Contents
 
-* [Joining the Network](#joining-the-network)
-* [Connecting to Nodes with connectivity limitations](#connecting-to-nodes-with-connectivity-limitations)
-  * [`webrtc-star` servers](#webrtc-star-servers)
-  * [Circuit Relay](#circuit-relay)
-* [Querying the network from the browser](#querying-the-network-from-the-browser)
-* [Others](#others)
-  * [SSL](#ssl)
+- [Production](#production)
+  - [Table of Contents](#table-of-contents)
+  - [Joining the Network](#joining-the-network)
+  - [Connecting to Nodes with connectivity limitations](#connecting-to-nodes-with-connectivity-limitations)
+    - [Circuit Relay](#circuit-relay)
+  - [Querying the network from the browser](#querying-the-network-from-the-browser)
+  - [Others](#others)
+    - [SSL](#ssl)
 
 ## Joining the Network
 
 Once a libp2p node stars, it will need to connect to a set of peers in order to establish its overlay network.
 
 Currently `js-libp2p` is not the best choice for being a bootstrap node. Its DHT needs to be improved, in order to become an effective server to enable other nodes to properly bootstrap their network.
 
-Setting up a fleet of [`go-libp2p`](https://github.com/libp2p/go-libp2p) nodes is the recommended way to proceed here. 
+Setting up a fleet of [`go-libp2p`](https://github.com/libp2p/go-libp2p) nodes is the recommended way to proceed here.
 
 ## Connecting to Nodes with connectivity limitations
 
 While the libp2p core codebase aims to work in multiple environments, there are some limitations that are not possible to overcome at the time of writing. These limitations include browser nodes, nodes behind NAT, reverse proxies, firewalls, or lack of compatible transports.
 
-In the browser, libp2p supports two transports: `websockets` and `webrtc-star`. Nowadays, browsers do not support listening for connections, but only to dial known addresses. `webrtc-star` servers can be used to enable libp2p nodes to discover other nodes running on the browser and to help them establish a connection.
-
-For nodes that cannot be dialed (including browser), circuit relay nodes should be used.
-
-### `webrtc-star` servers
-
-Regarding `webRTC` connections, a set of star servers are needed to act as a rendezvous point, where peers can learn about other peers (`peer-discovery`), as well as exchange their SDP offers (signaling data).
-
-You can read on how to setup your own star servers in [libp2p/js-libp2p-webrtc-star/DEPLOYMENT.md](https://github.com/libp2p/js-libp2p-webrtc-star/blob/master/DEPLOYMENT.md).
-
-It is worth pointing out that with new discovery protocols on the way, as well as support for distributed signaling, the star servers should be deprecated on the long run.
+In the browser, libp2p supports three transports: `websockets`, `webtransport`, and `webrtc`.
 
 ### Circuit Relay
 

diff --git a/examples/discovery-mechanisms/README.md b/examples/discovery-mechanisms/README.md
@@ -286,6 +286,5 @@ This is really useful when running libp2p in constrained environments like a bro
 
 There are plenty more Peer Discovery Mechanisms out there, you can:
 
-- Find one in [@libp2p/webrtc-star](https://github.com/libp2p/js-libp2p-webrtc-star). Yes, a transport with discovery capabilities! This happens because WebRTC requires a rendezvous point for peers to exchange [SDP](https://tools.ietf.org/html/rfc4317) offer, which means we have one or more points that can introduce peers to each other. Think of it as MulticastDNS for the Web, as in MulticastDNS only works in LAN.
 - Any DHT will offer you a discovery capability. You can simple _random-walk_ the routing tables to find other peers to connect to. For example [@libp2p/kad-dht](https://github.com/libp2p/js-libp2p-kad-dht) can be used for peer discovery. An example of how to configure it to enable random walks can be found [here](https://github.com/libp2p/js-libp2p/blob/v0.28.4/doc/CONFIGURATION.md#customizing-dht).
 - You can create your own Discovery service, a registry, a list, a radio beacon, you name it!
diff --git a/examples/libp2p-in-the-browser/README.md b/examples/libp2p-in-the-browser/README.md
@@ -38,14 +38,7 @@ Server running at http://localhost:1234
 
 This will compile the code and start a server listening on port [http://localhost:1234](http://localhost:1234). Now open your browser to `http://localhost:1234`. You should see a log of your node's Peer ID, the discovered peers from the Bootstrap module, and connections to those peers as they are created.
 
-Now, if you open a second browser tab to `http://localhost:1234`, you should discover your node from the previous tab. This is due to the fact that the `libp2p-webrtc-star` transport also acts as a Peer Discovery interface. Your node will be notified of any peer that connects to the same signaling server you are connected to. Once libp2p discovers this new peer, it will attempt to establish a direct WebRTC connection.
+Now, if you open a second browser tab to `http://localhost:1234`, you should discover your node from the previous tab.
 
 **Note**: In the example we assign libp2p to `window.libp2p`, in case you would like to play around with the API directly in the browser. You can of course make changes to `index.js` and vite will automatically rebuild and reload the browser tabs.
 
-## Going to production?
-
-This example uses public `libp2p-webrtc-star` servers. These servers should be used for experimenting and demos, they **MUST** not be used in production as there is no guarantee on availability.
-
-You can see how to deploy your own signaling server in [libp2p/js-libp2p-webrtc-star/DEPLOYMENT.md](https://github.com/libp2p/js-libp2p-webrtc-star/blob/master/packages/webrtc-star-signalling-server/DEPLOYMENT.md).
-
-Once you have your own server running, you should add its listen address in your libp2p node configuration.