fixup: remove dependency on tickets

Author: dignifiedquire

Cargo.lock

@@ -40,7 +40,3 @@ unexpected_cfgs = { level = "warn", check-cfg = ["cfg(iroh_docsrs)", "cfg(iroh_l
 
 [workspace.lints.clippy]
 unused-async = "warn"
-
-
-[patch.crates-io]
-iroh-base = { path = "./iroh-base" }

Cargo.toml

@@ -142,7 +142,6 @@ tokio = { version = "1", features = [
 ] }
 serde_json = "1"
 iroh-relay = { path = "../iroh-relay", default-features = false, features = ["test-utils", "server"] }
-iroh-tickets = { git = "https://github.com/n0-computer/iroh-tickets" }
 tracing-test = "0.2.5"
 clap = { version = "4", features = ["derive"] }
 tracing-subscriber = { version = "0.3", features = [

iroh/Cargo.toml

@@ -3,10 +3,9 @@ use std::{env, future::Future, str::FromStr, time::Instant};
 use clap::Parser;
 use data_encoding::HEXLOWER;
 use iroh::{
-    SecretKey,
+    EndpointId, SecretKey,
     endpoint::{Connecting, Connection},
 };
-use iroh_tickets::endpoint::EndpointTicket;
 use n0_future::{StreamExt, future};
 use n0_snafu::ResultExt;
 use n0_watcher::Watcher;
@@ -17,7 +16,7 @@ const PINGPONG_ALPN: &[u8] = b"0rtt-pingpong";
 #[derive(Parser)]
 struct Args {
     /// The endpoint id to connect to. If not set, the program will start a server.
-    endpoint: Option<EndpointTicket>,
+    endpoint_id: Option<EndpointId>,
     /// Number of rounds to run.
     #[clap(long, default_value = "100")]
     rounds: u64,
@@ -92,7 +91,7 @@ async fn pingpong_0rtt(connecting: Connecting, i: u64) -> n0_snafu::Result<Conne
 }
 
 async fn connect(args: Args) -> n0_snafu::Result<()> {
-    let endpoint_addr = args.endpoint.unwrap().endpoint_addr().clone();
+    let remote_id = args.endpoint_id.unwrap();
     let endpoint = iroh::Endpoint::builder()
         .relay_mode(iroh::RelayMode::Disabled)
         .keylog(true)
@@ -102,7 +101,7 @@ async fn connect(args: Args) -> n0_snafu::Result<()> {
     for i in 0..args.rounds {
         let t0 = Instant::now();
         let connecting = endpoint
-            .connect_with_opts(endpoint_addr.clone(), PINGPONG_ALPN, Default::default())
+            .connect_with_opts(remote_id, PINGPONG_ALPN, Default::default())
             .await?;
         let connection = if args.disable_0rtt {
             let connection = connecting.await.e()?;
@@ -150,7 +149,6 @@ async fn accept(_args: Args) -> n0_snafu::Result<()> {
     };
     println!("Listening on: {addr:?}");
     println!("Endpoint ID: {:?}", addr.endpoint_id);
-    println!("Ticket: {}", EndpointTicket::from(addr));
 
     let accept = async move {
         while let Some(incoming) = endpoint.accept().await {
@@ -185,7 +183,7 @@ async fn accept(_args: Args) -> n0_snafu::Result<()> {
 async fn main() -> n0_snafu::Result<()> {
     tracing_subscriber::fmt::init();
     let args = Args::parse();
-    if args.endpoint.is_some() {
+    if args.endpoint_id.is_some() {
         connect(args).await?;
     } else {
         accept(args).await?;

iroh/examples/0rtt.rs

@@ -8,15 +8,14 @@ use clap::{Parser, Subcommand};
 use data_encoding::HEXLOWER;
 use indicatif::HumanBytes;
 use iroh::{
-    Endpoint, EndpointAddr, EndpointId, RelayMap, RelayMode, RelayUrl, SecretKey,
+    Endpoint, EndpointId, RelayMap, RelayMode, RelayUrl, SecretKey,
     discovery::{
         dns::DnsDiscovery,
         pkarr::{N0_DNS_PKARR_RELAY_PROD, N0_DNS_PKARR_RELAY_STAGING, PkarrPublisher},
     },
     dns::{DnsResolver, N0_DNS_ENDPOINT_ORIGIN_PROD, N0_DNS_ENDPOINT_ORIGIN_STAGING},
     endpoint::ConnectionError,
 };
-use iroh_tickets::endpoint::EndpointTicket;
 use n0_future::task::AbortOnDropHandle;
 use n0_snafu::{Result, ResultExt};
 use n0_watcher::Watcher as _;
@@ -146,7 +145,7 @@ enum Commands {
     },
     /// Fetch data.
     Fetch {
-        ticket: String,
+        remote_id: EndpointId,
         #[clap(flatten)]
         endpoint_args: EndpointArgs,
     },
@@ -167,11 +166,11 @@ async fn main() -> Result<()> {
             provide(endpoint, size).await?
         }
         Commands::Fetch {
-            ticket,
+            remote_id,
             endpoint_args,
         } => {
             let endpoint = endpoint_args.bind_endpoint().await?;
-            fetch(endpoint, &ticket).await?
+            fetch(endpoint, remote_id).await?
         }
     }
 
@@ -302,17 +301,7 @@ impl EndpointArgs {
 async fn provide(endpoint: Endpoint, size: u64) -> Result<()> {
     let endpoint_id = endpoint.id();
 
-    let endpoint_addr = endpoint.addr();
-    let ticket = EndpointTicket::new(endpoint_addr);
-    println!("Ticket with our home relay and direct addresses:\n{ticket}\n",);
-
-    let mut endpoint_addr = endpoint.addr();
-    endpoint_addr.direct_addresses = Default::default();
-    let ticket = EndpointTicket::new(endpoint_addr);
-    println!("Ticket with our home relay but no direct addresses:\n{ticket}\n",);
-
-    let ticket = EndpointTicket::new(EndpointAddr::new(endpoint_id));
-    println!("Ticket with only our endpoint id:\n{ticket}\n");
+    println!("Endpoint id:\n{endpoint_id}\n");
 
     // accept incoming connections, returns a normal QUIC connection
     while let Some(incoming) = endpoint.accept().await {
@@ -383,20 +372,16 @@ async fn provide(endpoint: Endpoint, size: u64) -> Result<()> {
     Ok(())
 }
 
-async fn fetch(endpoint: Endpoint, ticket: &str) -> Result<()> {
+async fn fetch(endpoint: Endpoint, remote_id: EndpointId) -> Result<()> {
     let me = endpoint.id().fmt_short();
-    let ticket: EndpointTicket = ticket.parse()?;
-    let remote_endpoint_id = ticket.endpoint_addr().endpoint_id;
     let start = Instant::now();
 
     // Attempt to connect, over the given ALPN.
     // Returns a Quinn connection.
-    let conn = endpoint
-        .connect(EndpointAddr::from(ticket), TRANSFER_ALPN)
-        .await?;
-    println!("Connected to {remote_endpoint_id}");
+    let conn = endpoint.connect(remote_id, TRANSFER_ALPN).await?;
+    println!("Connected to {remote_id}");
     // Spawn a background task that prints connection type changes. Will be aborted on drop.
-    let _guard = watch_conn_type(&endpoint, remote_endpoint_id);
+    let _guard = watch_conn_type(&endpoint, remote_id);
 
     // Use the Quinn API to send and recv content.
     let (mut send, mut recv) = conn.open_bi().await.e()?;