Iroh

https://docs.rs/iroh/0.95.1/iroh/
Admin
Iroh is a Rust library for establishing direct peer-to-peer connectivity between endpoints using...
Tokens:43,644
Snippets:626
Trust Score:9.7
Update:2 months ago
Show doc for...
Tokens:
Raw
### run

Source: https://docs.rs/iroh/0.95.1/iroh/test_utils/struct.DnsPkarrServer.html

Starts the DNS and Pkarr servers on localhost.

```APIDOC
## pub async fn run() -> Result<Self>

### Description
Run DNS and Pkarr servers on localhost.
```

--------------------------------

### run_with_origin

Source: https://docs.rs/iroh/0.95.1/iroh/test_utils/struct.DnsPkarrServer.html

Starts the DNS and Pkarr servers on localhost with a specific endpoint origin.

```APIDOC
## pub async fn run_with_origin(endpoint_origin: String) -> Result<Self>

### Description
Run DNS and Pkarr servers on localhost with the specified `endpoint_origin` domain.
```

--------------------------------

### run_relay_server

Source: https://docs.rs/iroh/0.95.1/iroh/test_utils/fn.run_relay_server.html

Starts a relay server for testing. This function is available only when the 'test-utils' crate feature is enabled.

```APIDOC
## Function: run_relay_server

### Description
Runs a relay server with QUIC enabled, suitable for integration or unit tests. The server stops automatically when the returned `Server` object is dropped.

### Signature
`pub async fn run_relay_server() -> Result<(RelayMap, RelayUrl, Server), SpawnError>`

### Requirements
- **Crate Feature**: `test-utils`

### Returns
- **RelayMap**: The configuration map for the relay server.
- **RelayUrl**: The URL of the relay server.
- **Server**: A handle to the running server instance; dropping this will stop the server.
```

--------------------------------

### Configure DNS and mDNS Discovery

Source: https://docs.rs/iroh/0.95.1/iroh/discovery/index.html

Extends the DNS discovery setup by adding mDNS discovery for local network endpoint resolution. Requires the 'discovery-local-network' feature flag.

```rust
#[cfg(feature = "discovery-local-network")]
let ep = Endpoint::empty_builder(RelayMode::Default)
    .discovery(PkarrPublisher::n0_dns())
    .discovery(DnsDiscovery::n0_dns())
    .discovery(MdnsDiscovery::builder())
    .bind()
    .await?;
```

--------------------------------

### Retrieve Host String

Source: https://docs.rs/iroh/0.95.1/iroh/struct.RelayUrl.html

Get the string representation of a URL host using host_str().

```rust
use url::Url;

let url = Url::parse("https://127.0.0.1/index.html")?;
assert_eq!(url.host_str(), Some("127.0.0.1"));

let url = Url::parse("https://subdomain.example.com")?;
assert_eq!(url.host_str(), Some("subdomain.example.com"));

let url = Url::parse("ftp://rms@example.com")?;
assert_eq!(url.host_str(), Some("example.com"));

let url = Url::parse("unix:/run/foo.socket")?;
assert_eq!(url.host_str(), None);

let url = Url::parse("data:text/plain,Stuff")?;
assert_eq!(url.host_str(), None);
```

--------------------------------

### Initialize and use StaticProvider

Source: https://docs.rs/iroh/0.95.1/iroh/discovery/static_provider/struct.StaticProvider.html

Demonstrates creating a StaticProvider, integrating it into an Endpoint, and adding endpoint information manually.

```rust
use iroh::{Endpoint, EndpointAddr, TransportAddr, discovery::static_provider::StaticProvider};
use iroh_base::SecretKey;

// Create the discovery service and endpoint.
let discovery = StaticProvider::new();

let _ep = Endpoint::builder()
    .discovery(discovery.clone())
    .bind()
    .await?;

// Sometime later add a RelayUrl for our endpoint.
let id = SecretKey::generate(&mut rand::rng()).public();
// You can pass either `EndpointInfo` or `EndpointAddr` to `add_endpoint_info`.
discovery.add_endpoint_info(EndpointAddr {
    id,
    addrs: [TransportAddr::Relay("https://example.com".parse()?)]
        .into_iter()
        .collect(),
});
```

--------------------------------

### Create and use a StaticProvider

Source: https://docs.rs/iroh/0.95.1/iroh/discovery/static_provider/struct.StaticProvider.html

Demonstrates initializing a StaticProvider with endpoint information and using it to configure an iroh Endpoint.

```rust
use std::{net::SocketAddr, str::FromStr};

use iroh::{Endpoint, EndpointAddr, discovery::static_provider::StaticProvider};

// get addrs from somewhere
let addrs = get_addrs();

// create a StaticProvider from the list of addrs.
let discovery = StaticProvider::from_endpoint_info(addrs);
// create an endpoint with the discovery
let endpoint = Endpoint::builder().discovery(discovery).bind().await?;
```

--------------------------------

### Get Remote Endpoint ID

Source: https://docs.rs/iroh/0.95.1/iroh/endpoint/struct.Connecting.html

Returns the identifier of the remote endpoint being connected to.

```rust
pub fn remote_id(&self) -> EndpointId
```

--------------------------------

### Retrieve Port Number

Source: https://docs.rs/iroh/0.95.1/iroh/struct.RelayUrl.html

Get the explicit port number from a URL using port().

```rust
use url::Url;

let url = Url::parse("https://example.com")?;
assert_eq!(url.port(), None);

let url = Url::parse("https://example.com:443/")?;
assert_eq!(url.port(), None);

let url = Url::parse("ssh://example.com:22")?;
assert_eq!(url.port(), Some(22));
```

--------------------------------

### Initialize and Subscribe to MdnsDiscovery

Source: https://docs.rs/iroh/0.95.1/iroh/discovery/mdns/index.html

Demonstrates how to bind an endpoint, register the MdnsDiscovery service, and process discovery events.

```rust
use std::time::Duration;

use iroh::{
    RelayMode, SecretKey,
    discovery::mdns::{DiscoveryEvent, MdnsDiscovery},
    endpoint::{Endpoint, Source},
};
use n0_future::StreamExt;

#[tokio::main]
async fn main() {
    let recent = Duration::from_secs(600); // 10 minutes in seconds
    let endpoint = Endpoint::empty_builder(RelayMode::Disabled)
        .bind()
        .await
        .unwrap();

    // Register the discovery services with the endpoint
    let mdns = MdnsDiscovery::builder().build(endpoint.id()).unwrap();
    endpoint.discovery().add(mdns.clone());

    // Subscribe to the discovery events
    let mut events = mdns.subscribe().await;
    while let Some(event) = events.next().await {
        match event {
            DiscoveryEvent::Discovered { endpoint_info, .. } => {
                println!("MDNS discovered: {:?}", endpoint_info);
            }
            DiscoveryEvent::Expired { endpoint_id } => {
                println!("MDNS expired: {endpoint_id}");
            }
        }
    }
}
```

--------------------------------

### run_relay_server_with

Source: https://docs.rs/iroh/0.95.1/iroh/test_utils/fn.run_relay_server_with.html

Runs a relay server for testing purposes. If quic is set to true, it configures the server with QUIC support using generated TLS certificates and binds to a random free port.

```APIDOC
## Function: run_relay_server_with

### Description
Runs a relay server. If `quic` is set to `true`, it will make the appropriate `QuicConfig` from the generated tls certificates and run the quic server at a random free port.

### Signature
`pub async fn run_relay_server_with(quic: bool) -> Result<(RelayMap, RelayUrl, Server), SpawnError>`

### Parameters
- **quic** (bool) - Required - If true, configures the server for QUIC using generated TLS certificates.

### Returns
- **Result<(RelayMap, RelayUrl, Server), SpawnError>** - Returns a tuple containing the RelayMap, RelayUrl, and the Server instance, or a SpawnError if the server fails to start.

### Requirements
- Available on crate feature `test-utils` only.
```

--------------------------------

### Retrieve Parsed Host

Source: https://docs.rs/iroh/0.95.1/iroh/struct.RelayUrl.html

Get the parsed Host representation of a URL using host().

```rust
use url::Url;

let url = Url::parse("https://127.0.0.1/index.html")?;
assert!(url.host().is_some());

let url = Url::parse("ftp://rms@example.com")?;
assert!(url.host().is_some());

let url = Url::parse("unix:/run/foo.socket")?;
assert!(url.host().is_none());

let url = Url::parse("data:text/plain,Stuff")?;
assert!(url.host().is_none());
```

--------------------------------

### DnsResolver Initialization

Source: https://docs.rs/iroh/0.95.1/iroh/dns/struct.DnsResolver.html

Methods to instantiate a new DnsResolver instance.

```APIDOC
## DnsResolver::new()
Creates a new DNS resolver with sensible cross-platform defaults.

## DnsResolver::with_nameserver(nameserver: SocketAddr)
Creates a new DNS resolver configured with a single UDP DNS nameserver.

## DnsResolver::builder()
Creates a builder to construct a DNS resolver with custom options.

## DnsResolver::custom(resolver: impl Resolver)
Creates a new DnsResolver from a struct that implements the Resolver trait.
```

--------------------------------

### build

Source: https://docs.rs/iroh/0.95.1/iroh/discovery/dns/struct.DnsDiscoveryBuilder.html

Constructs the DnsDiscovery instance using the configured settings.

```APIDOC
## pub fn build(self) -> DnsDiscovery

### Description
Finalizes the configuration and builds a DnsDiscovery instance.
```

--------------------------------

### DhtDiscovery::publish

Source: https://docs.rs/iroh/0.95.1/iroh/discovery/pkarr/dht/struct.DhtDiscovery.html

Publishes endpoint data to the discovery mechanism, starting a background task for periodic updates.

```APIDOC
## pub fn publish(&self, data: &EndpointData)

### Description
Publishes the given EndpointData to the discovery mechanism. This starts a background task that periodically publishes the endpoint address.

### Parameters
- **data** (&EndpointData) - The endpoint information to publish.
```

--------------------------------

### build

Source: https://docs.rs/iroh/0.95.1/iroh/discovery/mdns/struct.MdnsDiscoveryBuilder.html

Builds an MdnsDiscovery instance with the configured settings.

```APIDOC
## pub fn build(self, endpoint_id: EndpointId) -> Result<MdnsDiscovery, IntoDiscoveryError>

### Description
Builds an MdnsDiscovery instance with the configured settings.

### Errors
Returns an error if the network does not allow ipv4 or ipv6.

### Panics
This method relies on tokio::runtime::Handle::current and will panic if called outside of the context of a tokio runtime.
```

--------------------------------

### Retrieve Port or Default

Source: https://docs.rs/iroh/0.95.1/iroh/struct.RelayUrl.html

Get the port number or the known default for common schemes using port_or_known_default().

```rust
use url::Url;

let url = Url::parse("foo://example.com")?;
assert_eq!(url.port_or_known_default(), None);

let url = Url::parse("foo://example.com:1456")?;
assert_eq!(url.port_or_known_default(), Some(1456));

let url = Url::parse("https://example.com")?;
assert_eq!(url.port_or_known_default(), Some(443));
```

--------------------------------

### PkarrRelayClient::new

Source: https://docs.rs/iroh/0.95.1/iroh/discovery/pkarr/struct.PkarrRelayClient.html

Creates a new instance of the PkarrRelayClient.

```APIDOC
### Method
`pub fn new(pkarr_relay_url: Url) -> Self`

### Description
Creates a new client instance configured with the specified pkarr relay URL.
```

--------------------------------

### ConnectOptions

Source: https://docs.rs/iroh/0.95.1/iroh/endpoint/struct.ConnectOptions.html

Configuration options for establishing connections via Endpoint::connect_with_opts.

```APIDOC
## ConnectOptions

### Description
Options for the `Endpoint::connect_with_opts` function. This struct allows customization of transport configurations and ALPN identifiers for a connection.

### Methods

#### new()
Initializes new connection options with default settings.

#### with_transport_config(transport_config: Arc<TransportConfig>)
Sets the QUIC transport config options for this connection.

#### with_additional_alpns(alpns: Vec<Vec<u8>>)
Sets ALPN identifiers that should be signaled as supported on connection, in addition to the main ALPN identifier used in `Endpoint::connect_with_opts`.
```

--------------------------------

### Get default NA west RelayConfig

Source: https://docs.rs/iroh/0.95.1/iroh/defaults/prod/fn.default_na_west_relay.html

Returns the default RelayConfig configuration for the NA west region.

```rust
pub fn default_na_west_relay() -> RelayConfig
```

--------------------------------

### Get default relay mode

Source: https://docs.rs/iroh/0.95.1/iroh/endpoint/fn.default_relay_mode.html

Returns RelayMode::Staging if IROH_FORCE_STAGING_RELAYS is set, otherwise returns RelayMode::Default.

```rust
pub fn default_relay_mode() -> RelayMode
```

--------------------------------

### build

Source: https://docs.rs/iroh/0.95.1/iroh/discovery/pkarr/struct.PkarrResolverBuilder.html

Creates a PkarrResolver instance from the current builder configuration.

```APIDOC
### pub fn build(self) -> PkarrResolver

Creates a PkarrResolver from this builder.
```

--------------------------------

### take

Source: https://docs.rs/iroh/0.95.1/iroh/endpoint/struct.RecvStream.html

Creates an adaptor which reads at most the specified limit of bytes from the stream.

```APIDOC
## fn take(self, limit: u64) -> Take<Self>

### Description
Creates an adaptor which reads at most `limit` bytes from it.
```

--------------------------------

### Implement graceful shutdown for Router

Source: https://docs.rs/iroh/0.95.1/iroh/protocol/struct.Router.html

Demonstrates how to bind an endpoint, spawn a router, and await a shutdown signal to ensure clean termination.

```rust
let endpoint = Endpoint::bind().await?;

let router = Router::builder(endpoint)
    // .accept(&ALPN, <something>)
    .spawn();

// wait until the user wants to
tokio::signal::ctrl_c().await.std_context("ctrl+c")?;
router.shutdown().await.std_context("shutdown")?;
```

--------------------------------

### MdnsDiscovery Usage

Source: https://docs.rs/iroh/0.95.1/iroh/discovery/mdns/index.html

Demonstrates how to initialize MdnsDiscovery, register it with an endpoint, and subscribe to discovery events.

```APIDOC
## MdnsDiscovery

### Description
A discovery service that uses an mdns-like service to discover local endpoints. It allows finding address information about endpoints on the local network.

### Usage
- **Initialization**: Use `MdnsDiscovery::builder().build(endpoint.id())` to create an instance.
- **Registration**: Add the service to an endpoint using `endpoint.discovery().add(mdns)`.
- **Subscription**: Call `mdns.subscribe()` to receive `DiscoveryEvent` updates.

### Events
- **DiscoveryEvent::Discovered**: Emitted when a new endpoint is found.
- **DiscoveryEvent::Expired**: Emitted when a previously discovered endpoint expires.
```

--------------------------------

### Serve Metrics via HTTP Server

Source: https://docs.rs/iroh/0.95.1/iroh/endpoint/struct.Endpoint.html

Launch an HTTP server to serve metrics in the OpenMetrics format using iroh_metrics::service.

```rust
// Create a registry, wrapped in a read-write lock so that we can register and serve
// the metrics independently.
let registry = Arc::new(RwLock::new(Registry::default()));
// Spawn a task to serve the metrics on an OpenMetrics HTTP endpoint.
let metrics_task = tokio::task::spawn({
    let registry = registry.clone();
    async move {
        let addr = "0.0.0.0:9100".parse().unwrap();
        iroh_metrics::service::start_metrics_server(addr, registry).await
    }
});

// Spawn an endpoint and add the metrics to the registry.
let endpoint = Endpoint::bind().await?;
registry.write().unwrap().register_all(endpoint.metrics());

// Wait for the metrics server to bind, then fetch the metrics via HTTP.
tokio::time::sleep(Duration::from_millis(500));
let res = reqwest::get("http://localhost:9100/metrics")
    .await
    .std_context("get")?
    .text()
    .await
    .std_context("text")?;

assert!(res.contains(r#"TYPE magicsock_recv_datagrams counter"#));
assert!(res.contains(r#"magicsock_recv_datagrams_total 0"#));
```

--------------------------------

### Report Implementation Methods

Source: https://docs.rs/iroh/0.95.1/iroh/net_report/struct.Report.html

Helper methods for checking UDP status and NAT mapping consistency.

```rust
pub fn has_udp(&self) -> bool
```

```rust
pub fn mapping_varies_by_dest(&self) -> Option<bool>
```

--------------------------------

### Implement a Protocol Handler and Router

Source: https://docs.rs/iroh/0.95.1/iroh/protocol/index.html

Demonstrates binding an endpoint, configuring a router with a specific ALPN, and implementing the ProtocolHandler trait to echo received bytes.

```rust
let endpoint = Endpoint::bind().await?;

let router = Router::builder(endpoint).accept(b"/my/alpn", Echo).spawn();

// The protocol definition:
#[derive(Debug, Clone)]
struct Echo;

impl ProtocolHandler for Echo {
    async fn accept(&self, connection: Connection) -> Result<(), AcceptError> {
        let (mut send, mut recv) = connection.accept_bi().await?;

        // Echo any bytes received back directly.
        let bytes_sent = tokio::io::copy(&mut recv, &mut send).await?;

        send.finish()?;
        connection.closed().await;

        Ok(())
    }
}
```

--------------------------------

### DiscoveryItem methods

Source: https://docs.rs/iroh/0.95.1/iroh/discovery/struct.DiscoveryItem.html

Methods for creating and interacting with DiscoveryItem instances.

```rust
pub fn new( endpoint_info: EndpointInfo, provenance: &'static str, last_updated: Option<u64>, ) -> Self
```

```rust
pub fn endpoint_id(&self) -> EndpointId
```

```rust
pub fn endpoint_info(&self) -> &EndpointInfo
```

```rust
pub fn provenance(&self) -> &'static str
```

```rust
pub fn last_updated(&self) -> Option<u64>
```

```rust
pub fn to_endpoint_addr(&self) -> EndpointAddr
```

```rust
pub fn into_endpoint_addr(self) -> EndpointAddr
```

```rust
pub fn user_data(&self) -> Option<UserData>
```

--------------------------------

### MtuDiscoveryConfig Configuration Methods

Source: https://docs.rs/iroh/0.95.1/iroh/endpoint/struct.MtuDiscoveryConfig.html

Methods to configure the MTU discovery process for peer connections.

```APIDOC
## MtuDiscoveryConfig Methods

### interval(value: Duration) -> &mut MtuDiscoveryConfig
Specifies the time to wait after completing MTU discovery before starting a new run. Defaults to 600 seconds.

### upper_bound(value: u16) -> &mut MtuDiscoveryConfig
Specifies the upper bound to the max UDP payload size that MTU discovery will search for. Defaults to 1452. The maximum allowed value is 65527.

### black_hole_cooldown(value: Duration) -> &mut MtuDiscoveryConfig
Specifies the amount of time to wait after a black hole is detected before running discovery again. Defaults to one minute.

### minimum_change(value: u16) -> &mut MtuDiscoveryConfig
Specifies the minimum MTU change required to stop the MTU discovery phase. Defaults to 20.
```

--------------------------------

### Create a new AccessLimit

Source: https://docs.rs/iroh/0.95.1/iroh/protocol/struct.AccessLimit.html

Constructor for initializing an AccessLimit with a protocol handler and a filtering function.

```rust
pub fn new<F>(proto: P, limiter: F) -> Self
where F: Fn(EndpointId) -> bool + Send + Sync + 'static,
```

--------------------------------

### From and FromRef Implementations

Source: https://docs.rs/iroh/0.95.1/iroh/endpoint/enum.ConnectionError.html

Standard conversion traits.

```rust
impl<T> From<T> for T
fn from(t: T) -> T
```

```rust
impl<T> FromRef<T> for T
where T: Clone,
fn from_ref(input: &T) -> T
```

--------------------------------

### Accept Connections with an Iroh Endpoint

Source: https://docs.rs/iroh/0.95.1/iroh/index.html

Configures an endpoint with required ALPN protocols to listen for and handle incoming QUIC connections.

```rust
use iroh::{Endpoint, EndpointAddr};
use n0_error::{Result, StackResultExt, StdResultExt};
use n0_future::StreamExt;

async fn accept() -> Result<()> {
    // To accept connections at least one ALPN must be configured.
    let ep = Endpoint::builder()
        .alpns(vec![b"hello-world".to_vec()])
        .bind()
        .await?;

    // Accept a QUIC connection, accept a bi-directional stream, exchange messages.
    let conn = ep
        .accept()
        .await
        .context("no incoming connection")?
        .await
        .context("accept conn")?;
    let (mut send_stream, mut recv_stream) =
        conn.accept_bi().await.std_context("accept stream")?;
    let _msg = recv_stream.read_to_end(10).await.std_context("read")?;
    send_stream.write_all(b"world").await.std_context("write")?;
    send_stream.finish().std_context("finish")?;

    // Wait for the client to close the connection and gracefully close the endpoint.
    conn.closed().await;
    ep.close().await;
    Ok(()) 
}
```

--------------------------------

### Configure DNS Discovery

Source: https://docs.rs/iroh/0.95.1/iroh/discovery/index.html

Enables DNS discovery by adding both a PkarrPublisher and DnsDiscovery to the endpoint builder.

```rust
use iroh::{
    Endpoint, SecretKey,
    discovery::{dns::DnsDiscovery, pkarr::PkarrPublisher},
    endpoint::RelayMode,
};

let ep = Endpoint::empty_builder(RelayMode::Default)
    .discovery(PkarrPublisher::n0_dns())
    .discovery(DnsDiscovery::n0_dns())
    .bind()
    .await?;
```

--------------------------------

### Configure AckFrequencyConfig Parameters

Source: https://docs.rs/iroh/0.95.1/iroh/endpoint/struct.AckFrequencyConfig.html

Methods to configure the acknowledgement frequency parameters for a connection.

```rust
pub fn ack_eliciting_threshold( &mut self, value: VarInt, ) -> &mut AckFrequencyConfig
```

```rust
pub fn max_ack_delay( &mut self, value: Option<Duration>, ) -> &mut AckFrequencyConfig
```

```rust
pub fn reordering_threshold(&mut self, value: VarInt) -> &mut AckFrequencyConfig
```

--------------------------------

### PkarrPublisherBuilder Methods

Source: https://docs.rs/iroh/0.95.1/iroh/discovery/pkarr/struct.PkarrPublisherBuilder.html

Methods available on the PkarrPublisherBuilder to configure and instantiate a PkarrPublisher.

```APIDOC
## PkarrPublisherBuilder Methods

### ttl(self, ttl: u32) -> Self
Sets the TTL (time-to-live) for published packets. Default is DEFAULT_PKARR_TTL.

### republish_interval(self, republish_interval: Duration) -> Self
Sets the interval after which packets are republished even if endpoint info did not change. Default is DEFAULT_REPUBLISH_INTERVAL.

### dns_resolver(self, dns_resolver: DnsResolver) -> Self
Sets the DNS resolver to use for resolving the pkarr relay URL. Available on non-wasm_browser platforms only.

### build(self, secret_key: SecretKey) -> PkarrPublisher
Builds the PkarrPublisher with the provided secret key for signing packets.
```

--------------------------------

### proxy_from_env

Source: https://docs.rs/iroh/0.95.1/iroh/endpoint/struct.Builder.html

Configures proxy settings automatically from environment variables.

```APIDOC
## pub fn proxy_from_env(self) -> Self

### Description
Sets the proxy URL from environment variables in the following order: HTTP_PROXY, http_proxy, HTTPS_PROXY, https_proxy.
```

--------------------------------

### PkarrRelayClient::with_dns_resolver

Source: https://docs.rs/iroh/0.95.1/iroh/discovery/pkarr/struct.PkarrRelayClient.html

Creates a new instance of the PkarrRelayClient with a custom DNS resolver.

```APIDOC
### Method
`pub fn with_dns_resolver(pkarr_relay_url: Url, dns_resolver: DnsResolver) -> Self`

### Description
Creates a new client while passing a DNS resolver to use. Available on non-wasm_browser platforms only.
```

--------------------------------

### Function signature for run_relay_server_with

Source: https://docs.rs/iroh/0.95.1/iroh/test_utils/fn.run_relay_server_with.html

The function signature for spawning a relay server within the test utilities. Requires the 'test-utils' crate feature.

```rust
pub async fn run_relay_server_with(
    quic: bool,
) -> Result<(RelayMap, RelayUrl, Server), SpawnError>
```

--------------------------------

### StaticProvider Methods

Source: https://docs.rs/iroh/0.95.1/iroh/discovery/static_provider/struct.StaticProvider.html

Methods available for managing static endpoint discovery information.

```APIDOC
## StaticProvider::new()

### Description
Creates a new static discovery instance.

## StaticProvider::with_provenance(provenance: &'static str)

### Description
Creates a new static discovery instance with the provided provenance string, which is used for debugging and identifying the origin of addressing information.

## StaticProvider::from_endpoint_info(infos: impl IntoIterator<Item = impl Into<EndpointInfo>>)

### Description
Creates a static discovery instance initialized with a collection of endpoint addresses.

## StaticProvider::set_endpoint_info(endpoint_info: impl Into<EndpointInfo>)

### Description
Sets endpoint addressing information for a given endpoint ID, overwriting any existing data. Returns the previous EndpointData if it existed.

## StaticProvider::add_endpoint_info(endpoint_info: impl Into<EndpointInfo>)

### Description
Augments existing endpoint addressing information for a given endpoint ID by adding new direct addresses and updating the relay URL.

## StaticProvider::get_endpoint_info(endpoint_id: EndpointId)

### Description
Retrieves the current endpoint addressing information for the specified endpoint ID.

## StaticProvider::remove_endpoint_info(endpoint_id: EndpointId)

### Description
Removes all addressing information associated with the specified endpoint ID and returns the removed data.
```

--------------------------------

### PolicyExt Implementation

Source: https://docs.rs/iroh/0.95.1/iroh/endpoint/enum.ReadError.html

Methods for combining policies using logical operators.

```rust
fn and<P, B, E>(self, other: P) -> And<T, P>
fn or<P, B, E>(self, other: P) -> Or<T, P>
```

--------------------------------

### RouterBuilder::spawn

Source: https://docs.rs/iroh/0.95.1/iroh/protocol/struct.RouterBuilder.html

Spawns an accept loop and returns a handle to it as a Router.

```APIDOC
### pub fn spawn(self) -> Router

Spawns an accept loop and returns a handle to it encapsulated as the `Router`.
```

--------------------------------

### Endpoint::accept

Source: https://docs.rs/iroh/0.95.1/iroh/endpoint/struct.Endpoint.html

Accepts an incoming connection on the endpoint.

```APIDOC
## pub fn accept(&self) -> Accept<'_>

### Description
Accepts an incoming connection on the endpoint. Only connections with ALPNs configured in `Builder::alpns` will be accepted.
```

--------------------------------

### AeadKey Open Method

Source: https://docs.rs/iroh/0.95.1/iroh/endpoint/trait.AeadKey.html

Method signature for opening a sealed message.

```rust
fn open<'a>( &self, data: &'a mut [u8], additional_data: &[u8], ) -> Result<&'a mut [u8], CryptoError>
```

--------------------------------

### Endpoint::connect

Source: https://docs.rs/iroh/0.95.1/iroh/index.html

Establishes a connection to a remote peer endpoint using a specified ALPN protocol.

```APIDOC
## Endpoint::connect

### Description
Connects to a remote peer using the provided EndpointAddr and ALPN protocol string.

### Signature
`async fn connect(&self, addr: EndpointAddr, alpn: &[u8]) -> Result<Connection, Error>`

### Parameters
- **addr** (EndpointAddr) - Required - The address of the remote endpoint.
- **alpn** (&[u8]) - Required - The ALPN protocol identifier for the connection.
```

--------------------------------

### Options API

Source: https://docs.rs/iroh/0.95.1/iroh/net_report/struct.Options.html

Methods available for configuring network probe options.

```APIDOC
## Options

### Description
Configuration struct for running network probes. By default, HTTPS probes are enabled.

### Methods

- **disabled() -> Self**: Creates an Options instance that disables all probes.
- **quic_config(quic_config: Option<QuicConfig>) -> Self**: Enables QUIC probes with the provided configuration.
- **https(enable: bool) -> Self**: Enables or disables HTTPS probes.
- **insecure_skip_relay_cert_verify(skip: bool) -> Self**: Skips relay certificate verification (requires `test-utils` feature).
- **as_protocols() -> BTreeSet<Probe>**: Converts the current options into a set of valid protocols.
```

--------------------------------

### discovery

Source: https://docs.rs/iroh/0.95.1/iroh/test_utils/struct.DnsPkarrServer.html

Creates a ConcurrentDiscovery instance configured for the test servers.

```APIDOC
## pub fn discovery(&self, secret_key: SecretKey) -> ConcurrentDiscovery

### Description
Create a `ConcurrentDiscovery` with `DnsDiscovery` and `PkarrPublisher` configured to use the test servers.
```

--------------------------------

### Connect to an Iroh Endpoint

Source: https://docs.rs/iroh/0.95.1/iroh/index.html

Establishes a QUIC connection to a remote endpoint, opens a bidirectional stream, and performs a basic message exchange.

```rust
use iroh::{Endpoint, EndpointAddr};
use n0_error::{Result, StackResultExt, StdResultExt};

async fn connect(addr: EndpointAddr) -> Result<()> {
    // The Endpoint is the central object that manages an iroh node.
    let ep = Endpoint::bind().await?;

    // Establish a QUIC connection, open a bi-directional stream, exchange messages.
    let conn = ep.connect(addr, b"hello-world").await?;
    let (mut send_stream, mut recv_stream) = conn.open_bi().await.std_context("open bi")?;
    send_stream.write_all(b"hello").await.std_context("write")?;
    send_stream.finish().std_context("finish")?;
    let _msg = recv_stream.read_to_end(10).await.std_context("read")?;

    // Gracefully close the connection and endpoint.
    conn.close(1u8.into(), b"done");
    ep.close().await;
    println!("Client closed");
    Ok(())
}
```

--------------------------------

### DnsDiscovery::n0_dns

Source: https://docs.rs/iroh/0.95.1/iroh/discovery/dns/struct.DnsDiscovery.html

Creates a DNS discovery builder configured for the iroh.link domain.

```APIDOC
## pub fn n0_dns() -> DnsDiscoveryBuilder

### Description
Creates a new DNS discovery builder using the production iroh.link domain (N0_DNS_ENDPOINT_ORIGIN_PROD).
```

--------------------------------

### Builder Methods

Source: https://docs.rs/iroh/0.95.1/iroh/discovery/pkarr/dht/struct.Builder.html

Methods available on the Builder struct to configure and initialize DhtDiscovery.

```APIDOC
## Builder Methods

### client(client: PkarrClient) -> Self
Sets the pkarr client to use.

### secret_key(secret_key: SecretKey) -> Self
Sets the secret key to use for signing the DNS packets. Without a secret key, the endpoint will not publish its address to the DHT.

### ttl(ttl: u32) -> Self
Sets the time-to-live value for the DNS packets.

### pkarr_relay(pkarr_relay: Url) -> Self
Sets the pkarr relay URL to use.

### n0_dns_pkarr_relay() -> Self
Uses the default number 0 pkarr relay URL.

### dht(dht: bool) -> Self
Sets whether to publish to the Mainline DHT.

### include_direct_addresses(include_direct_addresses: bool) -> Self
Sets whether to include the direct addresses in the DNS packet.

### republish_delay(republish_delay: Duration) -> Self
Sets the republish delay for the DHT.

### no_publish() -> Self
Disables publishing even if a secret key is set.

### build() -> Result<DhtDiscovery, IntoDiscoveryError>
Builds the discovery mechanism.
```

--------------------------------

### Create relative URLs

Source: https://docs.rs/iroh/0.95.1/iroh/struct.RelayUrl.html

Shows how to generate a relative URL path from a base URL. Returns None if the base and target URLs share different schemes, hosts, or ports.

```rust
use url::Url;

let base = Url::parse("https://example.net/a/b.html")?;
let url = Url::parse("https://example.net/a/c.png")?;
let relative = base.make_relative(&url);
assert_eq!(relative.as_ref().map(|s| s.as_str()), Some("c.png"));

let base = Url::parse("https://example.net/a/b/")?;
let url = Url::parse("https://example.net/a/b/c.png")?;
let relative = base.make_relative(&url);
assert_eq!(relative.as_ref().map(|s| s.as_str()), Some("c.png"));

let base = Url::parse("https://example.net/a/b/")?;
let url = Url::parse("https://example.net/a/d/c.png")?;
let relative = base.make_relative(&url);
assert_eq!(relative.as_ref().map(|s| s.as_str()), Some("../d/c.png"));

let base = Url::parse("https://example.net/a/b.html?c=d")?;
let url = Url::parse("https://example.net/a/b.html?e=f")?;
let relative = base.make_relative(&url);
assert_eq!(relative.as_ref().map(|s| s.as_str()), Some("?e=f"));
```

--------------------------------

### Join paths with RelayUrl base

Source: https://docs.rs/iroh/0.95.1/iroh/struct.RelayUrl.html

Demonstrates how to parse a string as a URL using a RelayUrl as the base. Note that trailing slashes in the base URL affect how path components are resolved.

```rust
use url::Url;

// Base without a trailing slash
let base = Url::parse("https://example.net/a/b.html")?;
let url = base.join("c.png")?;
assert_eq!(url.as_str(), "https://example.net/a/c.png");  // Not /a/b.html/c.png

// Base with a trailing slash
let base = Url::parse("https://example.net/a/b/")?;
let url = base.join("c.png")?;
assert_eq!(url.as_str(), "https://example.net/a/b/c.png");

// Input as scheme relative special URL
let base = Url::parse("https://alice.com/a")?;
let url = base.join("//eve.com/b")?;
assert_eq!(url.as_str(), "https://eve.com/b");

// Input as base url relative special URL
let base = Url::parse("https://alice.com/a")?;
let url = base.join("/v1/meta")?;
assert_eq!(url.as_str(), "https://alice.com/v1/meta");

// Input as absolute URL
let base = Url::parse("https://alice.com/a")?;
let url = base.join("http://eve.com/b")?;
assert_eq!(url.as_str(), "http://eve.com/b");  // http instead of https
```

--------------------------------

### Convert URL to file path

Source: https://docs.rs/iroh/0.95.1/iroh/struct.RelayUrl.html

Convert a file scheme URL to an absolute path. Ensure the scheme is checked before calling.

```rust
let path = url.to_file_path();
```

--------------------------------

### keylog

Source: https://docs.rs/iroh/0.95.1/iroh/endpoint/struct.Builder.html

Enables or disables TLS pre-master key logging for debugging.

```APIDOC
## pub fn keylog(self, keylog: bool) -> Self

### Description
Enables saving the TLS pre-master key for connections. If enabled, the SSLKEYLOGFILE environment variable determines the output file.

### Parameters
- **keylog** (bool) - Required - Whether to enable TLS key logging.
```

--------------------------------

### Retrieve URL Origin

Source: https://docs.rs/iroh/0.95.1/iroh/struct.RelayUrl.html

Demonstrates retrieving the origin of different URL schemes. Note that file URLs return an opaque origin.

```rust
use url::{Host, Origin, Url};

let url = Url::parse("ftp://example.com/foo")?;
assert_eq!(url.origin(),
           Origin::Tuple("ftp".into(),
                         Host::Domain("example.com".into()),
                         21));
```

```rust
use url::{Host, Origin, Url};

let url = Url::parse("blob:https://example.com/foo")?;
assert_eq!(url.origin(),
           Origin::Tuple("https".into(),
                         Host::Domain("example.com".into()),
                         443));
```

```rust
use url::{Host, Origin, Url};

let url = Url::parse("file:///tmp/foo")?;
assert!(!url.origin().is_tuple());

let other_url = Url::parse("file:///tmp/foo")?;
assert!(url.origin() != other_url.origin());
```

```rust
use url::{Host, Origin, Url};

let url = Url::parse("foo:bar")?;
assert!(!url.origin().is_tuple());
```

--------------------------------

### dns_resolver

Source: https://docs.rs/iroh/0.95.1/iroh/test_utils/struct.DnsPkarrServer.html

Creates a DnsResolver configured to use the test DNS server.

```APIDOC
## pub fn dns_resolver(&self) -> DnsResolver

### Description
Create a `DnsResolver` configured to use the test DNS server.
```

--------------------------------

### from_z32

Source: https://docs.rs/iroh/0.95.1/iroh/type.EndpointId.html

Parses a z-base-32 encoded string into a PublicKey.

```APIDOC
## fn from_z32(s: &str) -> Result<PublicKey, DecodingError>

### Description
Parses a `z-base-32` encoded string to return a `PublicKey` instance.

### Parameters
- **s** (&str) - The z-base-32 encoded string to parse.

### Response
- **Result<PublicKey, DecodingError>** - Returns the parsed PublicKey on success, or a DecodingError on failure.
```

--------------------------------

### pub async fn network_change(&self)

Source: https://docs.rs/iroh/0.95.1/iroh/endpoint/struct.Endpoint.html

Notifies the system of potential network changes, useful for platforms that do not automatically expose network change events to native code.

```APIDOC
## pub async fn network_change(&self)

### Description
Notifies the system of potential network changes. This is useful on platforms like Android where network changes may need to be signaled from Java code.

### Parameters
- **self** - Required - The endpoint instance.
```

--------------------------------

### CompatExt Implementation

Source: https://docs.rs/iroh/0.95.1/iroh/endpoint/enum.ConnectionError.html

Provides adapters for compatibility between different types.

```rust
impl<T> CompatExt for T
fn compat(self) -> Compat<T>
fn compat_ref(&self) -> Compat<&T>
fn compat_mut(&mut self) -> Compat<&mut T>
```

--------------------------------

### Configure idle timeout

Source: https://docs.rs/iroh/0.95.1/iroh/endpoint/struct.TransportConfig.html

Demonstrates setting the maximum idle timeout using either VarInt-encoded milliseconds or a Duration.

```rust
let mut config = TransportConfig::default();

// Set the idle timeout as `VarInt`-encoded milliseconds
config.max_idle_timeout(Some(VarInt::from_u32(10_000).into()));

// Set the idle timeout as a `Duration`
config.max_idle_timeout(Some(Duration::from_secs(10).try_into()?));
```

--------------------------------

### discovery

Source: https://docs.rs/iroh/0.95.1/iroh/endpoint/struct.Endpoint.html

Returns the discovery mechanism if configured.

```APIDOC
## pub fn discovery(&self) -> &ConcurrentDiscovery

### Description
Returns the discovery mechanism configured for this Endpoint.
```

--------------------------------

### Configure an Endpoint with N0 preset

Source: https://docs.rs/iroh/0.95.1/iroh/endpoint/presets/index.html

Uses the N0 preset to configure an endpoint with specific defaults before binding.

```rust
use iroh::{Endpoint, RelayMode, Watcher, endpoint::presets};

let endpoint = Endpoint::empty_builder(RelayMode::Disabled)
    .preset(presets::N0)
    .bind()
    .await?;
```

--------------------------------

### pub fn metrics(&self) -> &EndpointMetrics

Source: https://docs.rs/iroh/0.95.1/iroh/endpoint/struct.Endpoint.html

Returns the metrics collected for the endpoint. Requires the 'metrics' crate feature.

```APIDOC
## pub fn metrics(&self) -> &EndpointMetrics

### Description
Returns metrics collected for this endpoint. The returned `EndpointMetrics` struct contains all metrics collected during operation.

### Parameters
- **self** - Required - The endpoint instance.

### Returns
- **&EndpointMetrics** - A reference to the collected metrics.
```

--------------------------------

### Access N0_DNS_ENDPOINT_ORIGIN_PROD constant

Source: https://docs.rs/iroh/0.95.1/iroh/discovery/dns/constant.N0_DNS_ENDPOINT_ORIGIN_PROD.html

Displays the definition of the production DNS endpoint origin constant.

```rust
pub const N0_DNS_ENDPOINT_ORIGIN_PROD: &'static str;
```

--------------------------------

### PublicKey Methods

Source: https://docs.rs/iroh/0.95.1/iroh/struct.PublicKey.html

Methods available for interacting with the PublicKey struct.

```APIDOC
## PublicKey

### as_bytes
Returns the public key as a 32-byte array.

### from_bytes
Constructs a PublicKey from a 32-byte slice. Returns a KeyParsingError if the bytes do not represent a valid curve point.

### verify
Verifies a signature against a message using the public key. Returns Ok(()) if valid, or a SignatureError.

### fmt_short
Returns a displayable object representing the first 5 bytes of the key in hex format.
```

--------------------------------

### Connection Methods

Source: https://docs.rs/iroh/0.95.1/iroh/endpoint/struct.Connection.html

Methods available on the Connection struct for managing and querying connection state.

```APIDOC
## Connection Methods

### max_datagram_size
Computes the maximum size of datagrams that may be passed to `send_datagram`. Returns `None` if datagrams are unsupported.

### datagram_send_buffer_space
Returns the number of bytes available in the outgoing datagram buffer.

### rtt
Returns the current best estimate of the connection's latency (round-trip-time).

### stats
Returns the current connection statistics.

### congestion_state
Returns the current state of the congestion control algorithm.

### handshake_data
Returns parameters negotiated during the handshake.

### alpn
Extracts the ALPN protocol from the peer's handshake data.

### peer_identity
Returns the cryptographic identity of the peer.

### remote_id
Returns the `EndpointId` from the peer's TLS certificate.

### stable_id
Returns a stable identifier for the connection that remains fixed for its lifetime.

### export_keying_material
Derives keying material from the connection's TLS session secrets.

### set_max_concurrent_uni_streams
Modifies the number of unidirectional streams that may be concurrently opened.

### set_receive_window
Configures the receive window size.

### set_max_concurrent_bi_streams
Modifies the number of bidirectional streams that may be concurrently opened.
```

--------------------------------

### Router::builder

Source: https://docs.rs/iroh/0.95.1/iroh/protocol/struct.Router.html

Creates a new Router instance using the provided Endpoint.

```APIDOC
## pub fn builder(endpoint: Endpoint) -> RouterBuilder

### Description
Creates a new `Router` using the given `Endpoint`.

### Parameters
- **endpoint** (Endpoint) - Required - The endpoint to be used by the router.
```

--------------------------------

### PkarrRelayClient::publish

Source: https://docs.rs/iroh/0.95.1/iroh/discovery/pkarr/struct.PkarrRelayClient.html

Publishes a SignedPacket to the relay.

```APIDOC
### Method
`pub async fn publish(&self, signed_packet: &SignedPacket) -> Result<(), PkarrError>`

### Description
Publishes a `SignedPacket` to the pkarr relay.
```

--------------------------------

### Retrieve URL Scheme

Source: https://docs.rs/iroh/0.95.1/iroh/struct.RelayUrl.html

Returns the lower-cased ASCII scheme without the colon delimiter.

```rust
use url::Url;

let url = Url::parse("file:///tmp/foo")?;
assert_eq!(url.scheme(), "file");
```

--------------------------------

### Options struct definition

Source: https://docs.rs/iroh/0.95.1/iroh/net_report/struct.Options.html

The definition of the Options struct used for configuring network probes.

```rust
pub struct Options { /* private fields */ }
```

--------------------------------

### Serialize URL to string

Source: https://docs.rs/iroh/0.95.1/iroh/struct.RelayUrl.html

Retrieves the serialized string representation of the URL.

```rust
use url::Url;

let url_str = "https://example.net/";
let url = Url::parse(url_str)?;
assert_eq!(url.as_str(), url_str);
```

--------------------------------

### Retrieve default EU RelayConfig

Source: https://docs.rs/iroh/0.95.1/iroh/defaults/prod/fn.default_eu_relay.html

Returns the default configuration for the EU relay server.

```rust
pub fn default_eu_relay() -> RelayConfig
```

--------------------------------

### Define AccessLimit structure

Source: https://docs.rs/iroh/0.95.1/iroh/protocol/struct.AccessLimit.html

The internal structure definition for AccessLimit.

```rust
pub struct AccessLimit<P: ProtocolHandler + Clone> { /* private fields */ }
```

--------------------------------

### Signature constants and methods

Source: https://docs.rs/iroh/0.95.1/iroh/struct.Signature.html

Methods for accessing signature length and converting to/from byte arrays.

```rust
pub const LENGTH: usize = 64usize
```

```rust
pub fn to_bytes(&self) -> [u8; 64]
```

```rust
pub fn from_bytes(bytes: &[u8; 64]) -> Signature
```

--------------------------------

### DnsDiscovery::builder

Source: https://docs.rs/iroh/0.95.1/iroh/discovery/dns/struct.DnsDiscovery.html

Creates a new DnsDiscoveryBuilder instance with a specified origin domain.

```APIDOC
## pub fn builder(origin_domain: String) -> DnsDiscoveryBuilder

### Description
Creates a DnsDiscoveryBuilder that implements IntoDiscovery, allowing for custom DNS discovery configurations based on a provided origin domain.

### Parameters
- **origin_domain** (String) - Required - The domain used as the base for DNS TXT record lookups.
```

--------------------------------

### advertise

Source: https://docs.rs/iroh/0.95.1/iroh/discovery/mdns/struct.MdnsDiscoveryBuilder.html

Sets whether the endpoint should advertise its presence. The default value is true.

```APIDOC
## pub fn advertise(self, advertise: bool) -> Self

### Description
Sets whether this endpoint should advertise its presence. Default is true.
```

--------------------------------

### Retrieve URL Username

Source: https://docs.rs/iroh/0.95.1/iroh/struct.RelayUrl.html

Returns the percent-encoded username component.

```rust
use url::Url;

let url = Url::parse("ftp://rms@example.com")?;
assert_eq!(url.username(), "rms");

let url = Url::parse("ftp://:secret123@example.com")?;
assert_eq!(url.username(), "");

let url = Url::parse("https://example.com")?;
assert_eq!(url.username(), "");
```

--------------------------------

### pub async fn close(&self)

Source: https://docs.rs/iroh/0.95.1/iroh/endpoint/struct.Endpoint.html

Closes the QUIC endpoint and the magic socket, ensuring all connections are properly notified.

```APIDOC
## pub async fn close(&self)

### Description
Closes the QUIC endpoint and the magic socket. This method attempts to close all remaining open connections and waits for acknowledgments from peers to ensure a graceful shutdown.

### Usage
It is highly recommended to wait for this future to resolve to prevent remote peers from timing out on their connections.
```

--------------------------------

### Constructing a RelayMap

Source: https://docs.rs/iroh/0.95.1/iroh/struct.RelayMap.html

Create a new RelayMap instance from a collection of RelayUrl objects.

```rust
let relay1 = RelayUrl::from_str("https://relay1.example.org").unwrap();
let relay2 = RelayUrl::from_str("https://relay2.example.org").unwrap();
let map = RelayMap::from_iter(vec![relay1, relay2]);
```

--------------------------------

### Generate a SecretKey

Source: https://docs.rs/iroh/0.95.1/iroh/struct.SecretKey.html

Create a new SecretKey instance using a cryptographically secure random number generator.

```rust
// use the OsRng option for OS depedndent most secure RNG.
let _key = iroh_base::SecretKey::generate(&mut rand::rng());
```

--------------------------------

### DiscoveryError Implementation Methods

Source: https://docs.rs/iroh/0.95.1/iroh/discovery/enum.DiscoveryError.html

Methods for constructing user-defined errors from various error types.

```rust
pub fn from_err<T: Error + Send + Sync + 'static>( provenance: &'static str, source: T, ) -> Self
```

```rust
pub fn from_err_box( provenance: &'static str, source: Box<dyn Error + Send + Sync + 'static>, ) -> Self
```

```rust
pub fn from_err_any( provenance: &'static str, source: impl Into<AnyError>, ) -> Self
```

--------------------------------

### PkarrRelayClient Definition

Source: https://docs.rs/iroh/0.95.1/iroh/discovery/pkarr/struct.PkarrRelayClient.html

The internal structure definition for PkarrRelayClient.

```rust
pub struct PkarrRelayClient { /* private fields */ }
```

--------------------------------

### Retrieve URL query string

Source: https://docs.rs/iroh/0.95.1/iroh/struct.RelayUrl.html

Access the query component of a URL as a percent-encoded string.

```rust
use url::Url;

fn run() -> Result<(), ParseError> {
let url = Url::parse("https://example.com/products?page=2")?;
let query = url.query();
assert_eq!(query, Some("page=2"));

let url = Url::parse("https://example.com/products")?;
let query = url.query();
assert!(query.is_none());

let url = Url::parse("https://example.com/?country=español")?;
let query = url.query();
assert_eq!(query, Some("country=espa%C3%B1ol"));
```

--------------------------------

### CloneToUninit Trait Implementation

Source: https://docs.rs/iroh/0.95.1/iroh/discovery/mdns/enum.DiscoveryEvent.html

Experimental API for performing copy-assignment to uninitialized memory.

```rust
impl<T> CloneToUninit for T
where T: Clone,

unsafe fn clone_to_uninit(&self, dest: *mut u8)
```

--------------------------------

### PublicKey Implementation Methods

Source: https://docs.rs/iroh/0.95.1/iroh/type.EndpointId.html

Methods available on the PublicKey type, which EndpointId inherits.

```rust
pub const LENGTH: usize = 32usize
```

```rust
pub fn as_bytes(&self) -> &[u8; 32]
```

```rust
pub fn from_bytes(bytes: &[u8; 32]) -> Result<PublicKey, KeyParsingError>
```

```rust
pub fn verify( &self, message: &[u8], signature: &Signature, ) -> Result<(), SignatureError>
```

```rust
pub fn fmt_short(&self) -> impl Display + 'static
```

--------------------------------

### From and Into Trait Implementations

Source: https://docs.rs/iroh/0.95.1/iroh/discovery/mdns/enum.DiscoveryEvent.html

Standard conversion traits for type transformation.

```rust
impl<T> From<T> for T

fn from(t: T) -> T
```

```rust
impl<T, U> Into<U> for T
where U: From<T>,

fn into(self) -> U
```

--------------------------------

### MdnsDiscovery::builder

Source: https://docs.rs/iroh/0.95.1/iroh/discovery/mdns/struct.MdnsDiscovery.html

Returns a MdnsDiscoveryBuilder instance that implements IntoDiscovery.

```APIDOC
### Method
`pub fn builder() -> MdnsDiscoveryBuilder`

### Description
Returns a `MdnsDiscoveryBuilder` that implements `IntoDiscovery`.
```

--------------------------------

### AeadKey Seal Method

Source: https://docs.rs/iroh/0.95.1/iroh/endpoint/trait.AeadKey.html

Method signature for sealing message data.

```rust
fn seal( &self, data: &mut Vec<u8>, additional_data: &[u8], ) -> Result<(), CryptoError>
```

--------------------------------

### Encode Metrics to OpenMetrics Format

Source: https://docs.rs/iroh/0.95.1/iroh/endpoint/struct.Endpoint.html

Register endpoint metrics with an iroh_metrics::Registry and encode them into the OpenMetrics text format.

```rust
let endpoint = Endpoint::bind().await?;
let mut registry = Registry::default();
registry.register_all(endpoint.metrics());
let s = registry.encode_openmetrics_to_string()?;
assert!(s.contains(r#"TYPE magicsock_recv_datagrams counter"#));
assert!(s.contains(r#"magicsock_recv_datagrams_total 0"#));
```

--------------------------------

### Retrieve URL path as percent-encoded string

Source: https://docs.rs/iroh/0.95.1/iroh/struct.RelayUrl.html

Access the path component of a URL. For base-capable URLs, this returns a slash-separated string.

```rust
use url::{Url, ParseError};

let url = Url::parse("https://example.com/api/versions?page=2")?;
assert_eq!(url.path(), "/api/versions");

let url = Url::parse("https://example.com")?;
assert_eq!(url.path(), "/");

let url = Url::parse("https://example.com/countries/việt nam")?;
assert_eq!(url.path(), "/countries/vi%E1%BB%87t%20nam");
```

--------------------------------

### ServerConfig Struct Definition

Source: https://docs.rs/iroh/0.95.1/iroh/endpoint/struct.ServerConfig.html

The structure definition for ServerConfig, containing transport, crypto, and validation token configurations.

```rust
pub struct ServerConfig {
    pub transport: Arc<TransportConfig>,
    pub crypto: Arc<dyn ServerConfig>,
    pub validation_token: ValidationTokenConfig,
    /* private fields */
}
```

--------------------------------

### pub fn is_closed(&self) -> bool

Source: https://docs.rs/iroh/0.95.1/iroh/endpoint/struct.Endpoint.html

Checks the current status of the endpoint.

```APIDOC
## pub fn is_closed(&self) -> bool

### Description
Returns a boolean indicating whether the endpoint is still alive or has been closed.
```

--------------------------------

### Endpoint::builder

Source: https://docs.rs/iroh/0.95.1/iroh/endpoint/struct.Endpoint.html

Returns a builder for an Endpoint with a production configuration.

```APIDOC
## pub fn builder() -> Builder

### Description
Returns the builder for an `Endpoint`, with a production configuration using `presets::N0`.
```
Tokens:
Raw