add local discovery section and quickstart example

Author: okdistribute

concepts/discovery.mdx

@@ -131,3 +131,13 @@ iroh natively, see below for our plans).
 DNS servers that support this spec will receive these Pkarr signed packets,
 check their signature and format validity, and then serve each contained record,
 with the DNS server's configured *origin domain* appended to all record names.
+
+
+## Local Discovery
+
+Global servers aren't the only way to find other iroh endpoint. Iroh also supports local
+discovery, where endpoints on the same local network can find each other &
+exchange dialing information without a relay using mDNS.  This is useful for
+offline environments, or for bootstrapping a network before a relay is available. For
+more info on configuring local discovery, see the [local discovery
+documentation](/connecting/local-discovery).

concepts/relays.mdx

@@ -37,12 +37,3 @@ rate-limit traffic that flows through the relay. This is to prevent abuse, and
 ensure the relays are available to everyone. If you need more capacity, you can
 run your own relay server, or [contact us about a custom relay
 setup](https://n0.computer/n0ps/).
-
-## Local Discovery
-
-Relays aren't the only way to find other iroh endpoint. Iroh also supports local
-[discovery](/concepts/discovery), where endpoints on the same local network
-can find each other & exchange dialing information without a relay using mDNS.
-This is useful for local networks, or for bootstrapping a network before a relay
-is available. For more info on configuring local discovery, see the [local
-discovery docs](https://docs.rs/iroh/latest/iroh/discovery/mdns/index.html).

connecting/local-discovery.mdx

@@ -32,8 +32,14 @@ let ep = Endpoint::builder()
     .await?;
 ```
 
+The mDNS discovery mechanism will automatically broadcast your endpoint's
+presence on the local network, and listen for other endpoints doing the same. When
+another endpoint is discovered, the dialing information is exchanged, and a
+connection can be established directly over the local network without needing a relay.
+
+For more information on how mDNS discovery works, see the [mDNS documentation](https://docs.rs/iroh/latest/iroh/discovery/mdns/index.html).
 
 ## Bluetooth
 
 Bluetooth discovery is currently under development and will be available in a
-future release of iroh. For more information, please [contact us](https://cal.com/team/number-0/n0-protocol-services).
+future release of iroh. For more information, please [contact us](https://cal.com/team/number-0/n0-protocol-services).

quickstart.rs

@@ -0,0 +1,63 @@
+use anyhow::{anyhow, Result};
+use iroh::{Endpoint, protocol::Router};
+use iroh_ping::Ping;
+use iroh_tickets::{Ticket, endpoint::EndpointTicket};
+use std::env;
+
+async fn run_receiver() -> Result<()> {
+    // Create an endpoint, it allows creating and accepting
+    // connections in the iroh p2p world
+    let endpoint = Endpoint::builder().bind().await?;
+
+    // bring the endpoint online before accepting connections
+    endpoint.online().await;
+
+    // Then we initialize a struct that can accept ping requests over iroh connections
+    let ping = Ping::new();
+
+    // get the address of this endpoint to share with the sender
+    let ticket = EndpointTicket::new(endpoint.addr());
+    println!("{ticket}");
+
+    // receiving ping requests
+    Router::builder(endpoint)
+        .accept(iroh_ping::ALPN, ping)
+        .spawn();
+
+    // Keep the receiver running indefinitely
+    loop {
+        tokio::time::sleep(tokio::time::Duration::from_secs(60)).await;
+    }
+
+}
+
+async fn run_sender(ticket: EndpointTicket) -> Result<()> {
+    // create a send side & send a ping
+    let send_ep = Endpoint::builder().bind().await?;
+    let send_pinger = Ping::new();
+    let rtt = send_pinger.ping(&send_ep, ticket.endpoint_addr().clone()).await?;
+    println!("ping took: {:?} to complete", rtt);
+    Ok(())
+}
+
+#[tokio::main]
+async fn main() -> Result<()> {
+    let mut args = env::args().skip(1);
+    let role = args
+        .next()
+        .ok_or_else(|| anyhow!("expected 'receiver' or 'sender' as the first argument"))?;
+
+    match role.as_str() {
+        "receiver" => run_receiver().await,
+        "sender" => {
+            let ticket_str = args
+                .next()
+                .ok_or_else(|| anyhow!("expected ticket as the second argument"))?;
+            let ticket = EndpointTicket::deserialize(&ticket_str)
+                .map_err(|e| anyhow!("failed to parse ticket: {}", e))?;
+
+            run_sender(ticket).await
+        }
+        _ => Err(anyhow!("unknown role '{}'; use 'receiver' or 'sender'", role)),
+    }
+}