initial implementation pass

Author: jmwample

Cargo.lock

@@ -10,6 +10,7 @@ rust-version.workspace = true
 [dependencies]
 async-trait.workspace = true
 serde = { workspace = true, features = ["derive"] }
+serde_json.workspace = true
 thiserror.workspace = true
 time.workspace = true
 tokio = { workspace = true, features = ["sync"] }
@@ -20,10 +21,11 @@ zeroize = { workspace = true, features = ["zeroize_derive"] }
 nym-crypto = { path = "../../crypto", features = ["asymmetric"] }
 nym-gateway-requests = { path = "../../gateway-requests" }
 nym-gateway-client = { path = "../../client-libs/gateway-client" }
+nym-topology = { path = "../../topology", features = ["persistence"] }
 
 [target."cfg(not(target_arch = \"wasm32\"))".dependencies.sqlx]
 workspace = true
-features = ["runtime-tokio-rustls", "sqlite", "macros", "migrate", "time"]
+features = ["runtime-tokio-rustls", "sqlite", "macros", "migrate", "time", "json"]
 optional = true
 
 [build-dependencies]
@@ -34,6 +36,7 @@ sqlx = { workspace = true, features = [
     "sqlite",
     "macros",
     "migrate",
+    "json",
 ] }
 
 [features]

common/client-core/gateways-storage/Cargo.toml

@@ -0,0 +1,21 @@
+/*
+ * Copyright 2025 - Nym Technologies SA <[email protected]>
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+CREATE TABLE remote_gateway_details_temp
+(
+    gateway_id_bs58                          TEXT NOT NULL UNIQUE PRIMARY KEY REFERENCES registered_gateway (gateway_id_bs58),
+    derived_aes256_gcm_siv_key               BLOB NOT NULL,
+    gateway_details                          TEXT NOT NULL CHECK (json_valid(gateway_details)),
+    expiration_timestamp                     DATETIME NOT NULL
+);
+
+-- keep none, the gateways listener URL does not contain the gateway details information
+-- INSERT INTO remote_gateway_details_temp SELECT gateway_id_bs58, derived_aes256_gcm_siv_key, gateway_listener, NULL, datetime(0, 'unixepoch') FROM remote_gateway_details WHERE derived_aes256_gcm_siv_key IS NOT NULL;
+
+DROP TABLE remote_gateway_details;
+ALTER TABLE remote_gateway_details_temp RENAME TO remote_gateway_details;
+
+-- delete registrations with no key
+DELETE FROM registered_gateway WHERE gateway_id_bs58 NOT IN ( SELECT gateway_id_bs58 FROM remote_gateway_details);

common/client-core/gateways-storage/fs_gateways_migrations/20251212120000_store_gateway_details.sql

@@ -156,15 +156,16 @@ impl StorageManager {
         &self,
         remote: &RawRemoteGatewayDetails,
     ) -> Result<(), sqlx::Error> {
+        let details =
+            serde_json::to_string(&remote.published_data.gateway_details).expect("AHHHHHHHHH");
         sqlx::query!(
             r#"
-                INSERT INTO remote_gateway_details(gateway_id_bs58, derived_aes256_gcm_siv_key, gateway_listener, fallback_listener, expiration_timestamp)
-                VALUES (?, ?, ?, ?, ?)
+                INSERT INTO remote_gateway_details(gateway_id_bs58, derived_aes256_gcm_siv_key, gateway_details, expiration_timestamp)
+                VALUES (?, ?, ?, ?)
             "#,
             remote.gateway_id_bs58,
             remote.derived_aes256_gcm_siv_key,
-            remote.published_data.gateway_listener,
-            remote.published_data.fallback_listener,
+            details,
             remote.published_data.expiration_timestamp
         )
             .execute(&self.connection_pool)
@@ -177,12 +178,12 @@ impl StorageManager {
         gateway_id_bs58: &str,
         published_data: &RawGatewayPublishedData,
     ) -> Result<(), sqlx::Error> {
+        let details = serde_json::to_string(&published_data.gateway_details).expect("AHHHHHHHHH");
         sqlx::query!(
             r#"
-                UPDATE remote_gateway_details SET gateway_listener = ?, fallback_listener = ?, expiration_timestamp = ? WHERE gateway_id_bs58 = ?
+                UPDATE remote_gateway_details SET gateway_details = ?, expiration_timestamp = ? WHERE gateway_id_bs58 = ?
             "#,
-            published_data.gateway_listener,
-            published_data.fallback_listener,
+            details,
             published_data.expiration_timestamp,
             gateway_id_bs58
         )

common/client-core/gateways-storage/src/backend/fs_backend/manager.rs

@@ -3,6 +3,7 @@
 
 use nym_crypto::asymmetric::ed25519::Ed25519RecoveryError;
 use nym_gateway_requests::shared_key::SharedKeyConversionError;
+use serde_json::Error as JsonError;
 use thiserror::Error;
 
 #[derive(Debug, Error)]
@@ -29,23 +30,11 @@ pub enum BadGateway {
     #[error("could not find any valid shared keys for gateway {gateway_id}")]
     MissingSharedKey { gateway_id: String },
 
-    #[error(
-        "the listening address of gateway {gateway_id} ({raw_listener}) is malformed: {source}"
-    )]
-    MalformedListener {
-        gateway_id: String,
-
-        raw_listener: String,
-
-        #[source]
-        source: url::ParseError,
-    },
-
-    #[error("the listening address ({raw_listener}) is malformed: {source}")]
-    MalformedListenerNoId {
-        raw_listener: String,
+    #[error("the listening address ({raw_details}) is malformed: {source}")]
+    MalformedDetailsNoId {
+        raw_details: String,
 
         #[source]
-        source: url::ParseError,
+        source: JsonError,
     },
 }

common/client-core/gateways-storage/src/error.rs

@@ -3,15 +3,14 @@
 
 use crate::BadGateway;
 use nym_crypto::asymmetric::ed25519;
-use nym_gateway_client::client::GatewayListeners;
 use nym_gateway_requests::shared_key::SharedSymmetricKey;
+use nym_topology::EntryDetails;
 use serde::{Deserialize, Serialize};
 use std::fmt::{Display, Formatter};
 use std::str::FromStr;
 use std::sync::Arc;
 use time::Duration;
 use time::OffsetDateTime;
-use url::Url;
 use zeroize::{Zeroize, ZeroizeOnDrop};
 
 pub const REMOTE_GATEWAY_TYPE: &str = "remote";
@@ -172,14 +171,14 @@ pub struct RegisteredGateway {
 
 #[derive(Debug, Clone)]
 pub struct GatewayPublishedData {
-    pub listeners: GatewayListeners,
+    pub details: EntryDetails,
     pub expiration_timestamp: OffsetDateTime,
 }
 
 impl GatewayPublishedData {
-    pub fn new(listeners: GatewayListeners) -> GatewayPublishedData {
+    pub fn new(details: EntryDetails) -> GatewayPublishedData {
         GatewayPublishedData {
-            listeners,
+            details,
             expiration_timestamp: OffsetDateTime::now_utc() + GATEWAY_DETAILS_TTL,
         }
     }
@@ -188,16 +187,16 @@ impl GatewayPublishedData {
 #[derive(Debug, Serialize, Deserialize, Clone)]
 #[cfg_attr(feature = "sqlx", derive(sqlx::FromRow))]
 pub struct RawGatewayPublishedData {
-    pub gateway_listener: String,
-    pub fallback_listener: Option<String>,
+    #[cfg_attr(feature = "sqlx", sqlx(json))]
+    pub gateway_details: EntryDetails,
     pub expiration_timestamp: OffsetDateTime,
 }
 
 impl<'a> From<&'a GatewayPublishedData> for RawGatewayPublishedData {
     fn from(value: &'a GatewayPublishedData) -> Self {
         Self {
-            gateway_listener: value.listeners.primary.to_string(),
-            fallback_listener: value.listeners.fallback.as_ref().map(|uri| uri.to_string()),
+            // fallback_listener: value.listeners.fallback.as_ref().map(|uri| uri.to_string()),
+            gateway_details: value.details.clone(),
             expiration_timestamp: value.expiration_timestamp,
         }
     }
@@ -207,28 +206,15 @@ impl TryFrom<RawGatewayPublishedData> for GatewayPublishedData {
     type Error = BadGateway;
 
     fn try_from(value: RawGatewayPublishedData) -> Result<Self, Self::Error> {
-        let gateway_listener: Url = Url::parse(&value.gateway_listener).map_err(|source| {
-            BadGateway::MalformedListenerNoId {
-                raw_listener: value.gateway_listener.clone(),
-                source,
-            }
-        })?;
-        let fallback_listener = value
-            .fallback_listener
-            .as_ref()
-            .map(|uri| {
-                Url::parse(uri).map_err(|source| BadGateway::MalformedListenerNoId {
-                    raw_listener: uri.to_owned(),
-                    source,
-                })
-            })
-            .transpose()?;
+        // let details = serde_json::from_str(&value.gateway_listener).map_err(|source| {
+        //     BadGateway::MalformedDetailsNoId  {
+        //         raw_details: value.gateway_listener.clone(),
+        //         source,
+        //     }
+        // })?;
 
         Ok(GatewayPublishedData {
-            listeners: GatewayListeners {
-                primary: gateway_listener,
-                fallback: fallback_listener,
-            },
+            details: value.gateway_details,
             expiration_timestamp: value.expiration_timestamp,
         })
     }

common/client-core/gateways-storage/src/types.rs

@@ -87,7 +87,6 @@ where
         user_chosen_gateway_id.map(|id| id.to_base58_string()),
         Some(common_args.latency_based_selection),
         common_args.force_tls_gateway,
-        false,
     );
     tracing::debug!("Gateway selection specification: {selection_spec:?}");
 
@@ -168,7 +167,6 @@ where
         identity: gateway_details.gateway_id,
         active: common_args.set_active,
         typ: gateway_registration.details.typ().to_string(),
-        endpoint: Some(gateway_details.published_data.listeners.primary.clone()),
-        fallback_endpoint: gateway_details.published_data.listeners.fallback.clone(),
+        endpoint: Some(gateway_details.published_data.details.clone()),
     })
 }

common/client-core/src/cli_helpers/client_add_gateway.rs

@@ -140,7 +140,6 @@ where
         user_chosen_gateway_id.map(|id| id.to_base58_string()),
         Some(common_args.latency_based_selection),
         common_args.force_tls_gateway,
-        false,
     );
     tracing::debug!("Gateway selection specification: {selection_spec:?}");
 

common/client-core/src/cli_helpers/client_init.rs

@@ -56,16 +56,14 @@ where
                 identity: remote_details.gateway_id,
                 active: active_gateway == Some(remote_details.gateway_id),
                 typ: GatewayType::Remote.to_string(),
-                endpoint: Some(remote_details.published_data.listeners.primary.clone()),
-                fallback_endpoint: remote_details.published_data.listeners.fallback.clone(),
+                endpoint: Some(remote_details.published_data.details.clone()),
             }),
             GatewayDetails::Custom(_) => info.push(GatewayInfo {
                 registration: gateway.registration_timestamp,
                 identity: gateway.details.gateway_id(),
                 active: active_gateway == Some(gateway.details.gateway_id()),
                 typ: gateway.details.typ().to_string(),
                 endpoint: None,
-                fallback_endpoint: None,
             }),
         };
     }

common/client-core/src/cli_helpers/client_list_gateways.rs

@@ -2,10 +2,10 @@
 // SPDX-License-Identifier: Apache-2.0
 
 use nym_crypto::asymmetric::ed25519;
+use nym_topology::EntryDetails;
 use serde::{Deserialize, Serialize};
 use std::fmt::{Display, Formatter};
 use time::OffsetDateTime;
-use url::Url;
 
 #[derive(Serialize, Deserialize)]
 pub struct GatewayInfo {
@@ -14,8 +14,7 @@ pub struct GatewayInfo {
     pub active: bool,
 
     pub typ: String,
-    pub endpoint: Option<Url>,
-    pub fallback_endpoint: Option<Url>,
+    pub endpoint: Option<EntryDetails>,
 }
 
 impl Display for GatewayInfo {
@@ -31,9 +30,6 @@ impl Display for GatewayInfo {
         if let Some(endpoint) = &self.endpoint {
             write!(f, " endpoint: {endpoint}")?;
         }
-        if let Some(fallback_endpoint) = &self.fallback_endpoint {
-            write!(f, " fallback: {fallback_endpoint}")?;
-        }
         Ok(())
     }
 }