v0.2.12-pre.004

crates/ksp-app-solprices-desk/src/app_state.rs

@@ -1,5 +1,5 @@
 // file: crates/ksp-app-solprices-desk/src/app_state.rs
-// version: 2
+// version: 3
 
 //! Shared backend state owned by the SOL Prices Desk Tauri application.
 
@@ -7,13 +7,13 @@
 pub(crate) struct AppState {
     config_management: ksp_config_lib::ConfigManagement,
     logging_runtime: std::sync::Mutex<LoggingRuntimeState>,
-    offchain_transport_startup: crate::OffchainTransportStartup,
+    market_price_runtime: crate::MarketPriceRuntime,
     splash_settings: crate::SplashSettings,
     splash_sequence_started: std::sync::atomic::AtomicBool,
 }
 
 impl crate::AppState {
-    /// Initializes Config ownership, composite-managed Logging and the Config-selected Off-chain Transport runtime.
+    /// Initializes Config ownership, composite-managed Logging and the provider-neutral market-price runtime.
     pub(crate) fn initialize(arguments: &[std::ffi::OsString]) -> ksp_core_lib::Result<Self> {
         let config_management = crate::config_management(arguments);
         let config_management = match config_management {
@@ -35,6 +35,11 @@ impl crate::AppState {
             std::result::Result::Ok(value) => value,
             std::result::Result::Err(error) => return std::result::Result::Err(error),
         };
+        let market_price_runtime = crate::MarketPriceRuntime::new(offchain_transport_startup);
+        let market_price_runtime = match market_price_runtime {
+            std::result::Result::Ok(value) => value,
+            std::result::Result::Err(error) => return std::result::Result::Err(error),
+        };
         let splash_settings = crate::SplashSettings::load();
         let splash_settings = match splash_settings {
             std::result::Result::Ok(value) => value,
@@ -52,14 +57,19 @@ impl crate::AppState {
                 fallback_active: logging_startup.fallback_active,
                 startup_diagnostic: logging_startup.startup_diagnostic,
             }),
-            offchain_transport_startup,
+            market_price_runtime,
             splash_settings,
             splash_sequence_started: std::sync::atomic::AtomicBool::new(false),
         });
     }
 
-    /// Builds the safe runtime status exposed before provider rows and refresh commands are introduced.
-    pub(crate) fn runtime_status(&self) -> ksp_core_lib::Result<crate::RuntimeStatusDto> {
+    /// Lists the current provider-neutral market-price rows without triggering network refresh.
+    pub(crate) fn list_market_prices(&self) -> ksp_core_lib::Result<std::vec::Vec<crate::MarketPriceProviderRowDto>> {
+        return self.market_price_runtime.list_rows();
+    }
+
+    /// Builds the safe runtime status exposed by the SOL Prices Desk shell.
+    pub(crate) fn runtime_status(&self) -> ksp_core_lib::Result<crate::MarketPriceRuntimeStatusDto> {
         let document_count = self.config_management.engine().registry().descriptors().count();
         let document_count = u32::try_from(document_count);
         let document_count = match document_count {
@@ -74,6 +84,11 @@ impl crate::AppState {
                 );
             },
         };
+        let provider_counts = self.market_price_runtime.provider_counts();
+        let (provider_count, ready_provider_count, unavailable_provider_count) = match provider_counts {
+            std::result::Result::Ok(value) => value,
+            std::result::Result::Err(error) => return std::result::Result::Err(error),
+        };
         let runtime = self.logging_runtime.lock();
         let runtime = match runtime {
             std::result::Result::Ok(value) => value,
@@ -85,16 +100,20 @@ impl crate::AppState {
             },
         };
         let _keep_guard_alive = &runtime.guard;
-        let offchain = self.offchain_transport_startup.resolved();
-        return std::result::Result::Ok(crate::RuntimeStatusDto {
-            active_composite_profile: self.offchain_transport_startup.composite_profile_id().to_owned(),
+        let startup = self.market_price_runtime.startup();
+        let offchain = startup.resolved();
+        return std::result::Result::Ok(crate::MarketPriceRuntimeStatusDto {
+            active_composite_profile: startup.composite_profile_id().to_owned(),
             active_logging_profile: runtime.active_profile_id.clone(),
             active_offchain_profile: offchain.profile_id().to_owned(),
             application_version: env!("CARGO_PKG_VERSION").to_owned(),
             config_document_count: document_count,
             fallback_logging_active: runtime.fallback_active,
-            shell_phase: "pre.003-offchain-bootstrap".to_owned(),
+            provider_count,
+            ready_provider_count,
+            shell_phase: "pre.004-market-price-runtime".to_owned(),
             startup_diagnostic: runtime.startup_diagnostic.clone(),
+            unavailable_provider_count,
         });
     }
 

crates/ksp-app-solprices-desk/src/dto_common.rs

@@ -1,7 +1,7 @@
 // file: crates/ksp-app-solprices-desk/src/dto_common.rs
-// version: 2
+// version: 3
 
-//! Common Tauri DTOs shared by the SOL Prices Desk bootstrap shell.
+//! Common Tauri DTOs shared by the SOL Prices Desk shell.
 
 use ts_rs::TS; // rust-rules: trait-import
 
@@ -30,11 +30,11 @@ impl crate::CommandErrorDto {
     }
 }
 
-/// Safe Config/bootstrap snapshot exposed before market-price provider rows exist.
+/// Safe provider-neutral application/runtime snapshot exposed to the SOL Prices Desk shell.
 #[derive(Clone, Debug, serde::Serialize, TS)]
 #[serde(rename_all = "camelCase")]
-#[ts(export, export_to = "../frontend/ts/bindings/ksp_app_solprices_desk/dto_common/RuntimeStatusDto.ts")]
-pub(crate) struct RuntimeStatusDto {
+#[ts(export, export_to = "../frontend/ts/bindings/ksp_app_solprices_desk/dto_common/MarketPriceRuntimeStatusDto.ts")]
+pub(crate) struct MarketPriceRuntimeStatusDto {
     /// SOL Prices Desk composite profile selected for this launch.
     pub(crate) active_composite_profile: String,
     /// Active configured Logging profile, or `None` while transient fallback Logging is active.
@@ -47,10 +47,16 @@ pub(crate) struct RuntimeStatusDto {
     pub(crate) config_document_count: u32,
     /// Whether SOL Prices Desk had to install its transient in-memory Logging fallback.
     pub(crate) fallback_logging_active: bool,
-    /// Current implementation phase exposed by the bootstrap shell.
+    /// Total number of configured provider-neutral market-price rows.
+    pub(crate) provider_count: u32,
+    /// Number of providers currently classified as immediately ready.
+    pub(crate) ready_provider_count: u32,
+    /// Current implementation phase exposed by the shell.
     pub(crate) shell_phase: String,
     /// Safe startup diagnostic that caused fallback Logging, when applicable.
     pub(crate) startup_diagnostic: std::option::Option<CommandErrorDto>,
+    /// Number of providers currently not classified as immediately ready.
+    pub(crate) unavailable_provider_count: u32,
 }
 
 #[cfg(test)]

crates/ksp-app-solprices-desk/src/lib.rs

@@ -1,5 +1,5 @@
 // file: crates/ksp-app-solprices-desk/src/lib.rs
-// version: 2
+// version: 3
 
 //! Tauri desktop application scaffold for provider-neutral SOL/USD price visualization.
 
@@ -14,6 +14,7 @@ mod dto_common;
 mod errors;
 mod frontend_logging;
 mod logging_runtime;
+mod market_price_runtime;
 mod offchain_runtime;
 mod splash;
 mod tauri;
@@ -59,8 +60,8 @@ pub(crate) use self::constants::TRACING_TARGET_FRONTEND_MAIN;
 pub(crate) use self::constants::TRACING_TARGET_FRONTEND_SPLASH;
 /// Safe command error projection exposed to Tauri commands.
 pub(crate) use self::dto_common::CommandErrorDto;
-/// Safe scaffold runtime snapshot exposed to the shell.
-pub(crate) use self::dto_common::RuntimeStatusDto;
+/// Safe provider-neutral runtime snapshot exposed to the shell.
+pub(crate) use self::dto_common::MarketPriceRuntimeStatusDto;
 /// Shared SOL Prices Desk application state is internally inconsistent.
 pub(crate) use self::errors::ERROR_CODE_APP_STATE_INVALID;
 /// Shared SOL Prices Desk runtime state cannot be locked safely.
@@ -89,6 +90,10 @@ pub(crate) use self::frontend_logging::FrontendLogPayloadDto;
 pub(crate) use self::frontend_logging::emit_frontend_log_event;
 /// Creates the stable runtime identity for this SOL Prices Desk process launch.
 pub(crate) use self::logging_runtime::launch_identity;
+/// Safe provider-neutral market-price row exposed to the frontend.
+pub(crate) use self::market_price_runtime::MarketPriceProviderRowDto;
+/// Backend application runtime owning the Config-selected service and in-memory market-price presentation state.
+pub(crate) use self::market_price_runtime::MarketPriceRuntime;
 /// Resolved composite and Off-chain Transport configuration retained by SOL Prices Desk.
 pub(crate) use self::offchain_runtime::OffchainTransportStartup;
 /// Resolves the composite-selected Off-chain Transport profile and constructs the Config-owned service.

crates/ksp-app-solprices-desk/src/market_price_runtime.rs

@@ -0,0 +1,209 @@
+// file: crates/ksp-app-solprices-desk/src/market_price_runtime.rs
+// version: 1
+
+//! Provider-neutral market-price presentation runtime owned by SOL Prices Desk.
+
+use ts_rs::TS; // rust-rules: trait-import
+
+/// Safe provider-neutral row projected to the SOL Prices Desk frontend.
+#[derive(Clone, Debug, Eq, PartialEq, serde::Serialize, TS)]
+#[serde(rename_all = "camelCase")]
+#[ts(export, export_to = "../frontend/ts/bindings/ksp_app_solprices_desk/market_price_runtime/MarketPriceProviderRowDto.ts")]
+pub(crate) struct MarketPriceProviderRowDto {
+    /// Generic authentication capability code for the configured provider mode.
+    pub(crate) auth_mode: String,
+    /// Generic current availability code.
+    pub(crate) availability: String,
+    /// Safe provider display name supplied by Off-chain Transport.
+    pub(crate) display_name: String,
+    /// Whether one refresh is currently in flight for this provider.
+    pub(crate) loading: bool,
+    /// Stable V1 pair label.
+    pub(crate) pair: String,
+    /// Exact canonical SOL/USD decimal string, when an observation exists.
+    pub(crate) price: std::option::Option<String>,
+    /// Opaque provider identifier accepted by future refresh commands.
+    pub(crate) provider_id: String,
+    /// Provider-supplied observation timestamp in exact Unix milliseconds, when genuinely supplied.
+    pub(crate) provider_timestamp_unix_millis: std::option::Option<String>,
+    /// KSP receipt timestamp in exact Unix milliseconds, when an observation exists.
+    pub(crate) received_at_unix_millis: std::option::Option<String>,
+    /// Whether this row currently retains at least one successful observation.
+    pub(crate) refreshed: bool,
+    /// Known next retry timestamp in exact Unix milliseconds for cooldown/temporary states.
+    pub(crate) retry_at_unix_millis: std::option::Option<String>,
+    /// Generic price-semantics code retained from the provider descriptor.
+    pub(crate) semantics: String,
+}
+
+/// Backend application runtime that owns the Config-selected Off-chain service and current in-memory presentation state.
+pub(crate) struct MarketPriceRuntime {
+    presentation: std::sync::Mutex<MarketPricePresentationState>,
+    startup: crate::OffchainTransportStartup,
+}
+
+impl crate::MarketPriceRuntime {
+    /// Builds the application presentation runtime from the already Config-resolved Off-chain startup.
+    pub(crate) fn new(startup: crate::OffchainTransportStartup) -> ksp_core_lib::Result<Self> {
+        let registry = startup.resolved().service().registry();
+        let mut entries = std::collections::BTreeMap::new();
+        for entry in registry.entries() {
+            let previous = entries
+                .insert(entry.descriptor().id().as_str().to_owned(), MarketPricePresentationEntry { loading: false, observation: std::option::Option::None });
+            if previous.is_some() {
+                return std::result::Result::Err(
+                    ksp_core_lib::Error::new(crate::ERROR_CODE_APP_STATE_INVALID, "SOL Prices Desk market-price runtime contains duplicate provider state")
+                        .with_context("provider_id", entry.descriptor().id().as_str()),
+                );
+            }
+        }
+        ksp_logging_lib::debug!(
+            target: crate::TRACING_TARGET,
+            domain = crate::TRACING_DOMAIN_OFFCHAIN_TRANSPORT,
+            provider_count = entries.len(),
+            "initialized SOL Prices Desk market-price presentation runtime"
+        );
+        return std::result::Result::Ok(Self { presentation: std::sync::Mutex::new(MarketPricePresentationState { entries }), startup });
+    }
+
+    /// Returns the Config/bootstrap metadata retained by the price runtime.
+    #[must_use]
+    pub(crate) const fn startup(&self) -> &crate::OffchainTransportStartup {
+        return &self.startup;
+    }
+
+    /// Returns total, ready and unavailable provider counts from the detached generic registry snapshot.
+    pub(crate) fn provider_counts(&self) -> ksp_core_lib::Result<(u32, u32, u32)> {
+        let registry = self.startup.resolved().service().registry();
+        let total = count_to_u32(registry.len(), "provider_count");
+        let total = match total {
+            std::result::Result::Ok(value) => value,
+            std::result::Result::Err(error) => return std::result::Result::Err(error),
+        };
+        let mut ready_count = 0usize;
+        for entry in registry.entries() {
+            if matches!(entry.state().availability(), ksp_offchain_transport_lib::MarketPriceProviderAvailability::Ready) {
+                ready_count += 1;
+            }
+        }
+        let ready = count_to_u32(ready_count, "ready_provider_count");
+        let ready = match ready {
+            std::result::Result::Ok(value) => value,
+            std::result::Result::Err(error) => return std::result::Result::Err(error),
+        };
+        let unavailable = total.saturating_sub(ready);
+        return std::result::Result::Ok((total, ready, unavailable));
+    }
+
+    /// Projects the current registry and in-memory observation state as deterministic frontend rows without network dispatch.
+    pub(crate) fn list_rows(&self) -> ksp_core_lib::Result<std::vec::Vec<crate::MarketPriceProviderRowDto>> {
+        let registry = self.startup.resolved().service().registry();
+        let presentation = self.presentation.lock();
+        let presentation = match presentation {
+            std::result::Result::Ok(value) => value,
+            std::result::Result::Err(_) => {
+                return std::result::Result::Err(ksp_core_lib::Error::new(
+                    crate::ERROR_CODE_APP_STATE_LOCK_FAILED,
+                    "SOL Prices Desk market-price presentation state lock is poisoned",
+                ));
+            },
+        };
+        let mut rows = std::vec::Vec::with_capacity(registry.len());
+        for entry in registry.entries() {
+            let provider_id = entry.descriptor().id().as_str();
+            let presentation_entry = presentation.entries.get(provider_id);
+            let presentation_entry = match presentation_entry {
+                std::option::Option::Some(value) => value,
+                std::option::Option::None => {
+                    return std::result::Result::Err(
+                        ksp_core_lib::Error::new(crate::ERROR_CODE_APP_STATE_INVALID, "SOL Prices Desk market-price runtime is missing one registry row")
+                            .with_context("provider_id", provider_id),
+                    );
+                },
+            };
+            rows.push(project_registry_entry(entry, presentation_entry));
+        }
+        return std::result::Result::Ok(rows);
+    }
+}
+
+struct MarketPricePresentationEntry {
+    loading: bool,
+    observation: std::option::Option<ksp_offchain_transport_lib::MarketPriceObservation>,
+}
+
+struct MarketPricePresentationState {
+    entries: std::collections::BTreeMap<String, MarketPricePresentationEntry>,
+}
+
+fn auth_mode_code(auth_mode: ksp_offchain_transport_lib::MarketPriceProviderAuthMode) -> &'static str {
+    return match auth_mode {
+        ksp_offchain_transport_lib::MarketPriceProviderAuthMode::None => "none",
+        ksp_offchain_transport_lib::MarketPriceProviderAuthMode::OptionalApiKey => "optional_api_key",
+        ksp_offchain_transport_lib::MarketPriceProviderAuthMode::RequiredApiKey => "required_api_key",
+        _ => "unknown",
+    };
+}
+
+fn availability_code(availability: ksp_offchain_transport_lib::MarketPriceProviderAvailability) -> &'static str {
+    return match availability {
+        ksp_offchain_transport_lib::MarketPriceProviderAvailability::AuthenticationUnavailable => "authentication_unavailable",
+        ksp_offchain_transport_lib::MarketPriceProviderAvailability::CoolingDown { .. } => "cooling_down",
+        ksp_offchain_transport_lib::MarketPriceProviderAvailability::Disabled => "disabled",
+        ksp_offchain_transport_lib::MarketPriceProviderAvailability::Misconfigured => "misconfigured",
+        ksp_offchain_transport_lib::MarketPriceProviderAvailability::QuotaUnavailable => "quota_unavailable",
+        ksp_offchain_transport_lib::MarketPriceProviderAvailability::Ready => "ready",
+        ksp_offchain_transport_lib::MarketPriceProviderAvailability::TemporarilyUnavailable { .. } => "temporarily_unavailable",
+        _ => "unknown",
+    };
+}
+
+fn count_to_u32(value: usize, field: &'static str) -> ksp_core_lib::Result<u32> {
+    let converted = u32::try_from(value);
+    return match converted {
+        std::result::Result::Ok(value) => std::result::Result::Ok(value),
+        std::result::Result::Err(error) => std::result::Result::Err(
+            ksp_core_lib::Error::new(crate::ERROR_CODE_APP_STATE_INVALID, "SOL Prices Desk market-price runtime count exceeds DTO bounds")
+                .with_context("field", field)
+                .with_source(error),
+        ),
+    };
+}
+
+fn project_registry_entry(
+    entry: &ksp_offchain_transport_lib::MarketPriceProviderRegistryEntry,
+    presentation: &MarketPricePresentationEntry,
+) -> crate::MarketPriceProviderRowDto {
+    let descriptor = entry.descriptor();
+    let availability = entry.state().availability();
+    let observation = presentation.observation.as_ref();
+    return crate::MarketPriceProviderRowDto {
+        auth_mode: auth_mode_code(descriptor.auth_mode()).to_owned(),
+        availability: availability_code(availability).to_owned(),
+        display_name: descriptor.display_name().to_owned(),
+        loading: presentation.loading,
+        pair: ksp_offchain_transport_lib::MarketPricePair::SolUsd.code().to_owned(),
+        price: observation.map(|value| return value.price().to_canonical_string()),
+        provider_id: descriptor.id().as_str().to_owned(),
+        provider_timestamp_unix_millis: observation.and_then(|value| return value.provider_timestamp()).map(|value| return value.unix_millis().to_string()),
+        received_at_unix_millis: observation.map(|value| return value.received_at().unix_millis().to_string()),
+        refreshed: observation.is_some(),
+        retry_at_unix_millis: availability.retry_at().map(|value| return value.unix_millis().to_string()),
+        semantics: semantics_code(descriptor.semantics()).to_owned(),
+    };
+}
+
+fn semantics_code(semantics: ksp_offchain_transport_lib::MarketPriceSemantics) -> &'static str {
+    return match semantics {
+        ksp_offchain_transport_lib::MarketPriceSemantics::AggregatedMarket => "aggregated_market",
+        ksp_offchain_transport_lib::MarketPriceSemantics::DexPairUsd => "dex_pair_usd",
+        ksp_offchain_transport_lib::MarketPriceSemantics::ExchangeLastTrade => "exchange_last_trade",
+        ksp_offchain_transport_lib::MarketPriceSemantics::SolanaHeuristic => "solana_heuristic",
+        ksp_offchain_transport_lib::MarketPriceSemantics::SolanaSpot => "solana_spot",
+        _ => "unknown",
+    };
+}
+
+#[cfg(test)]
+#[path = "../unit_tests/market_price_runtime.rs"]
+mod tests;

crates/ksp-app-solprices-desk/src/tauri.rs

@@ -72,7 +72,7 @@ fn configure_plugins(builder: tauri::Builder<tauri::Wry>) -> tauri::Builder<taur
 
 #[allow(clippy::question_mark_used)] // Tauri generates the question-mark operator internally for async command dispatch.
 fn configure_commands(builder: tauri::Builder<tauri::Wry>) -> tauri::Builder<tauri::Wry> {
-    return builder.invoke_handler(tauri::generate_handler![emit_frontend_log, get_runtime_status, splash_frontend_ready,]);
+    return builder.invoke_handler(tauri::generate_handler![emit_frontend_log, get_runtime_status, list_market_prices, splash_frontend_ready,]);
 }
 
 fn configure_setup(builder: tauri::Builder<tauri::Wry>) -> tauri::Builder<tauri::Wry> {
@@ -91,7 +91,16 @@ fn configure_setup(builder: tauri::Builder<tauri::Wry>) -> tauri::Builder<tauri:
 }
 
 #[tauri::command]
-fn get_runtime_status(state: tauri::State<'_, crate::AppState>) -> std::result::Result<crate::RuntimeStatusDto, crate::CommandErrorDto> {
+fn emit_frontend_log(payload: crate::FrontendLogPayloadDto) -> std::result::Result<(), crate::CommandErrorDto> {
+    let result = crate::emit_frontend_log_event(payload);
+    return match result {
+        std::result::Result::Ok(()) => std::result::Result::Ok(()),
+        std::result::Result::Err(error) => std::result::Result::Err(crate::CommandErrorDto::from_error(&error)),
+    };
+}
+
+#[tauri::command]
+fn get_runtime_status(state: tauri::State<'_, crate::AppState>) -> std::result::Result<crate::MarketPriceRuntimeStatusDto, crate::CommandErrorDto> {
     let result = state.runtime_status();
     return match result {
         std::result::Result::Ok(value) => std::result::Result::Ok(value),
@@ -100,10 +109,15 @@ fn get_runtime_status(state: tauri::State<'_, crate::AppState>) -> std::result::
 }
 
 #[tauri::command]
-fn emit_frontend_log(payload: crate::FrontendLogPayloadDto) -> std::result::Result<(), crate::CommandErrorDto> {
-    let result = crate::emit_frontend_log_event(payload);
+fn list_market_prices(
+    state: tauri::State<'_, crate::AppState>,
+) -> std::result::Result<std::vec::Vec<crate::MarketPriceProviderRowDto>, crate::CommandErrorDto> {
+    let result = state.list_market_prices();
     return match result {
-        std::result::Result::Ok(()) => std::result::Result::Ok(()),
+        std::result::Result::Ok(value) => {
+            ksp_logging_lib::trace!(target: crate::TRACING_TARGET, domain = crate::TRACING_DOMAIN_OFFCHAIN_TRANSPORT, row_count = value.len(), "projected SOL Prices Desk market-price registry rows");
+            std::result::Result::Ok(value)
+        },
         std::result::Result::Err(error) => std::result::Result::Err(crate::CommandErrorDto::from_error(&error)),
     };
 }