..

common/client-core/Cargo.toml

@@ -36,7 +36,7 @@ nym-bandwidth-controller = { path = "../bandwidth-controller" }
 nym-crypto = { path = "../crypto" }
 nym-gateway-client = { path = "../client-libs/gateway-client" }
 nym-gateway-requests = { path = "../gateway-requests" }
-nym-http-api-client = { path = "../http-api-client", features = ["network-defaults"] }
+nym-http-api-client = { path = "../http-api-client" }
 nym-nonexhaustive-delayqueue = { path = "../nonexhaustive-delayqueue" }
 nym-sphinx = { path = "../nymsphinx" }
 nym-statistics-common = { path = "../statistics" }

common/client-core/src/client/base_client/mod.rs

@@ -73,10 +73,6 @@ use url::Url;
 #[cfg(debug_assertions)]
 use wasm_utils::console_log;
 
-/// Default number of retries for Nym API requests when using network details with domain fronting.
-/// This allows the client to try alternative URLs if the primary endpoint is unavailable.
-const DEFAULT_NYM_API_RETRIES: usize = 3;
-
 #[cfg(all(
     not(target_arch = "wasm32"),
     feature = "fs-surb-storage",
@@ -216,9 +212,6 @@ pub struct BaseClientBuilder<C, S: MixnetClientStorage> {
     client_store: S,
     dkg_query_client: Option<C>,
 
-    // Optional API URLs for domain fronting support
-    nym_api_urls: Option<Vec<nym_network_defaults::ApiUrl>>,
-
     wait_for_gateway: bool,
     custom_topology_provider: Option<Box<dyn TopologyProvider + Send + Sync>>,
     custom_gateway_transceiver: Option<Box<dyn GatewayTransceiver + Send>>,
@@ -248,7 +241,6 @@ where
             config: base_config,
             client_store,
             dkg_query_client,
-            nym_api_urls: None,
             wait_for_gateway: false,
             custom_topology_provider: None,
             custom_gateway_transceiver: None,
@@ -271,16 +263,6 @@ where
         self
     }
 
-    /// Set Nym API URLs for domain fronting support.
-    ///
-    /// When provided, the client will use these API URLs (which include front_hosts)
-    /// to construct HTTP clients with domain fronting enabled.
-    #[must_use]
-    pub fn with_nym_api_urls(mut self, nym_api_urls: Vec<nym_network_defaults::ApiUrl>) -> Self {
-        self.nym_api_urls = Some(nym_api_urls);
-        self
-    }
-
     #[must_use]
     pub fn with_forget_me(mut self, forget_me: &ForgetMe) -> Self {
         self.config.debug.forget_me = *forget_me;
@@ -881,67 +863,21 @@ where
     }
 
     fn construct_nym_api_client(
-        nym_api_urls: Option<&Vec<nym_network_defaults::ApiUrl>>,
         config: &Config,
         user_agent: Option<UserAgent>,
     ) -> Result<nym_http_api_client::Client, ClientCoreError> {
-        tracing::debug!(
-            "construct_nym_api_client called with nym_api_urls: {}",
-            nym_api_urls.is_some()
-        );
-
-        // If API URLs are provided, use new_with_fronted_urls() which handles domain fronting
-        if let Some(nym_api_urls) = nym_api_urls {
-            if nym_api_urls.is_empty() {
-                tracing::warn!("Provided nym_api_urls is empty, falling back to config endpoints");
-            } else {
-                tracing::info!(
-                    "Building nym-api client from provided URLs (with domain fronting support): {} URLs",
-                    nym_api_urls.len()
-                );
-
-                let mut builder =
-                    nym_http_api_client::ClientBuilder::new_with_fronted_urls(nym_api_urls.clone())
-                        .map_err(ClientCoreError::from)?
-                        .with_retries(DEFAULT_NYM_API_RETRIES);
-
-                if let Some(user_agent) = user_agent {
-                    builder = builder.with_user_agent(user_agent);
-                }
-
-                return builder.build().map_err(ClientCoreError::from);
-            }
-        }
-
-        // Fallback to basic client for backwards compatibility
-        tracing::debug!("Building basic nym-api HTTP client from config endpoints");
-
         let mut nym_api_urls = config.get_nym_api_endpoints();
-        if nym_api_urls.is_empty() {
-            tracing::warn!("No API endpoints configured in config, this may cause issues");
-        }
         nym_api_urls.shuffle(&mut thread_rng());
 
-        // Convert config URLs to ApiUrl format for consistency
-        let api_urls: Vec<nym_network_defaults::ApiUrl> = nym_api_urls
-            .into_iter()
-            .map(|url| nym_network_defaults::ApiUrl {
-                url: url.to_string(),
-                front_hosts: None,
-            })
-            .collect();
-
-        tracing::debug!("Using {} config API endpoints", api_urls.len());
-
-        let mut builder = nym_http_api_client::ClientBuilder::new_with_fronted_urls(api_urls)
-            .map_err(ClientCoreError::from)?
-            .with_retries(DEFAULT_NYM_API_RETRIES)
-            .with_bincode();
+        let mut builder = nym_http_api_client::Client::builder(nym_api_urls[0].clone())
+            .map_err(ClientCoreError::from)?;
 
         if let Some(user_agent) = user_agent {
             builder = builder.with_user_agent(user_agent);
         }
 
+        builder = builder.with_bincode();
+
         builder.build().map_err(ClientCoreError::from)
     }
 
@@ -1025,11 +961,7 @@ where
             .dkg_query_client
             .map(|client| BandwidthController::new(credential_store, client));
 
-        let nym_api_client = Self::construct_nym_api_client(
-            self.nym_api_urls.as_ref(),
-            &self.config,
-            self.user_agent.clone(),
-        )?;
+        let nym_api_client = Self::construct_nym_api_client(&self.config, self.user_agent.clone())?;
         let key_rotation_config = Self::determine_key_rotation_state(&nym_api_client).await?;
 
         let topology_provider = Self::setup_topology_provider(
@@ -1204,53 +1136,3 @@ pub struct BaseClient {
     pub forget_me: ForgetMe,
     pub remember_me: RememberMe,
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use nym_network_defaults::{ApiUrl, NymNetworkDetails};
-
-    #[test]
-    fn test_network_details_with_multiple_urls() {
-        // Verify that network details can be configured with multiple API URLs
-        let mut network_details = NymNetworkDetails::new_empty();
-        network_details.nym_api_urls = Some(vec![
-            ApiUrl {
-                url: "https://validator.nymtech.net/api/".to_string(),
-                front_hosts: None,
-            },
-            ApiUrl {
-                url: "https://nym-frontdoor.vercel.app/api/".to_string(),
-                front_hosts: Some(vec!["vercel.app".to_string(), "vercel.com".to_string()]),
-            },
-        ]);
-
-        assert_eq!(network_details.nym_api_urls.as_ref().unwrap().len(), 2);
-        assert!(network_details.nym_api_urls.as_ref().unwrap()[1]
-            .front_hosts
-            .is_some());
-    }
-
-    #[test]
-    fn test_network_details_with_front_hosts() {
-        // Verify that ApiUrl can store domain fronting configuration
-        let api_url = ApiUrl {
-            url: "https://nym-frontdoor.vercel.app/api/".to_string(),
-            front_hosts: Some(vec!["vercel.app".to_string(), "vercel.com".to_string()]),
-        };
-
-        assert_eq!(api_url.url, "https://nym-frontdoor.vercel.app/api/");
-        assert_eq!(api_url.front_hosts.as_ref().unwrap().len(), 2);
-        assert!(api_url
-            .front_hosts
-            .as_ref()
-            .unwrap()
-            .contains(&"vercel.app".to_string()));
-    }
-
-    #[test]
-    fn test_default_nym_api_retries_constant() {
-        // Verify the retry constant is set correctly
-        assert_eq!(DEFAULT_NYM_API_RETRIES, 3);
-    }
-}

common/client-core/src/client/mix_traffic/mod.rs

@@ -20,10 +20,7 @@ pub mod transceiver;
 
 // We remind ourselves that 32 x 32kb = 1024kb, a reasonable size for a network buffer.
 pub const MIX_MESSAGE_RECEIVER_BUFFER_SIZE: usize = 32;
-
-/// Reduced from 100 to 20 to fail fast (~1-2 seconds instead of ~6 seconds).
-/// If we can't send 20 packets in a row, the gateway is unreachable.
-const MAX_FAILURE_COUNT: usize = 20;
+const MAX_FAILURE_COUNT: usize = 100;
 
 // that's also disgusting.
 pub struct Empty;

common/client-core/src/client/real_messages_control/real_traffic_stream.rs

@@ -120,9 +120,6 @@ where
     stats_tx: ClientStatsSender,
 
     shutdown_token: ShutdownToken,
-
-    /// Flag to indicate that the mix_tx channel is closed and we should stop processing
-    mix_tx_closed: bool,
 }
 
 #[derive(Debug)]
@@ -198,7 +195,6 @@ where
             lane_queue_lengths,
             stats_tx,
             shutdown_token,
-            mix_tx_closed: false,
         }
     }
 
@@ -301,13 +297,7 @@ where
                     tracing::error!(
                         "failed to send mixnet packet due to closed channel (outside of shutdown!)"
                     );
-                    // Set the flag to break out of the main loop
-                    // This prevents an loop where we keep trying to send
-                    // packets through a closed channel
-                    self.mix_tx_closed = true;
                 }
-                // Early return to avoid further processing when channel is closed
-                return;
             }
             Ok(_) => {
                 let event = if fragment_id.is_some() {
@@ -611,12 +601,6 @@ where
                     }
                     next_message = self.next() => if let Some(next_message) = next_message {
                         self.on_message(next_message).await;
-                        // Check if mix_tx channel was closed during on_message
-                        // and break immediately to prevent loop
-                        if self.mix_tx_closed {
-                            tracing::error!("OutQueueControl: mix_tx channel closed, stopping traffic stream");
-                            break;
-                        }
                     } else {
                         tracing::trace!("OutQueueControl: Stopping since channel closed");
                         break;
@@ -636,12 +620,6 @@ where
                     }
                     next_message = self.next() => if let Some(next_message) = next_message {
                         self.on_message(next_message).await;
-                        // Check if mix_tx channel was closed during on_message
-                        // and break immediately to prevent infinite loop
-                        if self.mix_tx_closed {
-                            tracing::error!("OutQueueControl: mix_tx channel closed, stopping traffic stream");
-                            break;
-                        }
                     } else {
                         tracing::trace!("OutQueueControl: Stopping since channel closed");
                         break;

common/client-core/src/init/helpers.rs

@@ -151,7 +151,7 @@ pub async fn gateways_for_init(
     }
 
     let retry_count = retry_count.unwrap_or(DEFAULT_NYM_API_RETRIES);
-    let mut builder = nym_http_api_client::ClientBuilder::new_with_urls(nym_api_urls.clone())?
+    let mut builder = nym_http_api_client::ClientBuilder::new_with_urls(nym_api_urls.clone())
         .with_retries(retry_count)
         .with_bincode();
 

common/http-api-client/src/lib.rs

@@ -296,9 +296,6 @@ impl std::error::Error for ReqwestErrorWrapper {}
 #[derive(Debug, Error)]
 #[allow(missing_docs)]
 pub enum HttpClientError {
-    #[error("did not provide any valid client URLs")]
-    NoUrlsProvided,
-
     #[error("failed to construct inner reqwest client: {source}")]
     ReqwestBuildError {
         #[source]
@@ -585,29 +582,24 @@ impl ClientBuilder {
             Self::new(alt)
         } else {
             let url = url.to_url()?;
-            Self::new_with_urls(vec![url])
+            Ok(Self::new_with_urls(vec![url]))
         }
     }
 
     /// Create a client builder from network details with sensible defaults
     #[cfg(feature = "network-defaults")]
-    // deprecating function since it's not clear from its signature whether the client
-    // would be constructed using `nym_api_urls` or `nym_vpn_api_urls`
-    #[deprecated(note = "use explicit Self::new_with_fronted_urls instead")]
     pub fn from_network(
         network: &nym_network_defaults::NymNetworkDetails,
     ) -> Result<Self, HttpClientError> {
-        let urls = network.nym_api_urls.as_ref().cloned().unwrap_or_default();
-        Self::new_with_fronted_urls(urls.clone())
-    }
-
-    /// Create a client builder using the provided set of domain-fronted URLs
-    #[cfg(feature = "network-defaults")]
-    pub fn new_with_fronted_urls(
-        urls: Vec<nym_network_defaults::ApiUrl>,
-    ) -> Result<Self, HttpClientError> {
-        let urls = urls
-            .into_iter()
+        let urls = network
+            .nym_api_urls
+            .as_ref()
+            .ok_or_else(|| {
+                HttpClientError::GenericRequestFailure(
+                    "No API URLs configured in network details".to_string(),
+                )
+            })?
+            .iter()
             .map(|api_url| {
                 // Convert ApiUrl to our Url type with fronting support
                 let mut url = Url::parse(&api_url.url)?;
@@ -619,19 +611,15 @@ impl ClientBuilder {
                         .iter()
                         .map(|host| format!("https://{}", host))
                         .collect();
-                    url = Url::new(api_url.url.clone(), Some(fronts)).map_err(|source| {
-                        HttpClientError::MalformedUrl {
-                            raw: api_url.url.clone(),
-                            source,
-                        }
-                    })?;
+                    url = Url::new(api_url.url.clone(), Some(fronts))
+                        .map_err(|e| HttpClientError::GenericRequestFailure(e.to_string()))?;
                 }
 
                 Ok(url)
             })
             .collect::<Result<Vec<_>, HttpClientError>>()?;
 
-        let mut builder = Self::new_with_urls(urls)?;
+        let mut builder = Self::new_with_urls(urls);
 
         // Enable domain fronting by default (on retry)
         #[cfg(feature = "tunneling")]
@@ -643,11 +631,7 @@ impl ClientBuilder {
     }
 
     /// Constructs a new http `ClientBuilder` from a valid url.
-    pub fn new_with_urls(urls: Vec<Url>) -> Result<Self, HttpClientError> {
-        if urls.is_empty() {
-            return Err(HttpClientError::NoUrlsProvided);
-        }
-
+    pub fn new_with_urls(urls: Vec<Url>) -> Self {
         let urls = Self::check_urls(urls);
 
         #[cfg(target_arch = "wasm32")]
@@ -656,7 +640,7 @@ impl ClientBuilder {
         #[cfg(not(target_arch = "wasm32"))]
         let reqwest_client_builder = default_builder();
 
-        Ok(ClientBuilder {
+        ClientBuilder {
             urls,
             timeout: None,
             custom_user_agent: false,
@@ -667,7 +651,7 @@ impl ClientBuilder {
 
             retry_limit: 0,
             serialization: SerializationFormat::Json,
-        })
+        }
     }
 
     /// Add an additional URL to the set usable by this constructed `Client`
@@ -964,13 +948,13 @@ impl Client {
 
                     return (url.as_str(), url.front_str());
                 } else {
-                    tracing::debug!(
-                        "Domain fronting is enabled, but no host_url is defined for current URL"
+                    warn!(
+                        "Domain fronting is enabled, but no host_url is defined! Domain fronting WILL NOT WORK"
                     )
                 }
             } else {
-                tracing::debug!(
-                    "Domain fronting is enabled, but current URL has no front_hosts configured"
+                warn!(
+                    "Domain fronting is enabled, but no front_url is defined! Domain fronting WILL NOT WORK"
                 )
             }
         }

common/http-api-client/src/registry.rs

@@ -21,10 +21,6 @@ inventory::collect!(ConfigRecord);
 /// Returns the default builder with all registered configurations applied.
 pub fn default_builder() -> ReqwestClientBuilder {
     let mut b = ReqwestClientBuilder::new();
-
-    #[cfg(feature = "debug-inventory")]
-    let mut test_client = ReqwestClientBuilder::new();
-
     let mut records: Vec<&'static ConfigRecord> =
         inventory::iter::<ConfigRecord>.into_iter().collect();
     records.sort_by_key(|r| r.priority); // lower runs first
@@ -39,10 +35,6 @@ pub fn default_builder() -> ReqwestClientBuilder {
 
     for r in records {
         b = (r.apply)(b);
-        #[cfg(feature = "debug-inventory")]
-        {
-            test_client = (r.apply)(test_client);
-        }
     }
 
     #[cfg(feature = "debug-inventory")]
@@ -55,7 +47,7 @@ pub fn default_builder() -> ReqwestClientBuilder {
         eprintln!("[HTTP-INVENTORY] Building test client to verify configuration...");
 
         // Try to build a client to see if it works
-        match test_client.build() {
+        match b.try_clone().unwrap().build() {
             Ok(client) => {
                 eprintln!("[HTTP-INVENTORY] ✓ Client built successfully");
                 eprintln!("[HTTP-INVENTORY] Client debug info: {:#?}", client);

common/http-api-client/src/tests.rs

@@ -2,77 +2,77 @@ use super::*;
 
 #[test]
 fn sanitizing_urls() {
-    let base_url: Url = "http://api.test".parse().unwrap();
+    let base_url: Url = "http://foomp.com".parse().unwrap();
 
     // works with a full string
     assert_eq!(
-        "http://api.test/foo/bar",
+        "http://foomp.com/foo/bar",
         sanitize_url(&base_url, "/foo//bar/", NO_PARAMS).as_str()
     );
 
     // (and leading slash doesn't matter)
     assert_eq!(
-        "http://api.test/foo/bar",
+        "http://foomp.com/foo/bar",
         sanitize_url(&base_url, "foo//bar/", NO_PARAMS).as_str()
     );
 
     // works with 1 segment
     assert_eq!(
-        "http://api.test/foo",
+        "http://foomp.com/foo",
         sanitize_url(&base_url, &["foo"], NO_PARAMS).as_str()
     );
 
     // works with 2 segments
     assert_eq!(
-        "http://api.test/foo/bar",
+        "http://foomp.com/foo/bar",
         sanitize_url(&base_url, &["foo", "bar"], NO_PARAMS).as_str()
     );
 
     // works with leading slash
     assert_eq!(
-        "http://api.test/foo",
+        "http://foomp.com/foo",
         sanitize_url(&base_url, &["/foo"], NO_PARAMS).as_str()
     );
     assert_eq!(
-        "http://api.test/foo/bar",
+        "http://foomp.com/foo/bar",
         sanitize_url(&base_url, &["/foo", "bar"], NO_PARAMS).as_str()
     );
     assert_eq!(
-        "http://api.test/foo/bar",
+        "http://foomp.com/foo/bar",
         sanitize_url(&base_url, &["foo", "/bar"], NO_PARAMS).as_str()
     );
 
     // works with trailing slash
     assert_eq!(
-        "http://api.test/foo",
+        "http://foomp.com/foo",
         sanitize_url(&base_url, &["foo/"], NO_PARAMS).as_str()
     );
     assert_eq!(
-        "http://api.test/foo/bar",
+        "http://foomp.com/foo/bar",
         sanitize_url(&base_url, &["foo/", "bar"], NO_PARAMS).as_str()
     );
     assert_eq!(
-        "http://api.test/foo/bar",
+        "http://foomp.com/foo/bar",
         sanitize_url(&base_url, &["foo", "bar/"], NO_PARAMS).as_str()
     );
 
     // works with both leading and trailing slash
     assert_eq!(
-        "http://api.test/foo",
+        "http://foomp.com/foo",
         sanitize_url(&base_url, &["/foo/"], NO_PARAMS).as_str()
     );
     assert_eq!(
-        "http://api.test/foo/bar",
+        "http://foomp.com/foo/bar",
         sanitize_url(&base_url, &["/foo/", "/bar/"], NO_PARAMS).as_str()
     );
 
     // adds params
     assert_eq!(
-        "http://api.test/foo/bar?foomp=baz",
+        "http://foomp.com/foo/bar?foomp=baz",
         sanitize_url(&base_url, &["foo", "bar"], &[("foomp", "baz")]).as_str()
     );
     assert_eq!(
-        "http://api.test/foo/bar?arg1=val1&arg2=val2",
+        "http://foomp.com/foo/bar?arg1=val1&arg2=val2",
         sanitize_url(
             &base_url,
             &["/foo/", "/bar/"],
@@ -91,87 +91,83 @@ fn sanitizing_urls() {
 #[tokio::test]
 async fn api_client_retry() -> Result<(), Box<dyn std::error::Error>> {
     let client = ClientBuilder::new_with_urls(vec![
-        "http://broken.nym.test".parse()?,         // This will fail
-        "https://httpbin.org/status/200".parse()?, // This will succeed
-    ])?
+        "http://broken.nym.badurl".parse()?,
+        "http://example.com/".parse()?,
+    ])
     .with_retries(3)
     .build()?;
 
-    let req = client.create_get_request(&[], NO_PARAMS).unwrap();
+    let req = client.create_get_request(&["/"], NO_PARAMS).unwrap();
     let resp = client.send(req).await?;
 
-    // The main test is that we successfully retried and switched to the working URL
-    // We accept any response from the working endpoint since external services can be unreliable
-    assert_eq!(
-        client.current_url().as_str(),
-        "https://httpbin.org/status/200"
-    );
+    assert_eq!(resp.status(), 200);
 
-    println!("Response status: {}", resp.status());
+    // check that the url was updated
+    assert_eq!(client.current_url().as_str(), "http://example.com/");
 
     Ok(())
 }
 
 #[test]
 fn host_updating() {
-    let url = Url::new("http://nym-api1.test", None).unwrap();
+    let url = Url::new("http://example.com", None).unwrap();
     let mut client = ClientBuilder::new(url).unwrap().build().unwrap();
 
     // check that the url is set correctly
     let current_url = client.current_url();
-    assert_eq!(current_url.as_str(), "http://nym-api1.test/");
+    assert_eq!(current_url.as_str(), "http://example.com/");
     assert_eq!(current_url.front_str(), None);
 
     // update the url
     client.update_host();
 
     // check that the url is still the same since there is one URL
-    assert_eq!(client.current_url().as_str(), "http://nym-api1.test/");
+    assert_eq!(client.current_url().as_str(), "http://example.com/");
 
     // =======================================
     // we rotate through urls when available
 
     let new_urls = vec![
-        Url::new("http://nym-api1.test", None).unwrap(),
-        Url::new("http://nym-api2.test", None).unwrap(),
+        Url::new("http://example.com", None).unwrap(),
+        Url::new("http://example.org", None).unwrap(),
     ];
     client.change_base_urls(new_urls);
-    assert_eq!(client.current_url().as_str(), "http://nym-api1.test/");
+    assert_eq!(client.current_url().as_str(), "http://example.com/");
 
     client.update_host();
 
     // check that the url got updated now that there are multiple URLs
-    assert_eq!(client.current_url().as_str(), "http://nym-api2.test/");
+    assert_eq!(client.current_url().as_str(), "http://example.org/");
     assert_eq!(client.current_url().front_str(), None);
 
     client.update_host();
-    assert_eq!(client.current_url().as_str(), "http://nym-api1.test/");
+    assert_eq!(client.current_url().as_str(), "http://example.com/");
 
     // =======================================
     // we rotate through urls when available if fronting is disabled
 
     let new_urls = vec![
         Url::new(
-            "http://nym-api1.test",
-            Some(vec!["http://cdn1.test", "http://cdn2.test"]),
+            "http://example.com",
+            Some(vec!["http://front1.com", "http://front2.com"]),
         )
         .unwrap(),
-        Url::new("http://nym-api2.test", None).unwrap(),
+        Url::new("http://example.org", None).unwrap(),
     ];
     client.change_base_urls(new_urls);
 
-    assert_eq!(client.current_url().as_str(), "http://nym-api1.test/");
+    assert_eq!(client.current_url().as_str(), "http://example.com/");
 
     client.update_host();
 
     // check that the url got updated now that there are multiple URLs
-    assert_eq!(client.current_url().as_str(), "http://nym-api2.test/");
+    assert_eq!(client.current_url().as_str(), "http://example.org/");
 }
 
 #[test]
 #[cfg(feature = "tunneling")]
 fn fronted_host_updating() {
-    let url = Url::new("http://nym-api.test", Some(vec!["http://cdn1.test"])).unwrap();
+    let url = Url::new("http://example.com", Some(vec!["http://front1.com"])).unwrap();
     let mut client = ClientBuilder::new(url)
         .unwrap()
         .with_fronting(crate::fronted::FrontPolicy::Always)
@@ -180,103 +176,46 @@ fn fronted_host_updating() {
 
     // check that the url is set correctly
     let current_url = client.current_url();
-    assert_eq!(current_url.as_str(), "http://nym-api.test/");
-    assert_eq!(current_url.front_str(), Some("cdn1.test"));
+    assert_eq!(current_url.as_str(), "http://example.com/");
+    assert_eq!(current_url.front_str(), Some("front1.com"));
 
     // update the url
     client.update_host();
 
     // check that the url is still the same since there is one URL and one front
     let current_url = client.current_url();
-    assert_eq!(current_url.as_str(), "http://nym-api.test/");
-    assert_eq!(current_url.front_str(), Some("cdn1.test"));
+    assert_eq!(current_url.as_str(), "http://example.com/");
+    assert_eq!(current_url.front_str(), Some("front1.com"));
 
     // =======================================
     // we rotate through front urls when available if fronting is enabled
 
     let new_urls = vec![
         Url::new(
-            "http://nym-api.test",
-            Some(vec!["http://cdn1.test", "http://cdn2.test"]),
+            "http://example.com",
+            Some(vec!["http://front1.com", "http://front2.com"]),
         )
         .unwrap(),
-        Url::new("http://nym-api2.test", None).unwrap(),
+        Url::new("http://example.org", None).unwrap(),
     ];
     client.change_base_urls(new_urls);
 
     let current_url = client.current_url();
-    assert_eq!(current_url.as_str(), "http://nym-api.test/");
-    assert_eq!(current_url.front_str(), Some("cdn1.test"));
+    assert_eq!(current_url.as_str(), "http://example.com/");
+    assert_eq!(current_url.front_str(), Some("front1.com"));
 
     // update the url - this should keep the same host but change the front
     client.update_host();
 
     let current_url = client.current_url();
     // check that the url is still the same since there is one URL
-    assert_eq!(current_url.as_str(), "http://nym-api.test/");
-    assert_eq!(current_url.front_str(), Some("cdn2.test"));
+    assert_eq!(current_url.as_str(), "http://example.com/");
+    assert_eq!(current_url.front_str(), Some("front2.com"));
 
     // update the url - this should wrap around to the first front as the second url is not fronted
     client.update_host();
 
     let current_url = client.current_url();
-    assert_eq!(current_url.as_str(), "http://nym-api.test/");
-    assert_eq!(current_url.front_str(), Some("cdn1.test"));
-}
-
-#[test]
-#[cfg(feature = "network-defaults")]
-fn from_network_configures_multiple_urls_and_retries() {
-    use nym_network_defaults::{ApiUrl, NymNetworkDetails};
-
-    // Create network details with multiple URLs and fronting
-    let mut network_details = NymNetworkDetails::new_empty();
-    network_details.nym_api_urls = Some(vec![
-        ApiUrl {
-            url: "https://validator.nymtech.net/api/".to_string(),
-            front_hosts: None,
-        },
-        ApiUrl {
-            url: "https://nym-frontdoor.vercel.app/api/".to_string(),
-            front_hosts: Some(vec!["vercel.app".to_string(), "vercel.com".to_string()]),
-        },
-        ApiUrl {
-            url: "https://nym-frontdoor.global.ssl.fastly.net/api/".to_string(),
-            front_hosts: Some(vec!["yelp.global.ssl.fastly.net".to_string()]),
-        },
-    ]);
-
-    // Build client from network details
-    let client = ClientBuilder::new_with_fronted_urls(
-        network_details.nym_api_urls.clone().unwrap_or_default(),
-    )
-    .expect("Failed to create client from network")
-    .build()
-    .expect("Failed to build client");
-
-    // Verify all URLs were configured
-    assert_eq!(
-        client.base_urls().len(),
-        3,
-        "Expected 3 URLs to be configured from network details"
-    );
-
-    // Verify the URLs have fronting configured where appropriate
-    assert_eq!(
-        client.base_urls()[0].as_str(),
-        "https://validator.nymtech.net/api/"
-    );
-    assert!(client.base_urls()[0].front_str().is_none());
-
-    assert_eq!(
-        client.base_urls()[1].as_str(),
-        "https://nym-frontdoor.vercel.app/api/"
-    );
-    assert!(client.base_urls()[1].front_str().is_some());
-
-    assert_eq!(
-        client.base_urls()[2].as_str(),
-        "https://nym-frontdoor.global.ssl.fastly.net/api/"
-    );
-    assert!(client.base_urls()[2].front_str().is_some());
+    assert_eq!(current_url.as_str(), "http://example.com/");
+    assert_eq!(current_url.front_str(), Some("front1.com"));
 }

common/network-defaults/src/network.rs

@@ -124,8 +124,6 @@ impl NymNetworkDetails {
             }
         }
 
-        let nym_api = var(var_names::NYM_API).expect("nym api not set");
-
         NymNetworkDetails::new_empty()
             .with_network_name(var(var_names::NETWORK_NAME).expect("network name not set"))
             .with_bech32_account_prefix(
@@ -151,7 +149,7 @@ impl NymNetworkDetails {
             })
             .with_additional_validator_endpoint(ValidatorDetails::new(
                 var(var_names::NYXD).expect("nyxd validator not set"),
-                Some(nym_api.clone()),
+                Some(var(var_names::NYM_API).expect("nym api not set")),
                 get_optional_env(var_names::NYXD_WEBSOCKET),
             ))
             .with_mixnet_contract(get_optional_env(var_names::MIXNET_CONTRACT_ADDRESS))
@@ -161,10 +159,6 @@ impl NymNetworkDetails {
             .with_multisig_contract(get_optional_env(var_names::MULTISIG_CONTRACT_ADDRESS))
             .with_coconut_dkg_contract(get_optional_env(var_names::COCONUT_DKG_CONTRACT_ADDRESS))
             .with_nym_vpn_api_url(get_optional_env(var_names::NYM_VPN_API))
-            .with_nym_api_urls(Some(vec![ApiUrl {
-                url: nym_api,
-                front_hosts: None,
-            }]))
     }
 
     pub fn new_mainnet() -> Self {
@@ -354,12 +348,6 @@ impl NymNetworkDetails {
         self
     }
 
-    #[must_use]
-    pub fn with_nym_api_urls(mut self, urls: Option<Vec<ApiUrl>>) -> Self {
-        self.nym_api_urls = urls;
-        self
-    }
-
     pub fn nym_vpn_api_url(&self) -> Option<Url> {
         self.nym_vpn_api_url.as_ref().map(|url| {
             url.parse()

contracts/coconut-dkg/src/contract.rs

@@ -259,7 +259,7 @@ pub fn migrate(deps: DepsMut<'_>, env: Env, _msg: MigrateMsg) -> Result<Response
     set_build_information!(deps.storage)?;
     cw2::ensure_from_older_version(deps.storage, CONTRACT_NAME, CONTRACT_VERSION)?;
 
-    crate::queued_migrations::introduce_historical_epochs(deps, env)?;
+    // crate::queued_migrations::introduce_historical_epochs(deps, env)?;
 
     Ok(Response::new())
 }

nym-node-status-api/nym-node-status-api/src/metrics_scraper/mod.rs

@@ -57,7 +57,7 @@ async fn run(
         .clone()
         .expect("rust sdk mainnet default missing api_url");
 
-    let nym_api = nym_http_api_client::ClientBuilder::new_with_urls(vec![default_api_url.into()])?
+    let nym_api = nym_http_api_client::ClientBuilder::new_with_urls(vec![default_api_url.into()])
         .no_hickory_dns()
         .with_timeout(nym_api_client_timeout)
         .build()?;

nym-node-status-api/nym-node-status-api/src/monitor/mod.rs

@@ -98,7 +98,7 @@ impl Monitor {
             .expect("rust sdk mainnet default missing api_url");
 
         let nym_api =
-            nym_http_api_client::ClientBuilder::new_with_urls(vec![default_api_url.into()])?
+            nym_http_api_client::ClientBuilder::new_with_urls(vec![default_api_url.into()])
                 .no_hickory_dns()
                 .with_timeout(self.nym_api_client_timeout)
                 .build()?;

sdk/rust/nym-sdk/examples/non_active_gateway_test.rs

@@ -1,636 +0,0 @@
-// Copyright 2025 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-// Gateway Active Set Validation Test
-//
-// - nym-vpn-api shows ALL gateways
-// - nym-api epoch rewarded set has limited nodes (sandbox: 1 entry, 1 exit)
-// - dVPN mode requires mixnet registration
-// - If gateway isn't in epoch rewarded set, does registration fail?
-// - Result: "no gateway with id" errors on mainnet
-//
-// THE TEST SCENARIOS:
-// 1. Active entry gateway -> any node (in or out of rewarded set)
-// 2. Non-active entry gateway -> active node
-// 3. Non-active entry gateway -> another non-active node
-
-use nym_network_defaults::setup_env;
-use nym_sdk::mixnet::{self, MixnetMessageSender};
-use nym_topology::EpochRewardedSet;
-use nym_validator_client::nym_api::NymApiClientExt;
-
-#[derive(Debug, Clone)]
-struct GatewayInfo {
-    node_id: u32,
-    identity: String,
-    role: String,
-}
-
-async fn analyze_network() -> anyhow::Result<NetworkAnalysis> {
-    // Get nym-api URL from network details (already set to sandbox via setup_env)
-    let network_details = nym_network_defaults::NymNetworkDetails::new_from_env();
-    let nym_api = network_details
-        .nym_api_urls
-        .as_ref()
-        .and_then(|urls| urls.first())
-        .and_then(|api_url| api_url.url.parse::<url::Url>().ok())
-        .unwrap_or_else(|| "https://sandbox-nym-api1.nymtech.net/api/".parse().unwrap());
-
-    tracing::info!("Using nym-api: {}", nym_api);
-
-    let validator_client = nym_http_api_client::Client::builder(nym_api)
-        .expect("Failed to create API client builder")
-        .build()
-        .expect("Failed to build API client");
-
-    // Get epoch rewarded set from contract
-    let rewarded_set = validator_client
-        .get_current_rewarded_set()
-        .await
-        .expect("Failed to get rewarded set");
-
-    let epoch_rewarded_set: EpochRewardedSet = rewarded_set.into();
-
-    tracing::info!("========================================");
-    tracing::info!("Current Epoch Rewarded Set (from contract):");
-    tracing::info!(
-        "  Entry gateways: {:?}",
-        epoch_rewarded_set.assignment.entry_gateways
-    );
-    tracing::info!(
-        "  Exit gateways: {:?}",
-        epoch_rewarded_set.assignment.exit_gateways
-    );
-    tracing::info!(
-        "  Layer 1 (mixnodes): {:?}",
-        epoch_rewarded_set.assignment.layer1
-    );
-    tracing::info!(
-        "  Layer 2 (mixnodes): {:?}",
-        epoch_rewarded_set.assignment.layer2
-    );
-    tracing::info!(
-        "  Layer 3 (mixnodes): {:?}",
-        epoch_rewarded_set.assignment.layer3
-    );
-    tracing::info!("========================================");
-
-    // Get ALL entry-capable nodes
-    let all_entry_nodes = validator_client
-        .get_all_basic_entry_assigned_nodes_with_metadata()
-        .await
-        .expect("Failed to get all entry nodes");
-
-    tracing::info!("Total entry-capable nodes: {}", all_entry_nodes.nodes.len());
-
-    let mut active_entry_gateways = Vec::new();
-    let mut non_active_entry_gateways = Vec::new();
-
-    for node in all_entry_nodes.nodes {
-        let in_rewarded_set = epoch_rewarded_set
-            .assignment
-            .entry_gateways
-            .contains(&node.node_id)
-            || epoch_rewarded_set
-                .assignment
-                .exit_gateways
-                .contains(&node.node_id);
-
-        let gateway_info = GatewayInfo {
-            node_id: node.node_id,
-            identity: node.ed25519_identity_pubkey.to_string(),
-            role: if epoch_rewarded_set
-                .assignment
-                .entry_gateways
-                .contains(&node.node_id)
-            {
-                "entry".to_string()
-            } else if epoch_rewarded_set
-                .assignment
-                .exit_gateways
-                .contains(&node.node_id)
-            {
-                "exit".to_string()
-            } else {
-                "not in set".to_string()
-            },
-        };
-
-        if in_rewarded_set {
-            active_entry_gateways.push(gateway_info);
-        } else {
-            non_active_entry_gateways.push(gateway_info);
-        }
-    }
-
-    tracing::info!("");
-    tracing::info!(
-        "Gateways in current epoch rewarded set: {}",
-        active_entry_gateways.len()
-    );
-    for gw in &active_entry_gateways {
-        tracing::info!(
-            "  - Node ID {}: {} (role: {})",
-            gw.node_id,
-            gw.identity,
-            gw.role
-        );
-    }
-
-    tracing::info!("");
-    tracing::info!(
-        "Gateways NOT in rewarded set: {}",
-        non_active_entry_gateways.len()
-    );
-    for gw in non_active_entry_gateways.iter().take(5) {
-        tracing::info!(
-            "  - Node ID {}: {} (has entry capability but not in epoch set)",
-            gw.node_id,
-            gw.identity
-        );
-    }
-    if non_active_entry_gateways.len() > 5 {
-        tracing::info!("  ... and {} more", non_active_entry_gateways.len() - 5);
-    }
-
-    Ok(NetworkAnalysis {
-        active_entry_gateways,
-        non_active_entry_gateways,
-    })
-}
-
-struct NetworkAnalysis {
-    active_entry_gateways: Vec<GatewayInfo>,
-    non_active_entry_gateways: Vec<GatewayInfo>,
-}
-
-async fn test_scenario_1(analysis: &NetworkAnalysis) -> anyhow::Result<()> {
-    tracing::info!("");
-    tracing::info!("========================================");
-    tracing::info!("Scenario 1: Active entry gateway -> send/receive messages");
-    tracing::info!("========================================");
-
-    if analysis.active_entry_gateways.is_empty() {
-        tracing::warn!("No active entry gateways found - skipping scenario 1");
-        return Ok(());
-    }
-
-    let active_gateway = &analysis.active_entry_gateways[0];
-    tracing::info!(
-        "Requesting specific gateway: Node ID {}",
-        active_gateway.node_id
-    );
-    tracing::info!("Gateway identity: {}", active_gateway.identity);
-    tracing::info!(
-        "This gateway IS in epoch rewarded set (role: {})",
-        active_gateway.role
-    );
-
-    let network_details = nym_network_defaults::NymNetworkDetails::new_from_env();
-
-    let mut client = mixnet::MixnetClientBuilder::new_ephemeral()
-        .network_details(network_details)
-        .request_gateway(active_gateway.identity.clone())
-        .build()?
-        .connect_to_mixnet()
-        .await?;
-
-    let our_address = client.nym_address();
-    tracing::info!("Connected with address: {}", our_address);
-
-    // Send test message
-    client
-        .send_plain_message(*our_address, "Scenario 1 test")
-        .await?;
-    tracing::info!("Message sent, waiting for reply...");
-
-    // Wait for reply
-    let (tx, mut rx) = tokio::sync::mpsc::channel(1);
-    let timeout = tokio::time::Duration::from_secs(30);
-
-    let result = tokio::time::timeout(timeout, async {
-        tokio::select! {
-            _ = client.on_messages(|msg| {
-                tracing::info!("Received: {}", String::from_utf8_lossy(&msg.message));
-                let _ = tx.try_send(());
-            }) => {},
-            _ = rx.recv() => { return true; }
-        }
-        false
-    })
-    .await;
-
-    match result {
-        Ok(true) => {
-            tracing::info!("SUCCESS: Scenario 1 passed - active gateway works");
-            Ok(())
-        }
-        _ => {
-            tracing::error!("FAILED: Scenario 1 - active gateway didn't receive message");
-            anyhow::bail!("Scenario 1 failed");
-        }
-    }
-}
-
-async fn test_scenario_2(analysis: &NetworkAnalysis) -> anyhow::Result<()> {
-    tracing::info!("");
-    tracing::info!("========================================");
-    tracing::info!("Scenario 2: NON-ACTIVE entry gateway -> send/receive (Important)");
-    tracing::info!("========================================");
-
-    if analysis.non_active_entry_gateways.is_empty() {
-        tracing::warn!("No non-active gateways found - all are in rewarded set");
-        tracing::warn!("This means the TODO is irrelevant - no filtering needed");
-        return Ok(());
-    }
-
-    let non_active_gw = &analysis.non_active_entry_gateways[0];
-    tracing::info!(
-        "Requesting NON-ACTIVE gateway: Node ID {}",
-        non_active_gw.node_id
-    );
-    tracing::info!("Gateway identity: {}", non_active_gw.identity);
-    tracing::info!("This gateway has entry capability but is NOT in epoch rewarded set");
-    tracing::info!("If this works, we can use ALL entry gateways (not just rewarded set)");
-
-    // The Important test - can we register with a gateway NOT in the rewarded set?
-    let network_details = nym_network_defaults::NymNetworkDetails::new_from_env();
-
-    let mut client = mixnet::MixnetClientBuilder::new_ephemeral()
-        .network_details(network_details)
-        .request_gateway(non_active_gw.identity.clone())
-        .build()?
-        .connect_to_mixnet()
-        .await?;
-
-    let our_address = client.nym_address();
-    tracing::info!("SUCCESS: Registered with non-active gateway!");
-    tracing::info!("Connected with address: {}", our_address);
-
-    // Send test message
-    client
-        .send_plain_message(*our_address, "Scenario 2 test - non-active gateway")
-        .await?;
-    tracing::info!("Message sent, waiting for reply...");
-
-    // Wait for reply
-    let (tx, mut rx) = tokio::sync::mpsc::channel(1);
-    let timeout = tokio::time::Duration::from_secs(30);
-
-    let result = tokio::time::timeout(timeout, async {
-        tokio::select! {
-            _ = client.on_messages(|msg| {
-                tracing::info!("Received: {}", String::from_utf8_lossy(&msg.message));
-                let _ = tx.try_send(());
-            }) => {},
-            _ = rx.recv() => { return true; }
-        }
-        false
-    })
-    .await;
-
-    match result {
-        Ok(true) => {
-            tracing::info!(
-                "SUCCESS: Scenario 2 PASSED - non-active gateway CAN register and message!"
-            );
-            Ok(())
-        }
-        _ => {
-            tracing::error!("FAILED: Scenario 2 - non-active gateway didn't receive message");
-            anyhow::bail!("Scenario 2 failed");
-        }
-    }
-}
-
-async fn test_scenario_3(analysis: &NetworkAnalysis) -> anyhow::Result<()> {
-    tracing::info!("");
-    tracing::info!("========================================");
-    tracing::info!("Scenario 3: Non-active entry -> different non-active gateway");
-    tracing::info!("========================================");
-
-    if analysis.non_active_entry_gateways.len() < 2 {
-        tracing::warn!("Need at least 2 non-active gateways for this test");
-        return Ok(());
-    }
-
-    let entry_gw = &analysis.non_active_entry_gateways[0];
-    let target_gw = &analysis.non_active_entry_gateways[1];
-
-    tracing::info!(
-        "Client 1 using non-active gateway: Node ID {} (NOT in rewarded set)",
-        entry_gw.node_id
-    );
-    tracing::info!(
-        "Client 2 using different non-active gateway: Node ID {} (NOT in rewarded set)",
-        target_gw.node_id
-    );
-
-    // Client 1 - using first non-active gateway
-    let network_details1 = nym_network_defaults::NymNetworkDetails::new_from_env();
-
-    let client1 = mixnet::MixnetClientBuilder::new_ephemeral()
-        .network_details(network_details1)
-        .request_gateway(entry_gw.identity.clone())
-        .build()?
-        .connect_to_mixnet()
-        .await?;
-
-    let client1_address = client1.nym_address();
-    tracing::info!("Client 1 connected: {}", client1_address);
-
-    // Client 2 - using second non-active gateway
-    let network_details2 = nym_network_defaults::NymNetworkDetails::new_from_env();
-
-    let mut client2 = mixnet::MixnetClientBuilder::new_ephemeral()
-        .network_details(network_details2)
-        .request_gateway(target_gw.identity.clone())
-        .build()?
-        .connect_to_mixnet()
-        .await?;
-
-    let client2_address = client2.nym_address();
-    tracing::info!("Client 2 connected: {}", client2_address);
-
-    // Client 1 sends to Client 2
-    client1
-        .send_plain_message(*client2_address, "Test from non-active to non-active")
-        .await?;
-    tracing::info!("Message sent from client 1 to client 2, waiting for reply...");
-
-    // Wait for client 2 to receive
-    let (tx, mut rx) = tokio::sync::mpsc::channel(1);
-    let timeout = tokio::time::Duration::from_secs(30);
-
-    let result = tokio::time::timeout(timeout, async {
-        tokio::select! {
-            _ = client2.on_messages(|msg| {
-                tracing::info!("Client 2 received: {}", String::from_utf8_lossy(&msg.message));
-                let _ = tx.try_send(());
-            }) => {},
-            _ = rx.recv() => { return true; }
-        }
-        false
-    })
-    .await;
-
-    match result {
-        Ok(true) => {
-            tracing::info!("SUCCESS: Scenario 3 PASSED - two non-active gateways CAN communicate!");
-            Ok(())
-        }
-        _ => {
-            tracing::error!(
-                "FAILED: Scenario 3 - communication between non-active gateways failed"
-            );
-            anyhow::bail!("Scenario 3 failed");
-        }
-    }
-}
-
-async fn test_scenario_4(analysis: &NetworkAnalysis) -> anyhow::Result<()> {
-    tracing::info!("");
-    tracing::info!("========================================");
-    tracing::info!("Scenario 4: Multiple non-active gateways registration test");
-    tracing::info!("========================================");
-    tracing::info!("Testing 3-4 different non-active gateways to ensure reliability");
-    tracing::info!("");
-
-    // Determine how many non-active gateways we can test (max 4)
-    let test_count = std::cmp::min(analysis.non_active_entry_gateways.len(), 4);
-
-    if test_count < 3 {
-        tracing::warn!("Not enough non-active gateways to run this test (need at least 3)");
-        return Ok(());
-    }
-
-    let mut successful_registrations = 0;
-    let mut failed_registrations = 0;
-
-    for i in 0..test_count {
-        let gateway = &analysis.non_active_entry_gateways[i];
-        tracing::info!(
-            "  Test {}/{}: Attempting to register with non-active gateway Node ID {}",
-            i + 1,
-            test_count,
-            gateway.node_id
-        );
-        tracing::info!("  Identity: {}", gateway.identity);
-
-        let network_details = nym_network_defaults::NymNetworkDetails::new_from_env();
-
-        match mixnet::MixnetClientBuilder::new_ephemeral()
-            .network_details(network_details)
-            .request_gateway(gateway.identity.clone())
-            .build()
-        {
-            Ok(client_builder) => {
-                match client_builder.connect_to_mixnet().await {
-                    Ok(mut client) => {
-                        let address = client.nym_address();
-                        tracing::info!("SUCCESS: Connected with address {}", address);
-
-                        // Test message send/receive
-                        if let Err(e) = client
-                            .send_plain_message(*address, format!("Test message {}", i))
-                            .await
-                        {
-                            tracing::warn!("Failed to send message: {}", e);
-                        } else {
-                            // Wait briefly for message
-                            let (tx, mut rx) = tokio::sync::mpsc::channel(1);
-                            let timeout = tokio::time::Duration::from_secs(10);
-
-                            let received = tokio::time::timeout(timeout, async {
-                                tokio::select! {
-                                    _ = client.on_messages(|_msg| {
-                                        let _ = tx.try_send(());
-                                    }) => {},
-                                    _ = rx.recv() => { return true; }
-                                }
-                                false
-                            })
-                            .await;
-
-                            if received.unwrap_or(false) {
-                                tracing::info!("Message send/receive confirmed");
-                            } else {
-                                tracing::warn!(
-                                    "Message not received within timeout (but registration worked)"
-                                );
-                            }
-                        }
-
-                        successful_registrations += 1;
-
-                        // Disconnect gracefully
-                        client.disconnect().await;
-                    }
-                    Err(e) => {
-                        tracing::error!("FAILED to connect: {}", e);
-                        failed_registrations += 1;
-                    }
-                }
-            }
-            Err(e) => {
-                tracing::error!("  FAILED to build client: {}", e);
-                failed_registrations += 1;
-            }
-        }
-
-        tracing::info!("");
-
-        // Small delay between tests to avoid overwhelming the network
-        if i < test_count - 1 {
-            tokio::time::sleep(tokio::time::Duration::from_millis(500)).await;
-        }
-    }
-
-    tracing::info!("========================================");
-    tracing::info!("Scenario 4 Results:");
-    tracing::info!("  Total tests: {}", test_count);
-    tracing::info!(
-        "  Successful: {} ({}%)",
-        successful_registrations,
-        (successful_registrations * 100) / test_count
-    );
-    tracing::info!("  Failed: {}", failed_registrations);
-    tracing::info!("========================================");
-
-    if successful_registrations >= (test_count * 2 / 3) {
-        tracing::info!(
-            "SUCCESS: Scenario 4 PASSED - majority of non-active gateways work reliably"
-        );
-        Ok(())
-    } else {
-        tracing::error!("FAILED: Scenario 4 - too many registration failures");
-        anyhow::bail!(
-            "Scenario 4 failed: only {}/{} successful",
-            successful_registrations,
-            test_count
-        );
-    }
-}
-
-#[tokio::main]
-async fn main() -> anyhow::Result<()> {
-    tracing_subscriber::fmt()
-        .with_env_filter(
-            tracing_subscriber::EnvFilter::from_default_env()
-                .add_directive("non_active_gateway_test=info".parse().unwrap())
-                .add_directive("nym_sdk=info".parse().unwrap()),
-        )
-        .with_target(false)
-        .init();
-
-    // Setup environment - defaults to mainnet, or use NYM_ENV_PATH for sandbox
-    // Example: NYM_ENV_PATH=../../../envs/sandbox.env cargo run --example non_active_gateway_test
-    let env_path = std::env::var("NYM_ENV_PATH").ok();
-    let network_name = if env_path.is_some() {
-        "sandbox"
-    } else {
-        "mainnet"
-    };
-    setup_env(env_path.as_deref());
-
-    tracing::info!("Gateway Active Set Validation Test ({})", network_name);
-    tracing::info!("");
-    tracing::info!("Purpose: Validate if we can use gateways NOT in epoch rewarded set");
-    tracing::info!("Context: Epoch changes hourly, only ~1-2 gateways in sandbox rewarded set");
-    tracing::info!(
-        "Problem: App shows 11-12 gateways, but are we limited to the 1-2 in epoch set?"
-    );
-    tracing::info!("Tip: Set NYM_ENV_PATH=../../../envs/sandbox.env to test sandbox network");
-    tracing::info!("");
-
-    // Phase 1: Analyze the network and identify nodes
-    let analysis = analyze_network().await?;
-
-    if analysis.active_entry_gateways.is_empty() {
-        tracing::error!("No active entry gateways found in rewarded set!");
-        tracing::error!("Cannot proceed with tests");
-        anyhow::bail!("No active entry gateways");
-    }
-
-    if analysis.non_active_entry_gateways.is_empty() {
-        tracing::warn!("All entry-capable gateways are in the rewarded set");
-        tracing::warn!("No non-active gateways to test - this means filtering doesn't matter");
-        return Ok(());
-    }
-
-    // Phase 2: Run test scenarios
-    let mut all_passed = true;
-
-    if let Err(e) = test_scenario_1(&analysis).await {
-        tracing::error!("Scenario 1 failed: {}", e);
-        all_passed = false;
-    }
-
-    if let Err(e) = test_scenario_2(&analysis).await {
-        tracing::error!("Scenario 2 failed: {}", e);
-        all_passed = false;
-    }
-
-    if let Err(e) = test_scenario_3(&analysis).await {
-        tracing::error!("Scenario 3 failed: {}", e);
-        all_passed = false;
-    }
-
-    if let Err(e) = test_scenario_4(&analysis).await {
-        tracing::error!("Scenario 4 failed: {}", e);
-        all_passed = false;
-    }
-
-    tracing::info!("");
-    tracing::info!("========================================");
-    tracing::info!("FINAL RESULTS");
-    tracing::info!("========================================");
-    tracing::info!(
-        "Epoch rewarded set: {} gateways (entry + exit)",
-        analysis.active_entry_gateways.len()
-    );
-    tracing::info!(
-        "NOT in rewarded set: {} gateways",
-        analysis.non_active_entry_gateways.len()
-    );
-    tracing::info!("");
-
-    if all_passed {
-        tracing::info!("ALL SCENARIOS PASSED");
-        tracing::info!("");
-        tracing::info!("FINDINGS:");
-        tracing::info!("- Non-active gateways CAN register with mixnet");
-        tracing::info!("- Non-active gateways CAN send and receive messages");
-        tracing::info!("- Communication works between non-active gateways");
-        tracing::info!("- Multiple non-active gateways tested and verified");
-        tracing::info!("");
-        tracing::info!("CONCLUSION:");
-        tracing::info!(
-            "We can use all {} gateways, not just {} in epoch set",
-            analysis.active_entry_gateways.len() + analysis.non_active_entry_gateways.len(),
-            analysis.active_entry_gateways.len()
-        );
-        tracing::info!("Epoch rewarded set is for economics, not technical capability");
-        tracing::info!("This resolves 'no gateway with id' errors");
-    } else {
-        tracing::warn!("SOME SCENARIOS HAD ISSUES (but key tests passed)");
-        tracing::info!("");
-        tracing::info!("CRITICAL FINDINGS:");
-        tracing::info!("Scenario 2 proved non-active gateways CAN register and work");
-        tracing::info!("Scenario 4 tested multiple non-active gateways successfully");
-        tracing::info!(
-            "Some specific gateways may be offline/unreachable (normal network conditions)"
-        );
-        tracing::info!("");
-        tracing::info!("CONCLUSION:");
-        tracing::info!("Non-active gateways ARE technically capable");
-        tracing::info!("Individual gateway availability varies (not all online)");
-        tracing::info!(
-            "We can use all {} gateways, not just {} in epoch set",
-            analysis.active_entry_gateways.len() + analysis.non_active_entry_gateways.len(),
-            analysis.active_entry_gateways.len()
-        );
-    }
-
-    Ok(())
-}

sdk/rust/nym-sdk/src/mixnet/client.rs

@@ -706,16 +706,6 @@ where
             .config
             .as_base_client_config(nyxd_endpoints, nym_api_endpoints.clone());
 
-        tracing::debug!(
-            "SDK: Passing nym_api_urls to BaseClientBuilder (has {} nym_api_urls)",
-            self.config
-                .network_details
-                .nym_api_urls
-                .as_ref()
-                .map(|urls| urls.len())
-                .unwrap_or(0)
-        );
-
         let mut base_builder: BaseClientBuilder<_, _> =
             BaseClientBuilder::new(base_config, self.storage, self.dkg_query_client)
                 .with_wait_for_gateway(self.wait_for_gateway)
@@ -723,11 +713,6 @@ where
                 .with_remember_me(&self.remember_me)
                 .with_derivation_material(self.derivation_material);
 
-        // Add nym_api_urls if available in network_details
-        if let Some(nym_api_urls) = self.config.network_details.nym_api_urls.clone() {
-            base_builder = base_builder.with_nym_api_urls(nym_api_urls);
-        }
-
         if let Some(user_agent) = self.user_agent {
             base_builder = base_builder.with_user_agent(user_agent);
         }

tools/echo-server/src/lib.rs

@@ -226,8 +226,7 @@ mod tests {
                 error!("{err}");
                 // this is not an ideal way of checking it, but if test fails due to networking failures
                 // it should be fine to progress
-                let err_str = err.to_string();
-                if err_str.contains("nym api") || err_str.contains("failed to connect") {
+                if err.to_string().contains("nym api request failed") {
                     return Ok(());
                 }
                 return Err(err);
@@ -292,8 +291,7 @@ mod tests {
                 error!("{err}");
                 // this is not an ideal way of checking it, but if test fails due to networking failures
                 // it should be fine to progress
-                let err_str = err.to_string();
-                if err_str.contains("nym api") || err_str.contains("failed to connect") {
+                if err.to_string().contains("nym api request failed") {
                     return Ok(());
                 }
                 return Err(err);