Remove .preset(presets::N0) since it is implied by .builder()

Author: rklaehn

examples/compression.rs

@@ -8,7 +8,7 @@ use std::{fmt::Debug, path::PathBuf};
 use anyhow::Result;
 use clap::Parser;
 use common::setup_logging;
-use iroh::{endpoint::presets, protocol::ProtocolHandler};
+use iroh::protocol::ProtocolHandler;
 use iroh_blobs::{
     api::Store,
     get::StreamPair,
@@ -184,11 +184,7 @@ async fn main() -> Result<()> {
     setup_logging();
     let args = Args::parse();
     let secret = get_or_generate_secret_key()?;
-    let endpoint = iroh::Endpoint::builder()
-        .secret_key(secret)
-        .preset(presets::N0)
-        .bind()
-        .await?;
+    let endpoint = iroh::Endpoint::builder().secret_key(secret).bind().await?;
     let compression = lz4::Compression;
     match args {
         Args::Provide { path } => {

examples/custom-protocol.rs

@@ -44,7 +44,7 @@ use anyhow::Result;
 use clap::Parser;
 use iroh::{
     discovery::pkarr::PkarrResolver,
-    endpoint::{presets, Connection},
+    endpoint::Connection,
     protocol::{AcceptError, ProtocolHandler, Router},
     Endpoint, EndpointId,
 };
@@ -87,11 +87,7 @@ async fn listen(text: Vec<String>) -> Result<()> {
     // Use an in-memory store for this example. You would use a persistent store in production code.
     let store = MemStore::new();
     // Create an endpoint with the secret key and discovery publishing to the n0 dns server enabled.
-    let endpoint = Endpoint::builder()
-        .secret_key(secret_key)
-        .preset(presets::N0)
-        .bind()
-        .await?;
+    let endpoint = Endpoint::builder().secret_key(secret_key).bind().await?;
     // Build our custom protocol handler. The `builder` exposes access to various subsystems in the
     // iroh node. In our case, we need a blobs client and the endpoint.
     let proto = BlobSearch::new(&store);
@@ -124,7 +120,10 @@ async fn query(endpoint_id: EndpointId, query: String) -> Result<()> {
     // Create an endpoint with a random secret key and no discovery publishing.
     // For a client we just need discovery resolution via the n0 dns server, which
     // the PkarrResolver provides.
-    let endpoint = Endpoint::builder().preset(presets::N0).bind().await?;
+    let endpoint = Endpoint::empty_builder(iroh::RelayMode::Default)
+        .discovery(PkarrResolver::n0_dns())
+        .bind()
+        .await?;
     // Query the remote node.
     // This will send the query over our custom protocol, read hashes on the reply stream,
     // and download each hash over iroh-blobs.

examples/limit.rs

@@ -21,7 +21,7 @@ use std::{
 use anyhow::Result;
 use clap::Parser;
 use common::setup_logging;
-use iroh::{endpoint::presets, protocol::Router, EndpointAddr, EndpointId, SecretKey};
+use iroh::{protocol::Router, EndpointAddr, EndpointId, SecretKey};
 use iroh_blobs::{
     provider::events::{
         AbortReason, ConnectMode, EventMask, EventSender, ProviderMessage, RequestMode,
@@ -231,11 +231,7 @@ async fn main() -> Result<()> {
     setup_logging();
     let args = Args::parse();
     let secret = get_or_generate_secret_key()?;
-    let endpoint = iroh::Endpoint::builder()
-        .secret_key(secret)
-        .preset(presets::N0)
-        .bind()
-        .await?;
+    let endpoint = iroh::Endpoint::builder().secret_key(secret).bind().await?;
     match args {
         Args::Get { ticket } => {
             let connection = endpoint
@@ -352,11 +348,7 @@ async fn add_paths(store: &MemStore, paths: Vec<PathBuf>) -> Result<HashMap<Path
 
 async fn setup(store: MemStore, events: EventSender) -> Result<(Router, EndpointAddr)> {
     let secret = get_or_generate_secret_key()?;
-    let endpoint = iroh::Endpoint::builder()
-        .preset(presets::N0)
-        .secret_key(secret)
-        .bind()
-        .await?;
+    let endpoint = iroh::Endpoint::builder().secret_key(secret).bind().await?;
     endpoint.online().await;
     let addr = endpoint.addr();
     let blobs = BlobsProtocol::new(&store, Some(events));

examples/mdns-discovery.rs

@@ -136,7 +136,11 @@ async fn main() -> anyhow::Result<()> {
         Commands::Accept { path } => {
             accept(path).await?;
         }
-        Commands::Connect { endpoint_id, hash, out } => {
+        Commands::Connect {
+            endpoint_id,
+            hash,
+            out,
+        } => {
             connect(*endpoint_id, *hash, out.clone()).await?;
         }
     }

examples/transfer.rs

@@ -1,13 +1,13 @@
 use std::path::PathBuf;
 
-use iroh::{endpoint::presets, protocol::Router, Endpoint};
+use iroh::{protocol::Router, Endpoint};
 use iroh_blobs::{store::mem::MemStore, ticket::BlobTicket, BlobsProtocol};
 
 #[tokio::main]
 async fn main() -> anyhow::Result<()> {
     // Create an endpoint, it allows creating and accepting
     // connections in the iroh p2p world
-    let endpoint = Endpoint::builder().preset(presets::N0).bind().await?;
+    let endpoint = Endpoint::builder().bind().await?;
 
     // We initialize an in-memory backing store for iroh-blobs
     let store = MemStore::new();

src/tests.rs

@@ -2,10 +2,7 @@ use std::{collections::HashSet, io, ops::Range, path::PathBuf};
 
 use bao_tree::ChunkRanges;
 use bytes::Bytes;
-use iroh::{
-    discovery::static_provider::StaticProvider, endpoint::presets, protocol::Router, Endpoint,
-    EndpointId,
-};
+use iroh::{discovery::static_provider::StaticProvider, protocol::Router, Endpoint, EndpointId};
 use irpc::RpcMessage;
 use n0_future::{task::AbortOnDropHandle, StreamExt};
 use tempfile::TempDir;
@@ -615,14 +612,14 @@ async fn node_serve_hash_seq() -> TestResult<()> {
     let hash_seq = tts.iter().map(|x| x.hash).collect::<HashSeq>();
     let root_tt = store.add_bytes(hash_seq).await?;
     let root = root_tt.hash;
-    let endpoint = Endpoint::builder().preset(presets::N0).bind().await?;
+    let endpoint = Endpoint::builder().bind().await?;
     let blobs = crate::net_protocol::BlobsProtocol::new(&store, None);
     let r1 = Router::builder(endpoint)
         .accept(crate::protocol::ALPN, blobs)
         .spawn();
     let addr1 = r1.endpoint().addr();
     info!("node addr: {addr1:?}");
-    let endpoint2 = Endpoint::builder().preset(presets::N0).bind().await?;
+    let endpoint2 = Endpoint::builder().bind().await?;
     let conn = endpoint2.connect(addr1, crate::protocol::ALPN).await?;
     let (hs, sizes) = get::request::get_hash_seq_and_sizes(&conn, &root, 1024, None).await?;
     println!("hash seq: {hs:?}");
@@ -646,14 +643,14 @@ async fn node_serve_blobs() -> TestResult<()> {
     for size in sizes {
         tts.push(store.add_bytes(test_data(size)).await?);
     }
-    let endpoint = Endpoint::builder().preset(presets::N0).bind().await?;
+    let endpoint = Endpoint::builder().bind().await?;
     let blobs = crate::net_protocol::BlobsProtocol::new(&store, None);
     let r1 = Router::builder(endpoint)
         .accept(crate::protocol::ALPN, blobs)
         .spawn();
     let addr1 = r1.endpoint().addr();
     info!("node addr: {addr1:?}");
-    let endpoint2 = Endpoint::builder().preset(presets::N0).bind().await?;
+    let endpoint2 = Endpoint::builder().bind().await?;
     let conn = endpoint2.connect(addr1, crate::protocol::ALPN).await?;
     for size in sizes {
         let expected = test_data(size);
@@ -686,14 +683,14 @@ async fn node_smoke_mem() -> TestResult<()> {
 async fn node_smoke(store: &Store) -> TestResult<()> {
     let tt = store.add_bytes(b"hello world".to_vec()).temp_tag().await?;
     let hash = tt.hash();
-    let endpoint = Endpoint::builder().preset(presets::N0).bind().await?;
+    let endpoint = Endpoint::builder().bind().await?;
     let blobs = crate::net_protocol::BlobsProtocol::new(store, None);
     let r1 = Router::builder(endpoint)
         .accept(crate::protocol::ALPN, blobs)
         .spawn();
     let addr1 = r1.endpoint().addr();
     info!("node addr: {addr1:?}");
-    let endpoint2 = Endpoint::builder().preset(presets::N0).bind().await?;
+    let endpoint2 = Endpoint::builder().bind().await?;
     let conn = endpoint2.connect(addr1, crate::protocol::ALPN).await?;
     let (size, stats) = get::request::get_unverified_size(&conn, &hash).await?;
     info!("size: {} stats: {:?}", size, stats);