v0.3.8-pre.009

crates/ksp-store-api/src/capability/raw_account.rs

@@ -1,5 +1,5 @@
 // file: crates/ksp-store-api/src/capability/raw_account.rs
-// version: 3
+// version: 4
 
 /// Read capability for complete canonical RAW account states.
 ///
@@ -62,6 +62,15 @@ pub trait RawAccountObservationRead: std::marker::Send + std::marker::Sync {
     ) -> crate::StoreApiFuture<'a, crate::Result<std::option::Option<crate::RawAccountObservation>>>;
 }
 
+/// Read capability for random-access RAW account-observation inspection.
+pub trait RawAccountObservationInspectionRead: std::marker::Send + std::marker::Sync {
+    /// Inspects one account-observation window with exact logical counts.
+    fn inspect_raw_account_observations<'a>(
+        &'a self,
+        query: &'a crate::RawAccountObservationInspectionQuery,
+    ) -> crate::StoreApiFuture<'a, crate::Result<crate::RawInspectionPage<crate::RawAccountObservationSummary>>>;
+}
+
 /// Write capability for an additional observation of an already persisted RAW account state.
 ///
 /// This capability allows repeated HTTP/WS/gRPC acquisitions to be retained

crates/ksp-store-api/src/capability/raw_transaction.rs

@@ -1,5 +1,5 @@
 // file: crates/ksp-store-api/src/capability/raw_transaction.rs
-// version: 3
+// version: 4
 
 /// Read capability for canonical RAW transactions.
 ///
@@ -63,6 +63,15 @@ pub trait RawTransactionObservationRead: std::marker::Send + std::marker::Sync {
     ) -> crate::StoreApiFuture<'a, crate::Result<std::option::Option<crate::RawTransactionObservation>>>;
 }
 
+/// Read capability for random-access RAW transaction-observation inspection.
+pub trait RawTransactionObservationInspectionRead: std::marker::Send + std::marker::Sync {
+    /// Inspects one transaction-observation window with exact logical counts.
+    fn inspect_raw_transaction_observations<'a>(
+        &'a self,
+        query: &'a crate::RawTransactionObservationInspectionQuery,
+    ) -> crate::StoreApiFuture<'a, crate::Result<crate::RawInspectionPage<crate::RawTransactionObservationSummary>>>;
+}
+
 /// Write capability for an additional observation of an already persisted RAW transaction.
 ///
 /// This capability exists so repeated acquisitions can be recorded without

crates/ksp-store-api/src/lib.rs

@@ -1,5 +1,5 @@
 // file: crates/ksp-store-api/src/lib.rs
-// version: 6
+// version: 7
 
 #![warn(missing_docs)]
 #![deny(unreachable_pub)]
@@ -22,6 +22,8 @@ mod model;
 
 /// Boxed async operation returned by object-safe Store capability contracts.
 pub use self::capability::StoreApiFuture;
+/// Read capability for random-access RAW account-observation inspection.
+pub use self::capability::raw_account::RawAccountObservationInspectionRead;
 /// Read capability for persisted RAW account-state observations.
 pub use self::capability::raw_account::RawAccountObservationRead;
 /// Write capability for additional observations of already persisted RAW account states.
@@ -38,6 +40,8 @@ pub use self::capability::raw_retention::RawTransactionRetentionRead;
 pub use self::capability::raw_retention::RawTransactionRetentionWrite;
 /// Read capability for payload-free random-access RAW transaction inspection.
 pub use self::capability::raw_transaction::RawTransactionInspectionRead;
+/// Read capability for random-access RAW transaction-observation inspection.
+pub use self::capability::raw_transaction::RawTransactionObservationInspectionRead;
 /// Read capability for persisted RAW transaction observations.
 pub use self::capability::raw_transaction::RawTransactionObservationRead;
 /// Write capability for additional observations of already persisted RAW transactions.
@@ -64,6 +68,10 @@ pub use self::model::raw_account::RawAccountObservation;
 pub use self::model::raw_account::RawAccountState;
 /// Durable backend-independent identity of one canonical RAW account state.
 pub use self::model::raw_account::RawAccountStateReference;
+/// Backend-independent random-access inspection query for RAW account observations.
+pub use self::model::raw_inspection::RawAccountObservationInspectionQuery;
+/// Safe observation summary for one canonical RAW account-state acquisition.
+pub use self::model::raw_inspection::RawAccountObservationSummary;
 /// Backend-independent random-access inspection query for RAW account states.
 pub use self::model::raw_inspection::RawAccountStateInspectionQuery;
 /// Data-free summary of one canonical RAW account state for operator inspection.
@@ -74,6 +82,10 @@ pub use self::model::raw_inspection::RawInspectionPage;
 pub use self::model::raw_inspection::RawInspectionPageRequest;
 /// Backend-independent random-access inspection query for RAW transactions.
 pub use self::model::raw_inspection::RawTransactionInspectionQuery;
+/// Backend-independent random-access inspection query for RAW transaction observations.
+pub use self::model::raw_inspection::RawTransactionObservationInspectionQuery;
+/// Safe observation summary for one canonical RAW transaction acquisition.
+pub use self::model::raw_inspection::RawTransactionObservationSummary;
 /// Payload-free summary of one canonical RAW transaction for operator inspection.
 pub use self::model::raw_inspection::RawTransactionSummary;
 /// Combined outcome of one atomic canonical RAW entity plus observation acquisition.

crates/ksp-store-api/src/model/raw_inspection.rs

@@ -1,5 +1,5 @@
 // file: crates/ksp-store-api/src/model/raw_inspection.rs
-// version: 1
+// version: 2
 
 /// Random-access page request dedicated to bounded interactive RAW inspection.
 ///
@@ -87,6 +87,202 @@ impl<T> RawInspectionPage<T> {
     }
 }
 
+/// Backend-independent random-access inspection query for RAW transaction observations.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct RawTransactionObservationInspectionQuery {
+    direction: crate::RawSortDirection,
+    network: crate::RawNetworkId,
+    page: crate::RawInspectionPageRequest,
+    transaction: std::option::Option<crate::RawTransactionReference>,
+}
+
+impl RawTransactionObservationInspectionQuery {
+    /// Creates one transaction-observation inspection query after enforcing network coherence.
+    pub fn try_new(
+        network: crate::RawNetworkId,
+        transaction: std::option::Option<crate::RawTransactionReference>,
+        direction: crate::RawSortDirection,
+        page: crate::RawInspectionPageRequest,
+    ) -> crate::Result<Self> {
+        if let std::option::Option::Some(reference) = transaction.as_ref() {
+            if reference.network() != &network {
+                return std::result::Result::Err(raw_model_error("transaction"));
+            }
+        }
+        return std::result::Result::Ok(Self { direction, network, page, transaction });
+    }
+
+    /// Returns the requested deterministic traversal direction.
+    #[must_use]
+    pub const fn direction(&self) -> crate::RawSortDirection {
+        return self.direction;
+    }
+
+    /// Returns the mandatory logical network scope.
+    #[must_use]
+    pub fn network(&self) -> &crate::RawNetworkId {
+        return &self.network;
+    }
+
+    /// Returns the random-access inspection page request.
+    #[must_use]
+    pub const fn page(&self) -> crate::RawInspectionPageRequest {
+        return self.page;
+    }
+
+    /// Returns the optional exact transaction identity used to filter observations.
+    #[must_use]
+    pub fn transaction(&self) -> std::option::Option<&crate::RawTransactionReference> {
+        return self.transaction.as_ref();
+    }
+}
+
+/// Backend-independent random-access inspection query for RAW account observations.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct RawAccountObservationInspectionQuery {
+    account: std::option::Option<crate::RawAccountStateReference>,
+    direction: crate::RawSortDirection,
+    network: crate::RawNetworkId,
+    page: crate::RawInspectionPageRequest,
+}
+
+impl RawAccountObservationInspectionQuery {
+    /// Creates one account-observation inspection query after enforcing network coherence.
+    pub fn try_new(
+        network: crate::RawNetworkId,
+        account: std::option::Option<crate::RawAccountStateReference>,
+        direction: crate::RawSortDirection,
+        page: crate::RawInspectionPageRequest,
+    ) -> crate::Result<Self> {
+        if let std::option::Option::Some(reference) = account.as_ref() {
+            if reference.network() != &network {
+                return std::result::Result::Err(raw_model_error("account"));
+            }
+        }
+        return std::result::Result::Ok(Self { account, direction, network, page });
+    }
+
+    /// Returns the optional exact account-state identity used to filter observations.
+    #[must_use]
+    pub fn account(&self) -> std::option::Option<&crate::RawAccountStateReference> {
+        return self.account.as_ref();
+    }
+
+    /// Returns the requested deterministic traversal direction.
+    #[must_use]
+    pub const fn direction(&self) -> crate::RawSortDirection {
+        return self.direction;
+    }
+
+    /// Returns the mandatory logical network scope.
+    #[must_use]
+    pub fn network(&self) -> &crate::RawNetworkId {
+        return &self.network;
+    }
+
+    /// Returns the random-access inspection page request.
+    #[must_use]
+    pub const fn page(&self) -> crate::RawInspectionPageRequest {
+        return self.page;
+    }
+}
+
+/// Safe observation summary for one canonical RAW transaction acquisition.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct RawTransactionObservationSummary {
+    observation_key: crate::RawObservationKey,
+    provenance: crate::RawAcquisitionProvenance,
+    transaction: crate::RawTransactionReference,
+}
+
+impl RawTransactionObservationSummary {
+    /// Creates one safe transaction-observation summary without RAW payload bytes.
+    #[must_use]
+    pub fn new(observation_key: crate::RawObservationKey, transaction: crate::RawTransactionReference, provenance: crate::RawAcquisitionProvenance) -> Self {
+        return Self { observation_key, provenance, transaction };
+    }
+
+    /// Returns the producer-owned deterministic observation key.
+    #[must_use]
+    pub const fn observation_key(&self) -> crate::RawObservationKey {
+        return self.observation_key;
+    }
+
+    /// Returns safe source-independent acquisition provenance.
+    #[must_use]
+    pub fn provenance(&self) -> &crate::RawAcquisitionProvenance {
+        return &self.provenance;
+    }
+
+    /// Returns the durable transaction identity observed by this acquisition.
+    #[must_use]
+    pub fn transaction(&self) -> &crate::RawTransactionReference {
+        return &self.transaction;
+    }
+}
+
+/// Safe observation summary for one canonical RAW account-state acquisition.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct RawAccountObservationSummary {
+    account: crate::RawAccountStateReference,
+    is_startup: std::option::Option<bool>,
+    observation_key: crate::RawObservationKey,
+    provenance: crate::RawAcquisitionProvenance,
+    transaction_signature: std::option::Option<crate::RawTransactionSignature>,
+    write_version: std::option::Option<u64>,
+}
+
+impl RawAccountObservationSummary {
+    /// Creates one safe account-observation summary without account data bytes.
+    #[must_use]
+    pub fn new(
+        observation_key: crate::RawObservationKey,
+        account: crate::RawAccountStateReference,
+        provenance: crate::RawAcquisitionProvenance,
+        is_startup: std::option::Option<bool>,
+        transaction_signature: std::option::Option<crate::RawTransactionSignature>,
+        write_version: std::option::Option<u64>,
+    ) -> Self {
+        return Self { account, is_startup, observation_key, provenance, transaction_signature, write_version };
+    }
+
+    /// Returns the durable account-state identity observed by this acquisition.
+    #[must_use]
+    pub fn account(&self) -> &crate::RawAccountStateReference {
+        return &self.account;
+    }
+
+    /// Returns the optional source-reported startup/replay marker.
+    #[must_use]
+    pub const fn is_startup(&self) -> std::option::Option<bool> {
+        return self.is_startup;
+    }
+
+    /// Returns the producer-owned deterministic observation key.
+    #[must_use]
+    pub const fn observation_key(&self) -> crate::RawObservationKey {
+        return self.observation_key;
+    }
+
+    /// Returns safe source-independent acquisition provenance.
+    #[must_use]
+    pub fn provenance(&self) -> &crate::RawAcquisitionProvenance {
+        return &self.provenance;
+    }
+
+    /// Returns the optional transaction signature associated with the observed account write.
+    #[must_use]
+    pub const fn transaction_signature(&self) -> std::option::Option<crate::RawTransactionSignature> {
+        return self.transaction_signature;
+    }
+
+    /// Returns the optional source-specific account write version.
+    #[must_use]
+    pub const fn write_version(&self) -> std::option::Option<u64> {
+        return self.write_version;
+    }
+}
+
 /// Backend-independent random-access inspection query for RAW transactions.
 #[derive(Clone, Debug, Eq, PartialEq)]
 pub struct RawTransactionInspectionQuery {

crates/ksp-store-api/tests/dependency_boundary.rs

@@ -1,5 +1,5 @@
 // file: crates/ksp-store-api/tests/dependency_boundary.rs
-// version: 6
+// version: 7
 
 //! Dependency canaries for the Store API RAW foundation.
 
@@ -113,6 +113,7 @@ fn pre_006_source_boundary_keeps_models_and_capabilities_backend_free() {
     }
     assert!(raw_transaction_capability.contains("trait RawTransactionRead"));
     assert!(raw_transaction_capability.contains("trait RawTransactionInspectionRead"));
+    assert!(raw_transaction_capability.contains("trait RawTransactionObservationInspectionRead"));
     assert!(raw_transaction_capability.contains("trait RawTransactionWrite"));
     assert!(raw_transaction_capability.contains("trait RawTransactionObservationRead"));
     assert!(raw_transaction_capability.contains("trait RawTransactionObservationWrite"));
@@ -120,6 +121,7 @@ fn pre_006_source_boundary_keeps_models_and_capabilities_backend_free() {
     assert!(raw_retention_capability.contains("trait RawTransactionRetentionWrite"));
     assert!(raw_account_capability.contains("trait RawAccountStateRead"));
     assert!(raw_account_capability.contains("trait RawAccountStateInspectionRead"));
+    assert!(raw_account_capability.contains("trait RawAccountObservationInspectionRead"));
     assert!(raw_account_capability.contains("trait RawAccountStateWrite"));
     assert!(raw_account_capability.contains("trait RawAccountObservationRead"));
     assert!(raw_account_capability.contains("trait RawAccountObservationWrite"));

crates/ksp-store-api/tests/external_backend.rs

@@ -1,5 +1,5 @@
 // file: crates/ksp-store-api/tests/external_backend.rs
-// version: 3
+// version: 4
 
 //! External-implementation canary for object-safe Store API capabilities.
 
@@ -58,6 +58,18 @@ impl ksp_store_api::RawTransactionWrite for ExternalMemoryBackend {
     }
 }
 
+impl ksp_store_api::RawTransactionObservationInspectionRead for ExternalMemoryBackend {
+    fn inspect_raw_transaction_observations<'a>(
+        &'a self,
+        query: &'a ksp_store_api::RawTransactionObservationInspectionQuery,
+    ) -> ksp_store_api::StoreApiFuture<'a, ksp_store_api::Result<ksp_store_api::RawInspectionPage<ksp_store_api::RawTransactionObservationSummary>>> {
+        let _ = query;
+        return std::boxed::Box::pin(async {
+            return ksp_store_api::RawInspectionPage::try_new(std::vec::Vec::new(), 0, 0);
+        });
+    }
+}
+
 impl ksp_store_api::RawTransactionObservationRead for ExternalMemoryBackend {
     fn get_raw_transaction_observation<'a>(
         &'a self,
@@ -133,6 +145,18 @@ impl ksp_store_api::RawAccountStateWrite for ExternalMemoryBackend {
     }
 }
 
+impl ksp_store_api::RawAccountObservationInspectionRead for ExternalMemoryBackend {
+    fn inspect_raw_account_observations<'a>(
+        &'a self,
+        query: &'a ksp_store_api::RawAccountObservationInspectionQuery,
+    ) -> ksp_store_api::StoreApiFuture<'a, ksp_store_api::Result<ksp_store_api::RawInspectionPage<ksp_store_api::RawAccountObservationSummary>>> {
+        let _ = query;
+        return std::boxed::Box::pin(async {
+            return ksp_store_api::RawInspectionPage::try_new(std::vec::Vec::new(), 0, 0);
+        });
+    }
+}
+
 impl ksp_store_api::RawAccountObservationRead for ExternalMemoryBackend {
     fn get_raw_account_observation<'a>(
         &'a self,
@@ -197,11 +221,13 @@ fn v0_3_8_pre_003_external_backend_implements_canonical_and_inspection_capabilit
     let transaction_read: &dyn ksp_store_api::RawTransactionRead = &backend;
     let transaction_write: &dyn ksp_store_api::RawTransactionWrite = &backend;
     let transaction_inspection: &dyn ksp_store_api::RawTransactionInspectionRead = &backend;
+    let transaction_observation_inspection: &dyn ksp_store_api::RawTransactionObservationInspectionRead = &backend;
     let transaction_observation_read: &dyn ksp_store_api::RawTransactionObservationRead = &backend;
     let transaction_observation_write: &dyn ksp_store_api::RawTransactionObservationWrite = &backend;
     let account_read: &dyn ksp_store_api::RawAccountStateRead = &backend;
     let account_write: &dyn ksp_store_api::RawAccountStateWrite = &backend;
     let account_inspection: &dyn ksp_store_api::RawAccountStateInspectionRead = &backend;
+    let account_observation_inspection: &dyn ksp_store_api::RawAccountObservationInspectionRead = &backend;
     let account_observation_read: &dyn ksp_store_api::RawAccountObservationRead = &backend;
     let account_observation_write: &dyn ksp_store_api::RawAccountObservationWrite = &backend;
     let retention_read: &dyn ksp_store_api::RawTransactionRetentionRead = &backend;
@@ -209,11 +235,13 @@ fn v0_3_8_pre_003_external_backend_implements_canonical_and_inspection_capabilit
     let _ = transaction_read;
     let _ = transaction_write;
     let _ = transaction_inspection;
+    let _ = transaction_observation_inspection;
     let _ = transaction_observation_read;
     let _ = transaction_observation_write;
     let _ = account_read;
     let _ = account_write;
     let _ = account_inspection;
+    let _ = account_observation_inspection;
     let _ = account_observation_read;
     let _ = account_observation_write;
     let _ = retention_read;

crates/ksp-store-api/tests/public_api.rs

@@ -1,5 +1,5 @@
 // file: crates/ksp-store-api/tests/public_api.rs
-// version: 7
+// version: 8
 
 //! Integration canaries for the public `ksp-store-api` surface.
 
@@ -199,8 +199,12 @@ fn public_v0_3_8_pre_003_inspection_contracts_are_backend_neutral_and_dyn_compat
     let page = ksp_store_api::RawInspectionPage::<u64>::try_new(std::vec![1, 2], 10, 5);
     assert!(page.is_ok());
     let transaction_inspection: std::option::Option<&dyn ksp_store_api::RawTransactionInspectionRead> = std::option::Option::None;
+    let transaction_observation_inspection: std::option::Option<&dyn ksp_store_api::RawTransactionObservationInspectionRead> = std::option::Option::None;
     let account_inspection: std::option::Option<&dyn ksp_store_api::RawAccountStateInspectionRead> = std::option::Option::None;
+    let account_observation_inspection: std::option::Option<&dyn ksp_store_api::RawAccountObservationInspectionRead> = std::option::Option::None;
     assert!(transaction_inspection.is_none());
+    assert!(transaction_observation_inspection.is_none());
     assert!(account_inspection.is_none());
+    assert!(account_observation_inspection.is_none());
     return;
 }

crates/ksp-store-api/tests/release_completeness.rs

@@ -1,5 +1,5 @@
 // file: crates/ksp-store-api/tests/release_completeness.rs
-// version: 2
+// version: 3
 
 //! Release-level boundary and completeness canaries for the backend-neutral Store API RAW surface.
 
@@ -21,6 +21,7 @@ fn v0_3_8_pre_003_exact_crate_root_export_inventory_is_stable() {
         "pub use ksp_core_lib::Pubkey;",
         "pub use ksp_core_lib::Result;",
         "pub use self::capability::StoreApiFuture;",
+        "pub use self::capability::raw_account::RawAccountObservationInspectionRead;",
         "pub use self::capability::raw_account::RawAccountObservationRead;",
         "pub use self::capability::raw_account::RawAccountObservationWrite;",
         "pub use self::capability::raw_account::RawAccountStateRead;",
@@ -28,6 +29,7 @@ fn v0_3_8_pre_003_exact_crate_root_export_inventory_is_stable() {
         "pub use self::capability::raw_account::RawAccountStateWrite;",
         "pub use self::capability::raw_retention::RawTransactionRetentionRead;",
         "pub use self::capability::raw_retention::RawTransactionRetentionWrite;",
+        "pub use self::capability::raw_transaction::RawTransactionObservationInspectionRead;",
         "pub use self::capability::raw_transaction::RawTransactionObservationRead;",
         "pub use self::capability::raw_transaction::RawTransactionObservationWrite;",
         "pub use self::capability::raw_transaction::RawTransactionRead;",
@@ -42,11 +44,15 @@ fn v0_3_8_pre_003_exact_crate_root_export_inventory_is_stable() {
         "pub use self::model::raw_account::RawAccountObservation;",
         "pub use self::model::raw_account::RawAccountState;",
         "pub use self::model::raw_account::RawAccountStateReference;",
+        "pub use self::model::raw_inspection::RawAccountObservationInspectionQuery;",
+        "pub use self::model::raw_inspection::RawAccountObservationSummary;",
         "pub use self::model::raw_inspection::RawAccountStateInspectionQuery;",
         "pub use self::model::raw_inspection::RawAccountStateSummary;",
         "pub use self::model::raw_inspection::RawInspectionPage;",
         "pub use self::model::raw_inspection::RawInspectionPageRequest;",
         "pub use self::model::raw_inspection::RawTransactionInspectionQuery;",
+        "pub use self::model::raw_inspection::RawTransactionObservationInspectionQuery;",
+        "pub use self::model::raw_inspection::RawTransactionObservationSummary;",
         "pub use self::model::raw_inspection::RawTransactionSummary;",
         "pub use self::model::raw_outcome::RawAcquisitionWriteOutcome;",
         "pub use self::model::raw_outcome::RawEntityWriteOutcome;",
@@ -202,11 +208,13 @@ fn v0_3_8_pre_003_capability_inventory_stays_fine_grained_without_runtime_facade
     }
     traits.sort_unstable();
     let mut expected = std::vec![
+        "pub trait RawAccountObservationInspectionRead: std::marker::Send + std::marker::Sync {",
         "pub trait RawAccountObservationRead: std::marker::Send + std::marker::Sync {",
         "pub trait RawAccountObservationWrite: std::marker::Send + std::marker::Sync {",
         "pub trait RawAccountStateRead: std::marker::Send + std::marker::Sync {",
         "pub trait RawAccountStateInspectionRead: std::marker::Send + std::marker::Sync {",
         "pub trait RawAccountStateWrite: std::marker::Send + std::marker::Sync {",
+        "pub trait RawTransactionObservationInspectionRead: std::marker::Send + std::marker::Sync {",
         "pub trait RawTransactionObservationRead: std::marker::Send + std::marker::Sync {",
         "pub trait RawTransactionObservationWrite: std::marker::Send + std::marker::Sync {",
         "pub trait RawTransactionRead: std::marker::Send + std::marker::Sync {",

crates/ksp-store-api/unit_tests/model/raw_inspection.rs

@@ -1,5 +1,5 @@
 // file: crates/ksp-store-api/unit_tests/model/raw_inspection.rs
-// version: 1
+// version: 2
 
 //! Unit tests for backend-neutral RAW inspection contracts.
 
@@ -154,3 +154,118 @@ fn account_summary_exposes_length_only_and_enforces_raw_account_bound() {
     assert!(crate::RawAccountStateSummary::try_new(reference, 1000, crate::Pubkey::new_from_array([0x43_u8; 32]), false, 9, 16_777_217,).is_err());
     return;
 }
+
+#[test]
+fn observation_inspection_queries_require_network_coherence_and_exact_entity_filters() {
+    let network = match network() {
+        std::option::Option::Some(value) => value,
+        std::option::Option::None => return,
+    };
+    let other_network = match crate::RawNetworkId::new("devnet".to_owned()) {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(_) => return,
+    };
+    let limit = match crate::RawPageLimit::new(25) {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(_) => return,
+    };
+    let page = crate::RawInspectionPageRequest::new(125, limit);
+    let transaction_reference = crate::RawTransactionReference::new(network.clone(), crate::RawTransactionSignature::new([0x51_u8; 64]));
+    let transaction = crate::RawTransactionObservationInspectionQuery::try_new(
+        network.clone(),
+        std::option::Option::Some(transaction_reference.clone()),
+        crate::RawSortDirection::Descending,
+        page,
+    );
+    assert!(transaction.is_ok());
+    let transaction = match transaction {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(_) => return,
+    };
+    assert_eq!(transaction.page().offset(), 125);
+    assert_eq!(transaction.transaction(), std::option::Option::Some(&transaction_reference));
+    assert!(
+        crate::RawTransactionObservationInspectionQuery::try_new(
+            other_network.clone(),
+            std::option::Option::Some(transaction_reference),
+            crate::RawSortDirection::Ascending,
+            page,
+        )
+        .is_err()
+    );
+    let account_reference =
+        crate::RawAccountStateReference::new(network.clone(), crate::Pubkey::new_from_array([0x52_u8; 32]), 99, crate::RawContentHash::new([0x53_u8; 32]));
+    let account = crate::RawAccountObservationInspectionQuery::try_new(
+        network,
+        std::option::Option::Some(account_reference.clone()),
+        crate::RawSortDirection::Ascending,
+        page,
+    );
+    assert!(account.is_ok());
+    let account = match account {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(_) => return,
+    };
+    assert_eq!(account.account(), std::option::Option::Some(&account_reference));
+    let mismatched_account = crate::RawAccountStateReference::new(
+        other_network.clone(),
+        crate::Pubkey::new_from_array([0x54_u8; 32]),
+        100,
+        crate::RawContentHash::new([0x55_u8; 32]),
+    );
+    assert!(
+        crate::RawAccountObservationInspectionQuery::try_new(
+            other_network,
+            std::option::Option::Some(account_reference),
+            crate::RawSortDirection::Ascending,
+            page,
+        )
+        .is_err()
+    );
+    let _ = mismatched_account;
+    return;
+}
+
+#[test]
+fn observation_summaries_expose_safe_provenance_without_raw_entity_bytes() {
+    let network = match network() {
+        std::option::Option::Some(value) => value,
+        std::option::Option::None => return,
+    };
+    let provider = match crate::RawProvenanceCode::new("publicnode".to_owned()) {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(_) => return,
+    };
+    let protocol = match crate::RawProvenanceCode::new("solana-json-rpc".to_owned()) {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(_) => return,
+    };
+    let method = match crate::RawProvenanceCode::new("getTransaction".to_owned()) {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(_) => return,
+    };
+    let received_at = match crate::RawTimestamp::from_unix_millis(1_750_000_000_000) {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(_) => return,
+    };
+    let provenance = crate::RawAcquisitionProvenance::new(provider, protocol, method, crate::RawAcquisitionOrigin::Backfill, received_at);
+    let transaction_reference = crate::RawTransactionReference::new(network.clone(), crate::RawTransactionSignature::new([0x61_u8; 64]));
+    let transaction =
+        crate::RawTransactionObservationSummary::new(crate::RawObservationKey::new([0x62_u8; 32]), transaction_reference.clone(), provenance.clone());
+    assert_eq!(transaction.transaction(), &transaction_reference);
+    assert_eq!(transaction.provenance().received_at(), received_at);
+    let account_reference =
+        crate::RawAccountStateReference::new(network, crate::Pubkey::new_from_array([0x63_u8; 32]), 700, crate::RawContentHash::new([0x64_u8; 32]));
+    let account = crate::RawAccountObservationSummary::new(
+        crate::RawObservationKey::new([0x65_u8; 32]),
+        account_reference.clone(),
+        provenance,
+        std::option::Option::Some(true),
+        std::option::Option::Some(crate::RawTransactionSignature::new([0x66_u8; 64])),
+        std::option::Option::Some(u64::MAX),
+    );
+    assert_eq!(account.account(), &account_reference);
+    assert_eq!(account.is_startup(), std::option::Option::Some(true));
+    assert_eq!(account.write_version(), std::option::Option::Some(u64::MAX));
+    return;
+}