feat: import iroh_base::ticket::BlobTicket and iroh_base::hash

Author: dignifiedquire

Cargo.lock

@@ -19,9 +19,11 @@ bao-tree = { version = "0.13", features = [
     "tokio_fsm",
     "validate",
 ], default-features = false }
+blake3 = { version = "1.4.5", package = "iroh-blake3" }
 bytes = { version = "1.7", features = ["serde"] }
 chrono = "0.4.31"
 clap = { version = "4.5.20", features = ["derive"], optional = true }
+data-encoding = { version = "2.3.3" }
 derive_more = { version = "1.0.0", features = [
     "debug",
     "display",
@@ -93,7 +95,7 @@ futures-util = "0.3.30"
 testdir = "0.9.1"
 
 [features]
-default = ["fs-store", "net_protocol"]
+default = ["fs-store", "net_protocol", "cli"]
 downloader = ["dep:parking_lot", "tokio-util/time", "dep:hashlink"]
 net_protocol = ["downloader", "dep:futures-util"]
 fs-store = ["dep:reflink-copy", "redb", "dep:tempfile"]

Cargo.toml

@@ -48,8 +48,9 @@ use iroh::{
     protocol::{ProtocolHandler, Router},
     Endpoint, NodeId,
 };
-use iroh_base::hash::Hash;
-use iroh_blobs::{net_protocol::Blobs, rpc::client::blobs::MemClient, util::local_pool::LocalPool};
+use iroh_blobs::{
+    net_protocol::Blobs, rpc::client::blobs::MemClient, util::local_pool::LocalPool, Hash,
+};
 use tracing_subscriber::{prelude::*, EnvFilter};
 
 #[derive(Debug, Parser)]

examples/custom-protocol.rs

@@ -7,8 +7,9 @@ use std::{env, str::FromStr};
 
 use anyhow::{bail, ensure, Context, Result};
 use iroh::{protocol::Router, Endpoint};
-use iroh_base::ticket::BlobTicket;
-use iroh_blobs::{net_protocol::Blobs, util::local_pool::LocalPool, BlobFormat};
+use iroh_blobs::{
+    net_protocol::Blobs, ticket::BlobTicket, util::local_pool::LocalPool, BlobFormat,
+};
 use tracing_subscriber::{prelude::*, EnvFilter};
 
 // set the RUST_LOG env var to one of {debug,info,warn} to see logging info

examples/hello-world-fetch.rs

@@ -4,8 +4,7 @@
 //! run this example from the project root:
 //!     $ cargo run --example hello-world-provide
 use iroh::{protocol::Router, Endpoint};
-use iroh_base::{node_addr::AddrInfoOptions, ticket::BlobTicket};
-use iroh_blobs::{net_protocol::Blobs, util::local_pool::LocalPool};
+use iroh_blobs::{net_protocol::Blobs, ticket::BlobTicket, util::local_pool::LocalPool};
 use tracing_subscriber::{prelude::*, EnvFilter};
 
 // set the RUST_LOG env var to one of {debug,info,warn} to see logging info
@@ -35,8 +34,7 @@ async fn main() -> anyhow::Result<()> {
     let res = blobs_client.add_bytes("Hello, world!").await?;
 
     // create a ticket
-    let mut addr = node.endpoint().node_addr().await?;
-    addr.apply_options(AddrInfoOptions::RelayAndAddresses);
+    let addr = node.endpoint().node_addr().await?;
     let ticket = BlobTicket::new(addr, res.hash, res.format)?;
 
     // print some info about the node

examples/hello-world-provide.rs

@@ -10,12 +10,11 @@ use std::path::PathBuf;
 use anyhow::ensure;
 use clap::{Parser, Subcommand};
 use iroh::{
-    discovery::local_swarm_discovery::LocalSwarmDiscovery, key::PublicKey, protocol::Router,
-    Endpoint, NodeAddr, RelayMode,
+    discovery::local_swarm_discovery::LocalSwarmDiscovery, key::PublicKey, key::SecretKey,
+    protocol::Router, Endpoint, NodeAddr, RelayMode,
 };
-use iroh_base::{hash::Hash, key::SecretKey};
 use iroh_blobs::{
-    net_protocol::Blobs, rpc::client::blobs::WrapOption, util::local_pool::LocalPool,
+    net_protocol::Blobs, rpc::client::blobs::WrapOption, util::local_pool::LocalPool, Hash,
 };
 use tracing_subscriber::{prelude::*, EnvFilter};
 

examples/local-swarm-discovery.rs

@@ -2,10 +2,10 @@ use std::{path::PathBuf, str::FromStr};
 
 use anyhow::Result;
 use iroh::{protocol::Router, Endpoint};
-use iroh_base::ticket::BlobTicket;
 use iroh_blobs::{
     net_protocol::Blobs,
     rpc::client::blobs::{ReadAtLen, WrapOption},
+    ticket::BlobTicket,
     util::{local_pool::LocalPool, SetTagOption},
 };
 

examples/transfer.rs

@@ -16,7 +16,6 @@ use indicatif::{
     ProgressStyle,
 };
 use iroh::{key::PublicKey, relay::RelayUrl, NodeAddr};
-use iroh_base::{node_addr::AddrInfoOptions, ticket::BlobTicket};
 use tokio::io::AsyncWriteExt;
 
 use crate::{
@@ -27,6 +26,7 @@ use crate::{
         self, BlobInfo, BlobStatus, CollectionInfo, DownloadOptions, IncompleteBlobInfo, WrapOption,
     },
     store::{ConsistencyCheckProgress, ExportFormat, ExportMode, ReportLevel, ValidateProgress},
+    ticket::BlobTicket,
     util::SetTagOption,
     BlobFormat, Hash, HashAndFormat, Tag,
 };
@@ -146,11 +146,6 @@ pub enum BlobCommands {
     Share {
         /// Hash of the blob to share.
         hash: Hash,
-        /// Options to configure the address information in the generated ticket.
-        ///
-        /// Use `relay-and-addresses` in networks with no internet connectivity.
-        #[clap(long, default_value_t = AddrInfoOptions::Id)]
-        addr_options: AddrInfoOptions,
         /// If the blob is a collection, the requester will also fetch the listed blobs.
         #[clap(long, default_value_t = false)]
         recursive: bool,
@@ -203,18 +198,22 @@ impl BlobCommands {
 
                         // create the node address with the appropriate overrides
                         let node_addr = {
-                            let NodeAddr { node_id, info } = node_addr;
+                            let NodeAddr {
+                                node_id,
+                                relay_url: original_relay_url,
+                                direct_addresses,
+                            } = node_addr;
                             let addresses = if override_addresses {
                                 // use only the cli supplied ones
                                 address
                             } else {
                                 // use both the cli supplied ones and the ticket ones
-                                address.extend(info.direct_addresses);
+                                address.extend(direct_addresses);
                                 address
                             };
 
                             // prefer direct arg over ticket
-                            let relay_url = relay_url.or(info.relay_url);
+                            let relay_url = relay_url.or(original_relay_url);
 
                             NodeAddr::from_parts(node_id, relay_url, addresses)
                         };
@@ -357,7 +356,6 @@ impl BlobCommands {
             } => add_with_opts(blobs, addr, path, options).await,
             Self::Share {
                 hash,
-                addr_options,
                 recursive,
                 debug,
             } => {
@@ -367,8 +365,6 @@ impl BlobCommands {
                     BlobFormat::Raw
                 };
                 let status = blobs.status(hash).await?;
-                let mut addr = addr;
-                addr.apply_options(addr_options);
                 let ticket = BlobTicket::new(addr, hash, format)?;
 
                 let (blob_status, size) = match (status, format) {

src/cli.rs

@@ -46,7 +46,6 @@ use anyhow::anyhow;
 use futures_lite::{future::BoxedLocal, Stream, StreamExt};
 use hashlink::LinkedHashSet;
 use iroh::{endpoint, Endpoint, NodeAddr, NodeId};
-use iroh_base::hash::{BlobFormat, Hash, HashAndFormat};
 use iroh_metrics::inc;
 use tokio::{
     sync::{mpsc, oneshot},
@@ -60,6 +59,7 @@ use crate::{
     metrics::Metrics,
     store::Store,
     util::{local_pool::LocalPoolHandle, progress::ProgressSender},
+    BlobFormat, Hash, HashAndFormat,
 };
 
 mod get;

src/downloader.rs

@@ -10,7 +10,6 @@ use genawaiter::{
     GeneratorState,
 };
 use iroh::endpoint::Connection;
-use iroh_base::hash::Hash;
 use iroh_io::AsyncSliceReader;
 use serde::{Deserialize, Serialize};
 use tokio::sync::oneshot;
@@ -31,7 +30,7 @@ use crate::{
         Store as BaoStore,
     },
     util::progress::{IdGenerator, ProgressSender},
-    BlobFormat, HashAndFormat,
+    BlobFormat, Hash, HashAndFormat,
 };
 
 type GetGenerator = Gen<Yield, (), Pin<Box<dyn Future<Output = Result<Stats, GetError>>>>>;