lib

commit 971bcdb70904040295c44b43c2ca92b3fdcd57da
parent b3715d6f4460acbaffb69ee4fbb629bb877e7544
Author: triesap <tyson@radroots.org>
Date:   Mon, 13 Apr 2026 04:27:34 +0000

sdk: align client transport resolution

Diffstat:
M
crates/sdk/src/client.rs
 | 
58
++++++++++++++++++++++++++++++++++++++++------------------
M
crates/sdk/src/lib.rs
 | 
4
++--
M
crates/sdk/tests/client.rs
 | 
37
+++++++++++++++++++++++--------------

3 files changed, 65 insertions(+), 34 deletions(-)
diff --git a/crates/sdk/src/client.rs b/crates/sdk/src/client.rs
@@ -154,19 +154,29 @@ impl std::error::Error for SdkPublishError {}
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct RadrootsSdkClient {
     config: RadrootsSdkConfig,
+    resolved_transport_target: SdkResolvedTransportTarget,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum SdkResolvedTransportTarget {
+    RelayDirect { relay_urls: Vec<String> },
+    Radrootsd { endpoint: String },
 }
 
 impl RadrootsSdkClient {
     pub fn from_config(config: RadrootsSdkConfig) -> Result<Self, SdkConfigError> {
-        match config.transport {
-            SdkTransportMode::RelayDirect => {
-                config.resolved_relay_urls()?;
-            }
-            SdkTransportMode::Radrootsd => {
-                config.resolved_radrootsd_endpoint()?;
-            }
-        }
-        Ok(Self { config })
+        let resolved_transport_target = match config.transport {
+            SdkTransportMode::RelayDirect => SdkResolvedTransportTarget::RelayDirect {
+                relay_urls: config.resolved_relay_urls()?,
+            },
+            SdkTransportMode::Radrootsd => SdkResolvedTransportTarget::Radrootsd {
+                endpoint: config.resolved_radrootsd_endpoint()?,
+            },
+        };
+        Ok(Self {
+            config,
+            resolved_transport_target,
+        })
     }
 
     pub fn config(&self) -> &RadrootsSdkConfig {
@@ -181,12 +191,8 @@ impl RadrootsSdkClient {
         self.config.signer
     }
 
-    pub fn resolved_relay_urls(&self) -> Result<Vec<String>, SdkConfigError> {
-        self.config.resolved_relay_urls()
-    }
-
-    pub fn resolved_radrootsd_endpoint(&self) -> Result<String, SdkConfigError> {
-        self.config.resolved_radrootsd_endpoint()
+    pub fn resolved_transport_target(&self) -> &SdkResolvedTransportTarget {
+        &self.resolved_transport_target
     }
 
     pub fn profile(&self) -> ProfileClient<'_> {
@@ -250,7 +256,15 @@ impl RadrootsSdkClient {
         self.require_signer_mode(SignerConfig::LocalIdentity, operation)?;
 
         let event_kind = u32::from(parts.kind);
-        let relay_urls = self.resolved_relay_urls()?;
+        let relay_urls = match &self.resolved_transport_target {
+            SdkResolvedTransportTarget::RelayDirect { relay_urls } => relay_urls.clone(),
+            SdkResolvedTransportTarget::Radrootsd { .. } => {
+                return Err(SdkPublishError::UnsupportedTransport {
+                    transport: self.transport(),
+                    operation,
+                });
+            }
+        };
         let client = relay::connected_client_from_identity(
             identity,
             &relay_urls,
@@ -277,9 +291,17 @@ impl RadrootsSdkClient {
         }
         self.require_signer_mode(SignerConfig::Nip46, "listing.publish_via_radrootsd")?;
 
-        let endpoint = self.resolved_radrootsd_endpoint()?;
+        let endpoint = match &self.resolved_transport_target {
+            SdkResolvedTransportTarget::Radrootsd { endpoint } => endpoint.as_str(),
+            SdkResolvedTransportTarget::RelayDirect { .. } => {
+                return Err(SdkPublishError::UnsupportedTransport {
+                    transport: self.transport(),
+                    operation: "listing.publish_via_radrootsd",
+                });
+            }
+        };
         let response = radrootsd::publish_listing(
-            endpoint.as_str(),
+            endpoint,
             &self.config.radrootsd.auth,
             request,
             Duration::from_millis(self.config.network.timeout_ms),
diff --git a/crates/sdk/src/lib.rs b/crates/sdk/src/lib.rs
@@ -34,8 +34,8 @@ pub use crate::config::{
 };
 pub use crate::client::{
     FarmClient, ListingClient, ProfileClient, RadrootsSdkClient, SdkPublishError,
-    SdkPublishReceipt, SdkRadrootsdPublishReceipt, SdkRelayFailure, SdkRelayPublishReceipt,
-    SdkTransportReceipt, TradeClient,
+    SdkPublishReceipt, SdkRadrootsdPublishReceipt, SdkRelayFailure,
+    SdkRelayPublishReceipt, SdkResolvedTransportTarget, SdkTransportReceipt, TradeClient,
 };
 #[cfg(feature = "radrootsd-client")]
 pub use crate::adapters::radrootsd::{
diff --git a/crates/sdk/tests/client.rs b/crates/sdk/tests/client.rs
@@ -11,9 +11,9 @@ use radroots_events::listing::{
 };
 use radroots_events::trade::{RadrootsTradeListingValidateRequest, RadrootsTradeMessagePayload};
 use radroots_sdk::{
-    RADROOTS_SDK_PRODUCTION_RADROOTSD_ENDPOINT, RADROOTS_SDK_PRODUCTION_RELAY_URL,
-    RadrootsNostrEvent, RadrootsSdkClient, RadrootsSdkConfig, RelayConfig, SdkConfigError,
-    SdkEnvironment, SdkTransportMode, SignerConfig,
+    RADROOTS_SDK_PRODUCTION_RELAY_URL, RadrootsNostrEvent, RadrootsSdkClient, RadrootsSdkConfig,
+    RelayConfig, SdkConfigError, SdkEnvironment, SdkResolvedTransportTarget, SdkTransportMode,
+    SignerConfig,
 };
 
 fn sample_farm() -> RadrootsFarm {
@@ -97,14 +97,10 @@ fn client_default_config_uses_production_relay_direct() {
 
     assert_eq!(client.transport(), SdkTransportMode::RelayDirect);
     assert_eq!(
-        client.resolved_relay_urls().expect("resolved relays"),
-        vec![RADROOTS_SDK_PRODUCTION_RELAY_URL.to_string()]
-    );
-    assert_eq!(
-        client
-            .resolved_radrootsd_endpoint()
-            .expect("resolved radrootsd"),
-        RADROOTS_SDK_PRODUCTION_RADROOTSD_ENDPOINT
+        client.resolved_transport_target(),
+        &SdkResolvedTransportTarget::RelayDirect {
+            relay_urls: vec![RADROOTS_SDK_PRODUCTION_RELAY_URL.to_string()],
+        }
     );
 }
 
@@ -131,16 +127,29 @@ fn client_allows_custom_relay_without_radrootsd_endpoint() {
         urls: vec!["wss://radroots.org".into()],
     };
 
-    RadrootsSdkClient::from_config(config).expect("relay-only sdk client");
+    let client = RadrootsSdkClient::from_config(config).expect("relay-only sdk client");
+    assert_eq!(
+        client.resolved_transport_target(),
+        &SdkResolvedTransportTarget::RelayDirect {
+            relay_urls: vec!["wss://radroots.org".to_string()],
+        }
+    );
 }
 
 #[test]
 fn client_allows_custom_radrootsd_without_relay_urls() {
+    let endpoint = "https://custom.radroots.org/jsonrpc";
     let mut config = RadrootsSdkConfig::custom();
     config.transport = SdkTransportMode::Radrootsd;
-    config.radrootsd.endpoint = Some("https://rpc.radroots.org/jsonrpc".into());
+    config.radrootsd.endpoint = Some(endpoint.into());
 
-    RadrootsSdkClient::from_config(config).expect("radrootsd-only sdk client");
+    let client = RadrootsSdkClient::from_config(config).expect("radrootsd-only sdk client");
+    assert_eq!(
+        client.resolved_transport_target(),
+        &SdkResolvedTransportTarget::Radrootsd {
+            endpoint: endpoint.to_string(),
+        }
+    );
 }
 
 #[test]