feat: Remove endpoint from protocol constructor. (#181)

## Description

Remove endpoint from protocol constructor.

It was only needed for creating tickets, which is used almost nowhere.
To serve a protocol you just need the store, nothing else.

If you want to create a BlobTicket, just do it manually.

## Breaking Changes

BlobsProtocol::new now takes just store and events
BlobsProtocol::endpoint is removed
BlobsProtocol::ticket is removed
api::TempTag::inner is removed
api::TempTag::hash returns a value instead of a reference
api::TempTag::format returns a value instead of a reference
api::TempTag::hash_and_format returns a value instead of a reference

## Notes & open questions

None

## Change checklist

- [ ] Self-review.
- [ ] Documentation updates following the [style
guide](https://rust-lang.github.io/rfcs/1574-more-api-documentation-conventions.html#appendix-a-full-conventions-text),
if relevant.
- [ ] Tests if relevant.
- [ ] All breaking changes documented.

Author: rklaehn

Cargo.lock

@@ -27,7 +27,7 @@ tokio = { version = "1.43.0", features = ["full"] }
 tokio-util = { version = "0.7.13", features = ["full"] }
 tracing = "0.1.41"
 iroh-io = "0.6.1"
-rand = "0.8.5"
+rand = "0.9.2"
 hex = "0.4.3"
 serde = "1.0.217"
 postcard = { version = "1.1.1", features = ["experimental-derive", "use-std"] }

Cargo.toml

@@ -34,7 +34,7 @@ Here is a basic example of how to set up `iroh-blobs` with `iroh`:
 
 ```rust,no_run
 use iroh::{protocol::Router, Endpoint};
-use iroh_blobs::{store::mem::MemStore, BlobsProtocol};
+use iroh_blobs::{store::mem::MemStore, BlobsProtocol, ticket::BlobTicket};
 
 #[tokio::main]
 async fn main() -> anyhow::Result<()> {
@@ -44,15 +44,19 @@ async fn main() -> anyhow::Result<()> {
 
     // create a protocol handler using an in-memory blob store.
     let store = MemStore::new();
-    let blobs = BlobsProtocol::new(&store, endpoint.clone(), None);
+    let tag = store.add_slice(b"Hello world").await?;
+  
+    let _ = endpoint.online().await;
+    let addr = endpoint.node_addr();
+    let ticket = BlobTicket::new(addr, tag.hash, tag.format);
 
     // build the router
+    let blobs = BlobsProtocol::new(&store, None);
     let router = Router::builder(endpoint)
-        .accept(iroh_blobs::ALPN, blobs.clone())
+        .accept(iroh_blobs::ALPN, blobs)
         .spawn();
 
-    let tag = blobs.add_slice(b"Hello world").await?;
-    println!("We are now serving {}", blobs.ticket(tag).await?);
+    println!("We are now serving {}", ticket);
 
     // wait for control-c
     tokio::signal::ctrl_c().await;

README.md

@@ -9,13 +9,12 @@ pub fn get_or_generate_secret_key() -> Result<SecretKey> {
     use std::{env, str::FromStr};
 
     use anyhow::Context;
-    use rand::thread_rng;
     if let Ok(secret) = env::var("IROH_SECRET") {
         // Parse the secret key from string
         SecretKey::from_str(&secret).context("Invalid secret key format")
     } else {
         // Generate a new random key
-        let secret_key = SecretKey::generate(&mut thread_rng());
+        let secret_key = SecretKey::generate(&mut rand::rng());
         println!(
             "Generated new secret key: {}",
             hex::encode(secret_key.to_bytes())

examples/common/mod.rs

@@ -100,7 +100,7 @@ async fn listen(text: Vec<String>) -> Result<()> {
         proto.insert_and_index(text).await?;
     }
     // Build the iroh-blobs protocol handler, which is used to download blobs.
-    let blobs = BlobsProtocol::new(&store, endpoint.clone(), None);
+    let blobs = BlobsProtocol::new(&store, None);
 
     // create a router that handles both our custom protocol and the iroh-blobs protocol.
     let node = Router::builder(endpoint)

examples/custom-protocol.rs

@@ -162,14 +162,14 @@ async fn main() -> anyhow::Result<()> {
         let expires_at = SystemTime::now()
             .checked_add(Duration::from_secs(10))
             .unwrap();
-        create_expiring_tag(&store, &[*a.hash(), *b.hash()], "expiring", expires_at).await?;
+        create_expiring_tag(&store, &[a.hash(), b.hash()], "expiring", expires_at).await?;
 
         // add a single blob and tag it with an expiry date 60 seconds in the future
         let c = batch.add_bytes("blob 3".as_bytes()).await?;
         let expires_at = SystemTime::now()
             .checked_add(Duration::from_secs(60))
             .unwrap();
-        create_expiring_tag(&store, &[*c.hash()], "expiring", expires_at).await?;
+        create_expiring_tag(&store, &[c.hash()], "expiring", expires_at).await?;
         // batch goes out of scope, so data is only protected by the tags we created
     }
 

examples/expiring-tags.rs

@@ -21,7 +21,7 @@ use std::{
 use anyhow::Result;
 use clap::Parser;
 use common::setup_logging;
-use iroh::{protocol::Router, NodeAddr, NodeId, SecretKey, Watcher};
+use iroh::{protocol::Router, NodeAddr, NodeId, SecretKey};
 use iroh_blobs::{
     provider::events::{
         AbortReason, ConnectMode, EventMask, EventSender, ProviderMessage, RequestMode,
@@ -31,7 +31,7 @@ use iroh_blobs::{
     ticket::BlobTicket,
     BlobFormat, BlobsProtocol, Hash,
 };
-use rand::thread_rng;
+use rand::rng;
 
 use crate::common::get_or_generate_secret_key;
 
@@ -255,7 +255,7 @@ async fn main() -> Result<()> {
             let mut allowed_nodes = allowed_nodes.into_iter().collect::<HashSet<_>>();
             if secrets > 0 {
                 println!("Generating {secrets} new secret keys for allowed nodes:");
-                let mut rand = thread_rng();
+                let mut rand = rng();
                 for _ in 0..secrets {
                     let secret = SecretKey::generate(&mut rand);
                     let public = secret.public();
@@ -357,9 +357,9 @@ async fn setup(store: MemStore, events: EventSender) -> Result<(Router, NodeAddr
         .secret_key(secret)
         .bind()
         .await?;
-    let _ = endpoint.home_relay().initialized().await;
-    let addr = endpoint.node_addr().initialized().await;
-    let blobs = BlobsProtocol::new(&store, endpoint.clone(), Some(events));
+    endpoint.online().await;
+    let addr = endpoint.node_addr();
+    let blobs = BlobsProtocol::new(&store, Some(events));
     let router = Router::builder(endpoint)
         .accept(iroh_blobs::ALPN, blobs)
         .spawn();

examples/limit.rs

@@ -68,7 +68,7 @@ async fn accept(path: &Path) -> Result<()> {
         .await?;
     let builder = Router::builder(endpoint.clone());
     let store = MemStore::new();
-    let blobs = BlobsProtocol::new(&store, endpoint.clone(), None);
+    let blobs = BlobsProtocol::new(&store, None);
     let builder = builder.accept(iroh_blobs::ALPN, blobs.clone());
     let node = builder.spawn();
 
@@ -87,7 +87,7 @@ async fn accept(path: &Path) -> Result<()> {
 }
 
 async fn connect(node_id: PublicKey, hash: Hash, out: Option<PathBuf>) -> Result<()> {
-    let key = SecretKey::generate(rand::rngs::OsRng);
+    let key = SecretKey::generate(&mut rand::rng());
     // todo: disable discovery publishing once https://github.com/n0-computer/iroh/issues/3401 is implemented
     let discovery = MdnsDiscovery::builder();
 

examples/mdns-discovery.rs

@@ -2,7 +2,7 @@ use std::{env, path::PathBuf, str::FromStr};
 
 use anyhow::{Context, Result};
 use clap::{Parser, Subcommand};
-use iroh::{SecretKey, Watcher};
+use iroh::{discovery::static_provider::StaticProvider, SecretKey};
 use iroh_base::ticket::NodeTicket;
 use iroh_blobs::{
     api::downloader::Shuffled,
@@ -93,7 +93,7 @@ pub fn get_or_generate_secret_key() -> Result<SecretKey> {
         SecretKey::from_str(&secret).context("Invalid secret key format")
     } else {
         // Generate a new random key
-        let secret_key = SecretKey::generate(&mut rand::thread_rng());
+        let secret_key = SecretKey::generate(&mut rand::rng());
         let secret_key_str = hex::encode(secret_key.to_bytes());
         println!("Generated new random secret key");
         println!("To reuse this key, set the IROH_SECRET={secret_key_str}");
@@ -204,20 +204,20 @@ async fn provide(args: ProvideArgs) -> anyhow::Result<()> {
     println!("Using store at: {}", path.display());
     let mut rng = match args.common.seed {
         Some(seed) => StdRng::seed_from_u64(seed),
-        None => StdRng::from_entropy(),
+        None => StdRng::from_rng(&mut rand::rng()),
     };
     let blobs = create_random_blobs(
         &store,
         args.num_blobs,
-        |_, rand| rand.gen_range(1..=args.blob_size),
+        |_, rand| rand.random_range(1..=args.blob_size),
         &mut rng,
     )
     .await?;
     let hs = add_hash_sequences(
         &store,
         &blobs,
         args.hash_seqs,
-        |_, rand| rand.gen_range(1..=args.hash_seq_size),
+        |_, rand| rand.random_range(1..=args.hash_seq_size),
         &mut rng,
     )
     .await?;
@@ -238,11 +238,11 @@ async fn provide(args: ProvideArgs) -> anyhow::Result<()> {
         .bind()
         .await?;
     let (dump_task, events_tx) = dump_provider_events(args.allow_push);
-    let blobs = iroh_blobs::BlobsProtocol::new(&store, endpoint.clone(), Some(events_tx));
+    let blobs = iroh_blobs::BlobsProtocol::new(&store, Some(events_tx));
     let router = iroh::protocol::Router::builder(endpoint.clone())
         .accept(iroh_blobs::ALPN, blobs)
         .spawn();
-    let addr = router.endpoint().node_addr().initialized().await;
+    let addr = router.endpoint().node_addr();
     let ticket = NodeTicket::from(addr.clone());
     println!("Node address: {addr:?}");
     println!("ticket:\n{ticket}");
@@ -265,10 +265,14 @@ async fn request(args: RequestArgs) -> anyhow::Result<()> {
         .unwrap_or_else(|| tempdir.as_ref().unwrap().path().to_path_buf());
     let store = FsStore::load(&path).await?;
     println!("Using store at: {}", path.display());
-    let endpoint = iroh::Endpoint::builder().bind().await?;
+    let sp = StaticProvider::new();
+    let endpoint = iroh::Endpoint::builder()
+        .discovery(sp.clone())
+        .bind()
+        .await?;
     let downloader = store.downloader(&endpoint);
     for ticket in &args.nodes {
-        endpoint.add_node_addr(ticket.node_addr().clone())?;
+        sp.add_node_info(ticket.node_addr().clone());
     }
     let nodes = args
         .nodes

examples/random_store.rs

@@ -8,9 +8,7 @@
 use std::collections::HashMap;
 
 use anyhow::{Context, Result};
-use iroh::{
-    discovery::static_provider::StaticProvider, protocol::Router, Endpoint, NodeAddr, Watcher,
-};
+use iroh::{discovery::static_provider::StaticProvider, protocol::Router, Endpoint, NodeAddr};
 use iroh_blobs::{
     api::{downloader::Shuffled, Store, TempTag},
     format::collection::Collection,
@@ -38,7 +36,7 @@ impl Node {
 
         // this BlobsProtocol accepts connections from other nodes and serves blobs from the store
         // we pass None to skip subscribing to request events
-        let blobs = BlobsProtocol::new(&store, endpoint.clone(), None);
+        let blobs = BlobsProtocol::new(&store, None);
         // Routers group one or more protocols together to accept connections from other nodes,
         // here we're only using one, but could add more in a real world use case as needed
         let router = Router::builder(endpoint)
@@ -54,7 +52,8 @@ impl Node {
     // get address of this node. Has the side effect of waiting for the node
     // to be online & ready to accept connections
     async fn node_addr(&self) -> Result<NodeAddr> {
-        let addr = self.router.endpoint().node_addr().initialized().await;
+        self.router.endpoint().online().await;
+        let addr = self.router.endpoint().node_addr();
         Ok(addr)
     }
 
@@ -80,14 +79,14 @@ impl Node {
 
         let collection_items = collection_items
             .iter()
-            .map(|(name, tag)| (name.to_string(), *tag.hash()))
+            .map(|(name, tag)| (name.to_string(), tag.hash()))
             .collect::<Vec<_>>();
 
         let collection = Collection::from_iter(collection_items);
 
         let tt = collection.store(&self.store).await?;
-        self.store.tags().create(*tt.hash_and_format()).await?;
-        Ok(*tt.hash())
+        self.store.tags().create(tt.hash_and_format()).await?;
+        Ok(tt.hash())
     }
 
     /// retrieve an entire collection from a given hash and provider