refactor!: convert from snafu to n0-error (#3561)

## Description

Changes the error handling across all crates in this repo from
`snafu`/`n0-snafu` to **`n0-error`**. The latter is our new error
library which features call-site location tracking and better ergonomics
than snafu.

Repo: https://github.com/n0-computer/n0-error
Docs: https://docs.rs/n0-error/

*Note:* The initial version of this PR was written by an AI (OpenAI
codex) which I instructed in numerous prompts to convert iroh from
n0-snafu/snafu to n0-error. It has since been cleaned up and reviewed
line-by-line.

## Breaking Changes

*Changed*
* All error structs and enum variants now have a field `meta:
n0_error::Meta`. Fields `backtrace` and `span_trace` are removed.
* All error structs and enums no longer implement `snafu::ErrorCompat`.
They now implement `n0_error::StackError`. All our errors keep
implementing `std::error::Error`. For downstream uses of these errors,
not much changed.
* If you previously used `n0-snafu` to work with iroh errors, we
recommend you switch to `n0-error`. See the [docs](
https://docs.rs/n0-error/) for how to work with n0-error.

## Notes & open questions

<!-- Any notes, remarks or open questions you have to make about the PR.
-->

## Change checklist
<!-- Remove any that are not relevant. -->
- [x] Self-review.
- [x] 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.
- [x] Tests if relevant.
- [x] All breaking changes documented.
- [ ] List all breaking changes in the above "Breaking Changes" section.
- [ ] Open an issue or PR on any number0 repos that are affected by this
breaking change. Give guidance on how the updates should be handled or
do the actual updates themselves. The major ones are:
    - [ ] [`quic-rpc`](https://github.com/n0-computer/quic-rpc)
    - [ ] [`iroh-gossip`](https://github.com/n0-computer/iroh-gossip)
    - [ ] [`iroh-blobs`](https://github.com/n0-computer/iroh-blobs)
    - [ ] [`dumbpipe`](https://github.com/n0-computer/dumbpipe)
    - [ ] [`sendme`](https://github.com/n0-computer/sendme)

---------

Co-authored-by: dignifiedquire <[email protected]>

Author: Frando

Cargo.lock

@@ -22,9 +22,7 @@ derive_more = { version = "2.0.1", features = ["display"], optional = true }
 url = { version = "2.5.3", features = ["serde"], optional = true }
 rand_core = { version = "0.9.3", optional = true }
 serde = { version = "1", features = ["derive", "rc"] }
-snafu = { version = "0.8.5", features = ["rust_1_81"], optional = true }
-n0-snafu = "0.2.2"
-nested_enum_utils = "0.2.0"
+n0-error = "0.1.0"
 zeroize = { version = "1.8.2", optional = true, features = ["derive"] }
 zeroize_derive = { version = "1.4.2", optional = true } # needed for minimal versions
 
@@ -44,7 +42,6 @@ key = [
   "dep:ed25519-dalek",
   "dep:url",
   "dep:derive_more",
-  "dep:snafu",
   "dep:data-encoding",
   "dep:rand_core",
   "dep:zeroize",
@@ -54,7 +51,6 @@ key = [
 relay = [
   "dep:url",
   "dep:derive_more",
-  "dep:snafu",
 ]
 
 [package.metadata.docs.rs]

iroh-base/Cargo.toml

@@ -11,10 +11,9 @@ use std::{
 
 use curve25519_dalek::edwards::CompressedEdwardsY;
 use ed25519_dalek::{SigningKey, VerifyingKey};
-use nested_enum_utils::common_fields;
+use n0_error::{ensure, stack_error};
 use rand_core::CryptoRng;
 use serde::{Deserialize, Serialize, de, ser};
-use snafu::{Backtrace, Snafu};
 
 /// A public key.
 ///
@@ -128,7 +127,7 @@ impl PublicKey {
     pub fn verify(&self, message: &[u8], signature: &Signature) -> Result<(), SignatureError> {
         self.as_verifying_key()
             .verify_strict(message, &signature.0)
-            .map_err(|_| SignatureSnafu.build())
+            .map_err(|_| SignatureError::new())
     }
 
     /// Convert to a hex string limited to the first 5 bytes for a friendly string
@@ -204,26 +203,18 @@ impl Display for PublicKey {
 }
 
 /// Error when deserialising a [`PublicKey`] or a [`SecretKey`].
-#[common_fields({
-    backtrace: Option<Backtrace>,
-    #[snafu(implicit)]
-    span_trace: n0_snafu::SpanTrace,
-})]
-#[derive(Snafu, Debug)]
+#[stack_error(derive, add_meta, from_sources, std_sources)]
 #[allow(missing_docs)]
-#[snafu(visibility(pub(crate)))]
 pub enum KeyParsingError {
     /// Error when decoding.
-    #[snafu(transparent)]
-    Decode { source: data_encoding::DecodeError },
+    #[error(transparent)]
+    Decode(data_encoding::DecodeError),
     /// Error when decoding the public key.
-    #[snafu(transparent)]
-    Key {
-        source: ed25519_dalek::SignatureError,
-    },
+    #[error(transparent)]
+    Key(ed25519_dalek::SignatureError),
     /// The encoded information had the wrong length.
-    #[snafu(display("invalid length"))]
-    DecodeInvalidLength {},
+    #[error("invalid length")]
+    DecodeInvalidLength,
 }
 
 /// Deserialises the [`PublicKey`] from it's base32 encoding.
@@ -420,9 +411,9 @@ impl Signature {
 }
 
 /// Verification of a signature failed.
-#[derive(Debug, Snafu)]
-#[snafu(display("Invalid signature"))]
-pub struct SignatureError;
+#[stack_error(derive, add_meta)]
+#[error("Invalid signature")]
+pub struct SignatureError {}
 
 fn decode_base32_hex(s: &str) -> Result<[u8; 32], KeyParsingError> {
     let mut bytes = [0u8; 32];
@@ -433,16 +424,18 @@ fn decode_base32_hex(s: &str) -> Result<[u8; 32], KeyParsingError> {
     } else {
         let input = s.to_ascii_uppercase();
         let input = input.as_bytes();
-        if data_encoding::BASE32_NOPAD.decode_len(input.len())? != bytes.len() {
-            return Err(DecodeInvalidLengthSnafu.build());
-        }
+        ensure!(
+            data_encoding::BASE32_NOPAD.decode_len(input.len())? == bytes.len(),
+            KeyParsingError::DecodeInvalidLength
+        );
         data_encoding::BASE32_NOPAD.decode_mut(input, &mut bytes)
     };
     match res {
         Ok(len) => {
-            if len != PublicKey::LENGTH {
-                return Err(DecodeInvalidLengthSnafu.build());
-            }
+            ensure!(
+                len == PublicKey::LENGTH,
+                KeyParsingError::DecodeInvalidLength
+            );
         }
         Err(partial) => return Err(partial.error.into()),
     }

iroh-base/src/key.rs

@@ -1,7 +1,7 @@
 use std::{fmt, ops::Deref, str::FromStr, sync::Arc};
 
+use n0_error::stack_error;
 use serde::{Deserialize, Serialize};
-use snafu::{Backtrace, ResultExt, Snafu};
 use url::Url;
 
 /// A URL identifying a relay server.
@@ -39,12 +39,9 @@ impl From<Url> for RelayUrl {
 }
 
 /// Can occur when parsing a string into a [`RelayUrl`].
-#[derive(Debug, Snafu)]
-#[snafu(display("Failed to parse"))]
-pub struct RelayUrlParseError {
-    source: url::ParseError,
-    backtrace: Option<Backtrace>,
-}
+#[stack_error(derive, add_meta)]
+#[error("Failed to parse relay URL")]
+pub struct RelayUrlParseError(#[error(std_err)] url::ParseError);
 
 /// Support for parsing strings directly.
 ///
@@ -54,7 +51,7 @@ impl FromStr for RelayUrl {
     type Err = RelayUrlParseError;
 
     fn from_str(s: &str) -> Result<Self, Self::Err> {
-        let inner = Url::from_str(s).context(RelayUrlParseSnafu)?;
+        let inner = Url::from_str(s).map_err(RelayUrlParseError::new)?;
         Ok(RelayUrl::from(inner))
     }
 }

iroh-base/src/relay_url.rs

@@ -28,10 +28,9 @@ hickory-server = { version = "0.25.1", features = ["https-ring"] }
 http = "1.0.0"
 humantime = "2.2.0"
 humantime-serde = "1.1.1"
-iroh-metrics = { version = "0.36", features = ["service"] }
+iroh-metrics = { version = "0.37", features = ["service"] }
 lru = "0.16"
 n0-future = "0.3.0"
-n0-snafu = "0.2.2"
 pkarr = { version = "5", features = ["relays", "dht"], default-features = false }
 rcgen = "0.14"
 redb = "3.1.0"
@@ -40,7 +39,7 @@ rustls = { version = "0.23.33", default-features = false, features = ["ring"] }
 rustls-pemfile = { version = "2.1" }
 serde = { version = "1", features = ["derive"] }
 struct_iterable = "0.1.1"
-snafu = { version = "0.8.5", features = ["rust_1_81"] }
+n0-error = "0.1.0"
 strum = { version = "0.27", features = ["derive"] }
 tokio = { version = "1", features = ["full"] }
 tokio-rustls = { version = "0.26", default-features = false, features = [

iroh-dns-server/Cargo.toml

@@ -3,7 +3,7 @@ use std::sync::Arc;
 use criterion::{BenchmarkId, Criterion, Throughput, criterion_group, criterion_main};
 use iroh::{SecretKey, discovery::pkarr::PkarrRelayClient, endpoint_info::EndpointInfo};
 use iroh_dns_server::{ZoneStore, config::Config, metrics::Metrics, server::Server};
-use n0_snafu::Result;
+use n0_error::Result;
 use rand_chacha::rand_core::SeedableRng;
 use tokio::runtime::Runtime;
 

iroh-dns-server/benches/write.rs

@@ -2,7 +2,7 @@ use std::str::FromStr;
 
 use clap::Parser;
 use iroh::EndpointId;
-use n0_snafu::{Result, ResultExt};
+use n0_error::{Result, StdResultExt};
 
 #[derive(Debug, Parser)]
 struct Cli {
@@ -21,12 +21,12 @@ fn main() -> Result<()> {
     match args.command {
         Command::EndpointToPkarr { endpoint_id } => {
             let endpoint_id = EndpointId::from_str(&endpoint_id)?;
-            let public_key = pkarr::PublicKey::try_from(endpoint_id.as_bytes()).e()?;
+            let public_key = pkarr::PublicKey::try_from(endpoint_id.as_bytes()).anyerr()?;
             println!("{}", public_key.to_z32())
         }
         Command::PkarrToEndpoint { z32_pubkey } => {
-            let public_key = pkarr::PublicKey::try_from(z32_pubkey.as_str()).e()?;
-            let endpoint_id = EndpointId::from_bytes(public_key.as_bytes()).e()?;
+            let public_key = pkarr::PublicKey::try_from(z32_pubkey.as_str()).anyerr()?;
+            let endpoint_id = EndpointId::from_bytes(public_key.as_bytes())?;
             println!("{endpoint_id}")
         }
     }

iroh-dns-server/examples/convert.rs

@@ -10,7 +10,7 @@ use iroh::{
     },
     endpoint_info::{EndpointIdExt, EndpointInfo, IROH_TXT_NAME},
 };
-use n0_snafu::{Result, ResultExt};
+use n0_error::{Result, StackResultExt};
 use url::Url;
 
 const DEV_PKARR_RELAY_URL: &str = "http://localhost:8080/pkarr";

iroh-dns-server/examples/publish.rs

@@ -4,7 +4,7 @@ use iroh::{
     discovery::dns::{N0_DNS_ENDPOINT_ORIGIN_PROD, N0_DNS_ENDPOINT_ORIGIN_STAGING},
     dns::DnsResolver,
 };
-use n0_snafu::{Result, ResultExt};
+use n0_error::{Result, StackResultExt, StdResultExt};
 
 const DEV_DNS_SERVER: &str = "127.0.0.1:5300";
 const DEV_DNS_ORIGIN_DOMAIN: &str = "irohdns.example";
@@ -49,7 +49,7 @@ async fn main() -> Result<()> {
     let resolver = if let Some(host) = args.dns_server {
         let addr = tokio::net::lookup_host(host)
             .await
-            .e()?
+            .anyerr()?
             .next()
             .context("failed to resolve DNS server address")?;
         DnsResolver::with_nameserver(addr)

iroh-dns-server/examples/resolve.rs

@@ -7,7 +7,7 @@ use std::{
     time::Duration,
 };
 
-use n0_snafu::{Result, ResultExt};
+use n0_error::{Result, StdResultExt};
 use serde::{Deserialize, Serialize};
 use tracing::info;
 
@@ -162,8 +162,8 @@ impl Config {
         );
         let s = tokio::fs::read_to_string(path.as_ref())
             .await
-            .with_context(|| format!("failed to read {}", path.as_ref().to_string_lossy()))?;
-        let config: Config = toml::from_str(&s).e()?;
+            .with_std_context(|_| format!("failed to read {}", path.as_ref().to_string_lossy()))?;
+        let config: Config = toml::from_str(&s).anyerr()?;
         Ok(config)
     }
 
@@ -173,7 +173,7 @@ impl Config {
             PathBuf::from(val)
         } else {
             let path = dirs_next::data_dir()
-                .context("operating environment provides no directory for application data")?;
+                .std_context("operating environment provides no directory for application data")?;
 
             path.join("iroh-dns")
         };