v0.3.8-pre.010

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

@@ -1,5 +1,5 @@
 // file: crates/ksp-app-store-desk/src/app_state.rs
-// version: 4
+// version: 5
 
 //! Shared backend state owned by the Store Desk Tauri application.
 
@@ -105,7 +105,7 @@ impl crate::AppState {
             application_version: env!("CARGO_PKG_VERSION").to_owned(),
             config_document_count: document_count,
             fallback_logging_active: runtime.fallback_active,
-            shell_phase: "pre.008-raw-accounts".to_owned(),
+            shell_phase: "pre.010-observations-ui".to_owned(),
             startup_diagnostic: runtime.startup_diagnostic.clone(),
         });
     }
@@ -125,6 +125,14 @@ impl crate::AppState {
         return self.store_startup.account_detail(request).await;
     }
 
+    /// Executes one bounded metadata-only observation inspection for one explicit RAW account state.
+    pub(crate) async fn query_account_observations(
+        &self,
+        request: crate::StoreAccountObservationQueryRequestDto,
+    ) -> ksp_core_lib::Result<crate::StoreAccountObservationQueryResponseDto> {
+        return self.store_startup.query_account_observations(request).await;
+    }
+
     /// Executes one bounded RAW transaction inspection query through the retained Store facade.
     pub(crate) async fn query_transactions(
         &self,
@@ -138,6 +146,14 @@ impl crate::AppState {
         return self.store_startup.transaction_detail(request).await;
     }
 
+    /// Executes one bounded metadata-only observation inspection for one explicit RAW transaction.
+    pub(crate) async fn query_transaction_observations(
+        &self,
+        request: crate::StoreTransactionObservationQueryRequestDto,
+    ) -> ksp_core_lib::Result<crate::StoreTransactionObservationQueryResponseDto> {
+        return self.store_startup.query_transaction_observations(request).await;
+    }
+
     /// Returns the resolved splash timings captured during application bootstrap.
     #[must_use]
     pub(crate) const fn splash_settings(&self) -> crate::SplashSettings {

crates/ksp-app-store-desk/src/dto_observation.rs

@@ -0,0 +1,125 @@
+// file: crates/ksp-app-store-desk/src/dto_observation.rs
+// version: 1
+
+//! Application-owned DTOs for safe RAW observation inspection inside entity detail modals.
+
+use ts_rs::TS; // rust-rules: trait-import
+
+/// Safe source-independent acquisition provenance projected for Store Desk observation tables.
+#[derive(Clone, Debug, Eq, PartialEq, serde::Serialize, TS)]
+#[serde(rename_all = "camelCase")]
+#[ts(export, export_to = "../frontend/ts/bindings/ksp_app_store_desk/dto_observation/StoreObservationProvenanceDto.ts")]
+pub(crate) struct StoreObservationProvenanceDto {
+    /// Logical acquisition-method code.
+    pub(crate) acquisition_method: String,
+    /// Optional bounded capture/session identifier.
+    pub(crate) capture_session_id: std::option::Option<String>,
+    /// Optional commitment code captured at acquisition.
+    pub(crate) commitment: std::option::Option<String>,
+    /// Optional Config-owned logical endpoint identifier.
+    pub(crate) endpoint_id: std::option::Option<String>,
+    /// Optional bounded logical filter identifier.
+    pub(crate) filter_id: std::option::Option<String>,
+    /// Optional source-observation timestamp encoded as exact Unix-millisecond decimal text.
+    pub(crate) observed_at_unix_millis_decimal: std::option::Option<String>,
+    /// Stable acquisition-origin code.
+    pub(crate) origin: String,
+    /// Logical transport/protocol code.
+    pub(crate) protocol: String,
+    /// Safe provider code.
+    pub(crate) provider: String,
+    /// Local receipt timestamp encoded as exact Unix-millisecond decimal text.
+    pub(crate) received_at_unix_millis_decimal: String,
+    /// Optional source-wire payload digest encoded as lower-case hexadecimal text, never source bytes.
+    pub(crate) source_payload_hash: std::option::Option<String>,
+    /// Optional source-wire payload size encoded as exact decimal text.
+    pub(crate) source_payload_size_decimal: std::option::Option<String>,
+}
+
+/// DataTables random-access request for observations of one explicit RAW transaction.
+#[derive(Debug, serde::Deserialize, TS)]
+#[serde(rename_all = "camelCase")]
+#[ts(export, export_to = "../frontend/ts/bindings/ksp_app_store_desk/dto_observation/StoreTransactionObservationQueryRequestDto.ts")]
+pub(crate) struct StoreTransactionObservationQueryRequestDto {
+    /// Whitelisted page size (`25`, `50`, or `100`).
+    pub(crate) limit: u32,
+    /// Absolute zero-based observation offset encoded as exact decimal text.
+    pub(crate) offset: String,
+    /// Canonical 64-byte transaction signature encoded as lower-case hexadecimal text.
+    pub(crate) signature: String,
+}
+
+/// Safe metadata-only row for one RAW transaction observation.
+#[derive(Clone, Debug, Eq, PartialEq, serde::Serialize, TS)]
+#[serde(rename_all = "camelCase")]
+#[ts(export, export_to = "../frontend/ts/bindings/ksp_app_store_desk/dto_observation/StoreTransactionObservationRowDto.ts")]
+pub(crate) struct StoreTransactionObservationRowDto {
+    /// Deterministic observation key encoded as lower-case hexadecimal text.
+    pub(crate) observation_key: String,
+    /// Safe source-independent acquisition provenance.
+    pub(crate) provenance: crate::StoreObservationProvenanceDto,
+}
+
+/// Server-side transaction-observation table result using exact decimal counts.
+#[derive(Clone, Debug, Eq, PartialEq, serde::Serialize, TS)]
+#[serde(rename_all = "camelCase")]
+#[ts(export, export_to = "../frontend/ts/bindings/ksp_app_store_desk/dto_observation/StoreTransactionObservationQueryResponseDto.ts")]
+pub(crate) struct StoreTransactionObservationQueryResponseDto {
+    /// Exact count after the mandatory transaction filter.
+    pub(crate) records_filtered_decimal: String,
+    /// Exact count in the mandatory Store network scope before the entity filter.
+    pub(crate) records_total_decimal: String,
+    /// Metadata-only observation rows for the requested random-access page.
+    pub(crate) rows: std::vec::Vec<crate::StoreTransactionObservationRowDto>,
+}
+
+/// DataTables random-access request for observations of one explicit RAW account state.
+#[derive(Debug, serde::Deserialize, TS)]
+#[serde(rename_all = "camelCase")]
+#[ts(export, export_to = "../frontend/ts/bindings/ksp_app_store_desk/dto_observation/StoreAccountObservationQueryRequestDto.ts")]
+pub(crate) struct StoreAccountObservationQueryRequestDto {
+    /// Whitelisted page size (`25`, `50`, or `100`).
+    pub(crate) limit: u32,
+    /// Absolute zero-based observation offset encoded as exact decimal text.
+    pub(crate) offset: String,
+    /// Account public key in canonical base58 text.
+    pub(crate) pubkey: String,
+    /// Solana slot encoded as exact decimal text.
+    pub(crate) slot: String,
+    /// Canonical account-state hash encoded as lower-case hexadecimal text.
+    pub(crate) state_hash: String,
+}
+
+/// Safe metadata-only row for one RAW account observation.
+#[derive(Clone, Debug, Eq, PartialEq, serde::Serialize, TS)]
+#[serde(rename_all = "camelCase")]
+#[ts(export, export_to = "../frontend/ts/bindings/ksp_app_store_desk/dto_observation/StoreAccountObservationRowDto.ts")]
+pub(crate) struct StoreAccountObservationRowDto {
+    /// Optional source-reported startup/replay marker.
+    pub(crate) is_startup: std::option::Option<bool>,
+    /// Deterministic observation key encoded as lower-case hexadecimal text.
+    pub(crate) observation_key: String,
+    /// Safe source-independent acquisition provenance.
+    pub(crate) provenance: crate::StoreObservationProvenanceDto,
+    /// Optional transaction signature associated with the account write, encoded as lower-case hexadecimal text.
+    pub(crate) transaction_signature: std::option::Option<String>,
+    /// Optional source-specific account write version encoded as exact decimal text.
+    pub(crate) write_version_decimal: std::option::Option<String>,
+}
+
+/// Server-side account-observation table result using exact decimal counts.
+#[derive(Clone, Debug, Eq, PartialEq, serde::Serialize, TS)]
+#[serde(rename_all = "camelCase")]
+#[ts(export, export_to = "../frontend/ts/bindings/ksp_app_store_desk/dto_observation/StoreAccountObservationQueryResponseDto.ts")]
+pub(crate) struct StoreAccountObservationQueryResponseDto {
+    /// Exact count after the mandatory account-state filter.
+    pub(crate) records_filtered_decimal: String,
+    /// Exact count in the mandatory Store network scope before the entity filter.
+    pub(crate) records_total_decimal: String,
+    /// Metadata-only observation rows for the requested random-access page.
+    pub(crate) rows: std::vec::Vec<crate::StoreAccountObservationRowDto>,
+}
+
+#[cfg(test)]
+#[path = "../unit_tests/dto_observation.rs"]
+mod tests;

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

@@ -1,5 +1,5 @@
 // file: crates/ksp-app-store-desk/src/lib.rs
-// version: 5
+// version: 6
 
 //! Tauri desktop scaffold for backend-neutral KSP Store inspection.
 
@@ -12,6 +12,7 @@ mod bootstrap;
 mod constants;
 mod dto_account;
 mod dto_common;
+mod dto_observation;
 mod dto_transaction;
 mod errors;
 mod frontend_logging;
@@ -77,6 +78,20 @@ pub(crate) use self::dto_common::CommandErrorDto;
 pub(crate) use self::dto_common::ShellStatusDto;
 /// Backend-neutral Store runtime and health projection exposed to Overview.
 pub(crate) use self::dto_common::StoreRuntimeStatusDto;
+/// DataTables random-access request for observations of one explicit RAW account state.
+pub(crate) use self::dto_observation::StoreAccountObservationQueryRequestDto;
+/// Server-side account-observation table result using exact decimal counts.
+pub(crate) use self::dto_observation::StoreAccountObservationQueryResponseDto;
+/// Safe metadata-only row for one RAW account observation.
+pub(crate) use self::dto_observation::StoreAccountObservationRowDto;
+/// Safe source-independent acquisition provenance projected for observation tables.
+pub(crate) use self::dto_observation::StoreObservationProvenanceDto;
+/// DataTables random-access request for observations of one explicit RAW transaction.
+pub(crate) use self::dto_observation::StoreTransactionObservationQueryRequestDto;
+/// Server-side transaction-observation table result using exact decimal counts.
+pub(crate) use self::dto_observation::StoreTransactionObservationQueryResponseDto;
+/// Safe metadata-only row for one RAW transaction observation.
+pub(crate) use self::dto_observation::StoreTransactionObservationRowDto;
 /// Bounded detail projection for one RAW transaction.
 pub(crate) use self::dto_transaction::StoreTransactionDetailDto;
 /// App-owned identity request for one explicit RAW transaction detail load.

crates/ksp-app-store-desk/src/store_runtime.rs

@@ -1,5 +1,5 @@
 // file: crates/ksp-app-store-desk/src/store_runtime.rs
-// version: 4
+// version: 5
 
 //! Composite-selected Store readiness, status and bounded shutdown lifecycle owned by Store Desk.
 
@@ -53,6 +53,18 @@ impl crate::StoreStartup {
         };
     }
 
+    /// Executes one bounded metadata-only observation inspection for an explicit RAW account state.
+    pub(crate) async fn query_account_observations(
+        &self,
+        request: crate::StoreAccountObservationQueryRequestDto,
+    ) -> ksp_core_lib::Result<crate::StoreAccountObservationQueryResponseDto> {
+        let runtime = self.runtime.as_ref();
+        return match runtime {
+            std::option::Option::Some(value) => value.query_account_observations(request).await,
+            std::option::Option::None => std::result::Result::Err(store_runtime_unavailable()),
+        };
+    }
+
     /// Executes one bounded server-side RAW transaction inspection query.
     pub(crate) async fn query_transactions(
         &self,
@@ -74,6 +86,18 @@ impl crate::StoreStartup {
         };
     }
 
+    /// Executes one bounded metadata-only observation inspection for an explicit RAW transaction.
+    pub(crate) async fn query_transaction_observations(
+        &self,
+        request: crate::StoreTransactionObservationQueryRequestDto,
+    ) -> ksp_core_lib::Result<crate::StoreTransactionObservationQueryResponseDto> {
+        let runtime = self.runtime.as_ref();
+        return match runtime {
+            std::option::Option::Some(value) => value.query_transaction_observations(request).await,
+            std::option::Option::None => std::result::Result::Err(store_runtime_unavailable()),
+        };
+    }
+
     /// Closes the retained Store runtime if startup reached the physical Store-open phase.
     pub(crate) async fn close(&self) -> ksp_core_lib::Result<()> {
         let runtime = self.runtime.as_ref();
@@ -184,6 +208,37 @@ impl crate::StoreRuntime {
         return std::result::Result::Ok(account_detail_dto(&state));
     }
 
+    /// Executes one validated metadata-only observation query for one exact account-state identity.
+    pub(crate) async fn query_account_observations(
+        &self,
+        request: crate::StoreAccountObservationQueryRequestDto,
+    ) -> ksp_core_lib::Result<crate::StoreAccountObservationQueryResponseDto> {
+        let locked = self.store.read().await;
+        let store = locked.as_ref();
+        let store = match store {
+            std::option::Option::Some(value) => value,
+            std::option::Option::None => return std::result::Result::Err(store_runtime_unavailable()),
+        };
+        let query = account_observation_query_from_request(store, &request);
+        let query = match query {
+            std::result::Result::Ok(value) => value,
+            std::result::Result::Err(error) => return std::result::Result::Err(error),
+        };
+        let page = ksp_store_lib::RawAccountObservationInspectionRead::inspect_raw_account_observations(store, &query).await;
+        let page = match page {
+            std::result::Result::Ok(value) => value,
+            std::result::Result::Err(error) => return std::result::Result::Err(error),
+        };
+        let records_total_decimal = page.total_items().to_string();
+        let records_filtered_decimal = page.filtered_items().to_string();
+        let items = page.into_items();
+        let mut rows = std::vec::Vec::with_capacity(items.len());
+        for item in items {
+            rows.push(account_observation_row_dto(&item));
+        }
+        return std::result::Result::Ok(crate::StoreAccountObservationQueryResponseDto { records_filtered_decimal, records_total_decimal, rows });
+    }
+
     /// Executes one validated random-access transaction inspection query while retaining the Store read guard.
     pub(crate) async fn query_transactions(
         &self,
@@ -246,6 +301,37 @@ impl crate::StoreRuntime {
         };
     }
 
+    /// Executes one validated metadata-only observation query for one exact transaction identity.
+    pub(crate) async fn query_transaction_observations(
+        &self,
+        request: crate::StoreTransactionObservationQueryRequestDto,
+    ) -> ksp_core_lib::Result<crate::StoreTransactionObservationQueryResponseDto> {
+        let locked = self.store.read().await;
+        let store = locked.as_ref();
+        let store = match store {
+            std::option::Option::Some(value) => value,
+            std::option::Option::None => return std::result::Result::Err(store_runtime_unavailable()),
+        };
+        let query = transaction_observation_query_from_request(store, &request);
+        let query = match query {
+            std::result::Result::Ok(value) => value,
+            std::result::Result::Err(error) => return std::result::Result::Err(error),
+        };
+        let page = ksp_store_lib::RawTransactionObservationInspectionRead::inspect_raw_transaction_observations(store, &query).await;
+        let page = match page {
+            std::result::Result::Ok(value) => value,
+            std::result::Result::Err(error) => return std::result::Result::Err(error),
+        };
+        let records_total_decimal = page.total_items().to_string();
+        let records_filtered_decimal = page.filtered_items().to_string();
+        let items = page.into_items();
+        let mut rows = std::vec::Vec::with_capacity(items.len());
+        for item in items {
+            rows.push(transaction_observation_row_dto(&item));
+        }
+        return std::result::Result::Ok(crate::StoreTransactionObservationQueryResponseDto { records_filtered_decimal, records_total_decimal, rows });
+    }
+
     /// Explicitly closes the Store exactly once through its backend-neutral facade after all read guards have drained.
     pub(crate) async fn close(&self) -> ksp_core_lib::Result<()> {
         let mut locked = self.store.write().await;
@@ -281,23 +367,88 @@ impl crate::StoreRuntime {
 const ACCOUNT_DETAIL_PREVIEW_BYTES: usize = 512;
 const TRANSACTION_DETAIL_PREVIEW_BYTES: usize = 512;
 
-fn account_query_from_request(
-    store: &ksp_store_lib::Store,
-    request: &crate::StoreAccountQueryRequestDto,
-) -> ksp_core_lib::Result<ksp_store_lib::RawAccountStateInspectionQuery> {
-    let limit = match request.limit {
-        25 | 50 | 100 => ksp_store_lib::RawPageLimit::new(u64::from(request.limit)),
+fn inspection_page_from_request(offset_text: &str, limit_value: u32) -> ksp_core_lib::Result<ksp_store_lib::RawInspectionPageRequest> {
+    let limit = match limit_value {
+        25 | 50 | 100 => ksp_store_lib::RawPageLimit::new(u64::from(limit_value)),
         _ => return std::result::Result::Err(store_query_invalid()),
     };
     let limit = match limit {
         std::result::Result::Ok(value) => value,
         std::result::Result::Err(_) => return std::result::Result::Err(store_query_invalid()),
     };
-    let offset = request.offset.parse::<u64>();
+    let offset = offset_text.parse::<u64>();
     let offset = match offset {
         std::result::Result::Ok(value) => value,
         std::result::Result::Err(_) => return std::result::Result::Err(store_query_invalid()),
     };
+    return std::result::Result::Ok(ksp_store_lib::RawInspectionPageRequest::new(offset, limit));
+}
+
+fn account_observation_query_from_request(
+    store: &ksp_store_lib::Store,
+    request: &crate::StoreAccountObservationQueryRequestDto,
+) -> ksp_core_lib::Result<ksp_store_lib::RawAccountObservationInspectionQuery> {
+    let page = inspection_page_from_request(request.offset.as_str(), request.limit);
+    let page = match page {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(error) => return std::result::Result::Err(error),
+    };
+    let detail_request =
+        crate::StoreAccountDetailRequestDto { pubkey: request.pubkey.clone(), slot: request.slot.clone(), state_hash: request.state_hash.clone() };
+    let reference = account_reference_from_request(store, &detail_request);
+    let reference = match reference {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(error) => return std::result::Result::Err(error),
+    };
+    let network = store.runtime_snapshot().network().clone();
+    let query = ksp_store_lib::RawAccountObservationInspectionQuery::try_new(
+        network,
+        std::option::Option::Some(reference),
+        ksp_store_lib::RawSortDirection::Descending,
+        page,
+    );
+    return match query {
+        std::result::Result::Ok(value) => std::result::Result::Ok(value),
+        std::result::Result::Err(_) => std::result::Result::Err(store_query_invalid()),
+    };
+}
+
+fn transaction_observation_query_from_request(
+    store: &ksp_store_lib::Store,
+    request: &crate::StoreTransactionObservationQueryRequestDto,
+) -> ksp_core_lib::Result<ksp_store_lib::RawTransactionObservationInspectionQuery> {
+    let page = inspection_page_from_request(request.offset.as_str(), request.limit);
+    let page = match page {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(error) => return std::result::Result::Err(error),
+    };
+    let reference = transaction_reference_from_request(store, request.signature.as_str());
+    let reference = match reference {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(error) => return std::result::Result::Err(error),
+    };
+    let network = store.runtime_snapshot().network().clone();
+    let query = ksp_store_lib::RawTransactionObservationInspectionQuery::try_new(
+        network,
+        std::option::Option::Some(reference),
+        ksp_store_lib::RawSortDirection::Descending,
+        page,
+    );
+    return match query {
+        std::result::Result::Ok(value) => std::result::Result::Ok(value),
+        std::result::Result::Err(_) => std::result::Result::Err(store_query_invalid()),
+    };
+}
+
+fn account_query_from_request(
+    store: &ksp_store_lib::Store,
+    request: &crate::StoreAccountQueryRequestDto,
+) -> ksp_core_lib::Result<ksp_store_lib::RawAccountStateInspectionQuery> {
+    let page = inspection_page_from_request(request.offset.as_str(), request.limit);
+    let page = match page {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(error) => return std::result::Result::Err(error),
+    };
     let pubkey = parse_optional_pubkey(request.pubkey.as_deref());
     let pubkey = match pubkey {
         std::result::Result::Ok(value) => value,
@@ -324,7 +475,6 @@ fn account_query_from_request(
         _ => return std::result::Result::Err(store_query_invalid()),
     };
     let network = store.runtime_snapshot().network().clone();
-    let page = ksp_store_lib::RawInspectionPageRequest::new(offset, limit);
     return std::result::Result::Ok(ksp_store_lib::RawAccountStateInspectionQuery::new(network, pubkey, slots, direction, page));
 }
 
@@ -383,22 +533,59 @@ fn account_row_dto(summary: &ksp_store_lib::RawAccountStateSummary) -> crate::St
     };
 }
 
+fn observation_provenance_dto(provenance: &ksp_store_lib::RawAcquisitionProvenance) -> crate::StoreObservationProvenanceDto {
+    return crate::StoreObservationProvenanceDto {
+        acquisition_method: provenance.acquisition_method().as_str().to_owned(),
+        capture_session_id: provenance.capture_session_id().map(|value| return value.as_str().to_owned()),
+        commitment: provenance.commitment().map(|value| return value.as_str().to_owned()),
+        endpoint_id: provenance.endpoint_id().map(|value| return value.as_str().to_owned()),
+        filter_id: provenance.filter_id().map(|value| return value.as_str().to_owned()),
+        observed_at_unix_millis_decimal: provenance.observed_at().map(|value| return value.unix_millis().to_string()),
+        origin: acquisition_origin_code(provenance.origin()).to_owned(),
+        protocol: provenance.protocol().as_str().to_owned(),
+        provider: provenance.provider().as_str().to_owned(),
+        received_at_unix_millis_decimal: provenance.received_at().unix_millis().to_string(),
+        source_payload_hash: provenance.source_payload_hash().map(|value| return encode_hex(value.as_bytes())),
+        source_payload_size_decimal: provenance.source_payload_size_bytes().map(|value| return value.to_string()),
+    };
+}
+
+fn account_observation_row_dto(summary: &ksp_store_lib::RawAccountObservationSummary) -> crate::StoreAccountObservationRowDto {
+    return crate::StoreAccountObservationRowDto {
+        is_startup: summary.is_startup(),
+        observation_key: encode_hex(summary.observation_key().as_bytes()),
+        provenance: observation_provenance_dto(summary.provenance()),
+        transaction_signature: summary.transaction_signature().map(|value| return encode_hex(value.as_bytes())),
+        write_version_decimal: summary.write_version().map(|value| return value.to_string()),
+    };
+}
+
+fn transaction_observation_row_dto(summary: &ksp_store_lib::RawTransactionObservationSummary) -> crate::StoreTransactionObservationRowDto {
+    return crate::StoreTransactionObservationRowDto {
+        observation_key: encode_hex(summary.observation_key().as_bytes()),
+        provenance: observation_provenance_dto(summary.provenance()),
+    };
+}
+
+fn acquisition_origin_code(origin: ksp_store_lib::RawAcquisitionOrigin) -> &'static str {
+    return match origin {
+        ksp_store_lib::RawAcquisitionOrigin::Backfill => "backfill",
+        ksp_store_lib::RawAcquisitionOrigin::Import => "import",
+        ksp_store_lib::RawAcquisitionOrigin::Live => "live",
+        ksp_store_lib::RawAcquisitionOrigin::Repair => "repair",
+        ksp_store_lib::RawAcquisitionOrigin::Replay => "replay",
+        _ => "unknown",
+    };
+}
+
 fn transaction_query_from_request(
     store: &ksp_store_lib::Store,
     request: &crate::StoreTransactionQueryRequestDto,
 ) -> ksp_core_lib::Result<ksp_store_lib::RawTransactionInspectionQuery> {
-    let limit = match request.limit {
-        25 | 50 | 100 => ksp_store_lib::RawPageLimit::new(u64::from(request.limit)),
-        _ => return std::result::Result::Err(store_query_invalid()),
-    };
-    let limit = match limit {
+    let page = inspection_page_from_request(request.offset.as_str(), request.limit);
+    let page = match page {
         std::result::Result::Ok(value) => value,
-        std::result::Result::Err(_) => return std::result::Result::Err(store_query_invalid()),
-    };
-    let offset = request.offset.parse::<u64>();
-    let offset = match offset {
-        std::result::Result::Ok(value) => value,
-        std::result::Result::Err(_) => return std::result::Result::Err(store_query_invalid()),
+        std::result::Result::Err(error) => return std::result::Result::Err(error),
     };
     let slot_min = parse_optional_decimal_u64(request.slot_min.as_deref());
     let slot_min = match slot_min {
@@ -421,7 +608,6 @@ fn transaction_query_from_request(
         _ => return std::result::Result::Err(store_query_invalid()),
     };
     let network = store.runtime_snapshot().network().clone();
-    let page = ksp_store_lib::RawInspectionPageRequest::new(offset, limit);
     return std::result::Result::Ok(ksp_store_lib::RawTransactionInspectionQuery::new(network, slots, direction, page));
 }
 

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

@@ -1,5 +1,5 @@
 // file: crates/ksp-app-store-desk/src/tauri.rs
-// version: 4
+// version: 5
 
 //! Tauri runtime assembly for the KSP Store desktop application.
 
@@ -81,7 +81,9 @@ fn configure_commands(builder: tauri::Builder<tauri::Wry>) -> tauri::Builder<tau
         splash_frontend_ready,
         store_get_account_detail,
         store_get_transaction_detail,
+        store_query_account_observations,
         store_query_accounts,
+        store_query_transaction_observations,
         store_query_transactions,
         store_runtime_status,
     ]);
@@ -176,6 +178,20 @@ fn get_shell_status(state: tauri::State<'_, crate::AppState>) -> std::result::Re
     };
 }
 
+#[tauri::command]
+async fn store_query_account_observations(
+    request: crate::StoreAccountObservationQueryRequestDto,
+    state: tauri::State<'_, crate::AppState>,
+) -> std::result::Result<crate::StoreAccountObservationQueryResponseDto, crate::CommandErrorDto> {
+    let result = state.query_account_observations(request).await;
+    return match result {
+        std::result::Result::Ok(value) => std::result::Result::Ok(value),
+        std::result::Result::Err(error) => {
+            std::result::Result::Err(project_command_error("store_query_account_observations", crate::TRACING_DOMAIN_STORE, &error))
+        },
+    };
+}
+
 #[tauri::command]
 async fn store_query_accounts(
     request: crate::StoreAccountQueryRequestDto,
@@ -200,6 +216,20 @@ async fn store_get_account_detail(
     };
 }
 
+#[tauri::command]
+async fn store_query_transaction_observations(
+    request: crate::StoreTransactionObservationQueryRequestDto,
+    state: tauri::State<'_, crate::AppState>,
+) -> std::result::Result<crate::StoreTransactionObservationQueryResponseDto, crate::CommandErrorDto> {
+    let result = state.query_transaction_observations(request).await;
+    return match result {
+        std::result::Result::Ok(value) => std::result::Result::Ok(value),
+        std::result::Result::Err(error) => {
+            std::result::Result::Err(project_command_error("store_query_transaction_observations", crate::TRACING_DOMAIN_STORE, &error))
+        },
+    };
+}
+
 #[tauri::command]
 async fn store_query_transactions(
     request: crate::StoreTransactionQueryRequestDto,