imp(sdk): remove snafu dependency

Author: evansims

Cargo.lock

@@ -58,6 +58,7 @@ postcard = { version = "1", features = ["alloc"] }
 
 # Error handling
 snafu = { version = "0.8", features = ["backtrace"] }
+thiserror = "2"
 
 # Concurrency
 parking_lot = "0.12"

Cargo.toml

@@ -31,7 +31,7 @@ serde = { workspace = true }
 serde_json = { workspace = true }
 
 # Error handling
-snafu = { workspace = true }
+thiserror = { workspace = true }
 
 # Concurrency
 parking_lot = { workspace = true }

crates/sdk/Cargo.toml

@@ -949,10 +949,9 @@ impl VerifiedValue {
     pub fn verify(&self) -> Result<bool> {
         // Verify the Merkle proof against the block header's state root
         if !self.merkle_proof.verify(&self.block_header.state_root) {
-            return Err(error::ProofVerificationSnafu {
+            return Err(error::SdkError::ProofVerification {
                 reason: "Merkle proof does not match state root",
-            }
-            .build());
+            });
         }
 
         // If we have a chain proof, that would be verified by the caller
@@ -1316,8 +1315,8 @@ impl LedgerClient {
                 let resolver = Arc::new(ServerResolver::new(source.clone()));
 
                 // Perform initial resolution
-                let servers = resolver.resolve().await.map_err(|e| {
-                    error::ConfigSnafu { message: format!("Server discovery failed: {e}") }.build()
+                let servers = resolver.resolve().await.map_err(|e| error::SdkError::Config {
+                    message: format!("Server discovery failed: {e}"),
                 })?;
 
                 // Convert to endpoint URLs
@@ -2156,35 +2155,32 @@ impl LedgerClient {
                     },
                     proto::WriteErrorCode::IdempotencyKeyReused => {
                         // Client reused idempotency key with different payload
-                        crate::error::IdempotencySnafu {
+                        Err(crate::error::SdkError::Idempotency {
                             message: format!(
                                 "Idempotency key reused with different payload: {}",
                                 error.message
                             ),
-                            conflict_key: None::<String>,
+                            conflict_key: None,
                             original_tx_id: Some(Self::tx_id_to_hex(error.committed_tx_id.clone())),
-                        }
-                        .fail()
+                        })
                     },
                     _ => {
                         // Other write errors (CAS failures, etc.)
-                        crate::error::RpcSnafu {
+                        Err(crate::error::SdkError::Rpc {
                             code: tonic::Code::FailedPrecondition,
                             message: error.message,
-                            request_id: None::<String>,
-                            trace_id: None::<String>,
-                        }
-                        .fail()
+                            request_id: None,
+                            trace_id: None,
+                        })
                     },
                 }
             },
-            None => crate::error::RpcSnafu {
+            None => Err(crate::error::SdkError::Rpc {
                 code: tonic::Code::Internal,
-                message: "Empty write response".to_string(),
-                request_id: None::<String>,
-                trace_id: None::<String>,
-            }
-            .fail(),
+                message: "Empty write response".to_owned(),
+                request_id: None,
+                trace_id: None,
+            }),
         }
     }
 
@@ -2408,35 +2404,32 @@ impl LedgerClient {
                     },
                     proto::WriteErrorCode::IdempotencyKeyReused => {
                         // Client reused idempotency key with different payload
-                        crate::error::IdempotencySnafu {
+                        Err(crate::error::SdkError::Idempotency {
                             message: format!(
                                 "Idempotency key reused with different payload: {}",
                                 error.message
                             ),
-                            conflict_key: None::<String>,
+                            conflict_key: None,
                             original_tx_id: Some(Self::tx_id_to_hex(error.committed_tx_id.clone())),
-                        }
-                        .fail()
+                        })
                     },
                     _ => {
                         // Other write errors (CAS failures, etc.)
-                        crate::error::RpcSnafu {
+                        Err(crate::error::SdkError::Rpc {
                             code: tonic::Code::FailedPrecondition,
                             message: error.message,
-                            request_id: None::<String>,
-                            trace_id: None::<String>,
-                        }
-                        .fail()
+                            request_id: None,
+                            trace_id: None,
+                        })
                     },
                 }
             },
-            None => crate::error::RpcSnafu {
+            None => Err(crate::error::SdkError::Rpc {
                 code: tonic::Code::Internal,
-                message: "Empty batch write response".to_string(),
-                request_id: None::<String>,
-                trace_id: None::<String>,
-            }
-            .fail(),
+                message: "Empty batch write response".to_owned(),
+                request_id: None,
+                trace_id: None,
+            }),
         }
     }
 
@@ -3030,7 +3023,9 @@ impl LedgerClient {
         match result.status {
             HealthStatus::Healthy => Ok(true),
             HealthStatus::Degraded => Ok(false),
-            HealthStatus::Unavailable => error::UnavailableSnafu { message: result.message }.fail(),
+            HealthStatus::Unavailable => {
+                Err(error::SdkError::Unavailable { message: result.message })
+            },
             HealthStatus::Unspecified => Ok(false),
         }
     }

crates/sdk/src/client.rs

@@ -4,10 +4,9 @@ use std::time::Duration;
 
 use bon::bon;
 use inferadb_ledger_types::config::ValidationConfig;
-use snafu::ensure;
 
 use crate::{
-    error::{ConfigSnafu, InvalidUrlSnafu, Result},
+    error::{Result, SdkError},
     server::ServerSource,
     tracing::TraceConfig,
 };
@@ -117,24 +116,27 @@ impl ClientConfig {
     ) -> Result<Self> {
         // Validate static endpoints
         if let ServerSource::Static(ref endpoints) = servers {
-            ensure!(
-                !endpoints.is_empty(),
-                ConfigSnafu {
+            if endpoints.is_empty() {
+                return Err(SdkError::Config {
                     message: "at least one endpoint is required for static server source"
-                }
-            );
+                        .to_owned(),
+                });
+            }
 
             for endpoint in endpoints {
                 validate_url(endpoint)?;
             }
         }
 
-        ensure!(!client_id.is_empty(), ConfigSnafu { message: "client_id cannot be empty" });
-        ensure!(!timeout.is_zero(), ConfigSnafu { message: "timeout cannot be zero" });
-        ensure!(
-            !connect_timeout.is_zero(),
-            ConfigSnafu { message: "connect_timeout cannot be zero" }
-        );
+        if client_id.is_empty() {
+            return Err(SdkError::Config { message: "client_id cannot be empty".to_owned() });
+        }
+        if timeout.is_zero() {
+            return Err(SdkError::Config { message: "timeout cannot be zero".to_owned() });
+        }
+        if connect_timeout.is_zero() {
+            return Err(SdkError::Config { message: "connect_timeout cannot be zero".to_owned() });
+        }
 
         Ok(Self {
             servers,
@@ -285,19 +287,28 @@ impl RetryPolicy {
 fn validate_url(url: &str) -> Result<()> {
     // Basic validation - must start with http:// or https://
     if !url.starts_with("http://") && !url.starts_with("https://") {
-        return InvalidUrlSnafu { url, message: "URL must start with http:// or https://" }.fail();
+        return Err(SdkError::InvalidUrl {
+            url: url.to_owned(),
+            message: "URL must start with http:// or https://".to_owned(),
+        });
     }
 
     // Check there's something after the scheme
     let rest = url.strip_prefix("http://").or_else(|| url.strip_prefix("https://")).unwrap_or("");
 
     if rest.is_empty() {
-        return InvalidUrlSnafu { url, message: "URL must have a host" }.fail();
+        return Err(SdkError::InvalidUrl {
+            url: url.to_owned(),
+            message: "URL must have a host".to_owned(),
+        });
     }
 
     // Check for invalid characters
     if rest.contains(char::is_whitespace) {
-        return InvalidUrlSnafu { url, message: "URL cannot contain whitespace" }.fail();
+        return Err(SdkError::InvalidUrl {
+            url: url.to_owned(),
+            message: "URL cannot contain whitespace".to_owned(),
+        });
     }
 
     Ok(())
@@ -501,13 +512,16 @@ impl TlsConfig {
     ) -> Result<Self> {
         // If client cert is set, key must also be set
         if client_cert.is_some() && client_key.is_none() {
-            return ConfigSnafu { message: "client certificate requires a private key" }.fail();
+            return Err(SdkError::Config {
+                message: "client certificate requires a private key".to_owned(),
+            });
         }
 
         // Must have some way to verify server certificate
         if ca_cert.is_none() && !use_native_roots {
-            return ConfigSnafu { message: "TLS requires either a CA certificate or native roots" }
-                .fail();
+            return Err(SdkError::Config {
+                message: "TLS requires either a CA certificate or native roots".to_owned(),
+            });
         }
 
         Ok(Self { ca_cert, client_cert, client_key, domain_name, use_native_roots })

crates/sdk/src/config.rs

@@ -28,12 +28,11 @@
 use std::{sync::Arc, time::Duration};
 
 use parking_lot::RwLock;
-use snafu::ResultExt;
 use tonic::transport::{Certificate, Channel, ClientTlsConfig, Endpoint, Identity};
 
 use crate::{
     config::ClientConfig,
-    error::{ConnectionSnafu, InvalidUrlSnafu, Result, TransportSnafu},
+    error::{Result, SdkError},
     server::{ServerSelector, ServerSource},
 };
 
@@ -186,28 +185,25 @@ impl ConnectionPool {
         };
 
         let Some(endpoint_url) = endpoint_url else {
-            return ConnectionSnafu {
+            return Err(SdkError::Connection {
                 message:
                     "No endpoints available. For DNS/File sources, ensure the resolver has run."
-                        .to_string(),
-            }
-            .fail();
+                        .to_owned(),
+            });
         };
 
         // Parse the endpoint URL
-        let endpoint = Endpoint::try_from(endpoint_url.clone()).map_err(|_| {
-            InvalidUrlSnafu {
+        let endpoint =
+            Endpoint::try_from(endpoint_url.clone()).map_err(|_| SdkError::InvalidUrl {
                 url: endpoint_url.clone(),
-                message: "Failed to parse as tonic endpoint".to_string(),
-            }
-            .build()
-        })?;
+                message: "Failed to parse as tonic endpoint".to_owned(),
+            })?;
 
         // Apply connection settings (including TLS if configured)
         let endpoint = self.configure_endpoint(endpoint)?;
 
         // Establish the connection
-        let channel = endpoint.connect().await.context(TransportSnafu)?;
+        let channel = endpoint.connect().await?;
 
         Ok(channel)
     }
@@ -230,8 +226,8 @@ impl ConnectionPool {
         // Apply TLS configuration if present
         let endpoint = if let Some(ref tls_config) = self.config.tls {
             let tls = self.build_tls_config(tls_config)?;
-            endpoint.tls_config(tls).map_err(|e| {
-                ConnectionSnafu { message: format!("TLS configuration error: {e}") }.build()
+            endpoint.tls_config(tls).map_err(|e| SdkError::Connection {
+                message: format!("TLS configuration error: {e}"),
             })?
         } else {
             endpoint

crates/sdk/src/connection.rs

@@ -57,7 +57,7 @@ use tracing::{debug, info, warn};
 use crate::{
     config::DiscoveryConfig,
     connection::ConnectionPool,
-    error::{Result, RpcSnafu},
+    error::{Result, SdkError},
     retry::with_retry,
 };
 
@@ -216,14 +216,11 @@ impl DiscoveryService {
             let mut client = Self::create_discovery_client(channel, compression);
 
             let request = proto::GetPeersRequest { max_peers };
-            let response = client.get_peers(request).await.map_err(|status| {
-                RpcSnafu {
-                    code: status.code(),
-                    message: status.message().to_string(),
-                    request_id: None::<String>,
-                    trace_id: None::<String>,
-                }
-                .build()
+            let response = client.get_peers(request).await.map_err(|status| SdkError::Rpc {
+                code: status.code(),
+                message: status.message().to_owned(),
+                request_id: None,
+                trace_id: None,
             })?;
 
             let inner = response.into_inner();