staking: move uptime tracking to NV storage (#4046)

Close #4030, I think we could also avoid deserializing into a domain
type altogether, maybe other optimizations are possible. This takes care
of the state-breaking part of the change.

crates/core/component/stake/src/component/validator_handler/validator_store.rs

@@ -10,7 +10,7 @@ use async_trait::async_trait;
 use cnidarium::{StateRead, StateWrite};
 use futures::{Future, FutureExt, TryStreamExt};
 use penumbra_num::Amount;
-use penumbra_proto::{state::future::DomainFuture, StateReadProto, StateWriteProto};
+use penumbra_proto::{state::future::DomainFuture, DomainType, StateReadProto, StateWriteProto};
 use std::pin::Pin;
 use tendermint::PublicKey;
 use tracing::instrument;
@@ -113,7 +113,8 @@ pub trait ValidatorDataRead: StateRead {
         &self,
         identity_key: &IdentityKey,
     ) -> DomainFuture<Uptime, Self::GetRawFut> {
-        self.get(&state_key::validators::uptime::by_id(identity_key))
+        let key = state_key::validators::uptime::by_id(identity_key);
+        self.nonverifiable_get(key.as_bytes())
     }
 
     // Tendermint validators are referenced to us by their Tendermint consensus key,
@@ -204,7 +205,12 @@ impl<T: StateRead + ?Sized> ValidatorDataRead for T {}
 #[async_trait]
 pub(crate) trait ValidatorDataWrite: StateWrite {
     fn set_validator_uptime(&mut self, identity_key: &IdentityKey, uptime: Uptime) {
-        self.put(state_key::validators::uptime::by_id(identity_key), uptime);
+        self.nonverifiable_put_raw(
+            state_key::validators::uptime::by_id(identity_key)
+                .as_bytes()
+                .to_vec(),
+            uptime.encode_to_vec(),
+        );
     }
 
     fn set_validator_bonding_state(

crates/proto/src/state/read.rs

@@ -26,6 +26,24 @@ pub trait StateReadProto: StateRead + Send + Sync {
         }
     }
 
+    /// Gets a value from the nonverifiable key-value store as a domain type.
+    ///
+    /// # Returns
+    ///
+    /// * `Ok(Some(v))` if the value is present and parseable as a domain type `D`;
+    /// * `Ok(None)` if the value is missing;
+    /// * `Err(_)` if the value is present but not parseable as a domain type `D`, or if an underlying storage error occurred.
+    fn nonverifiable_get<D>(&self, key: &[u8]) -> DomainFuture<D, Self::GetRawFut>
+    where
+        D: DomainType + std::fmt::Debug,
+        anyhow::Error: From<<D as TryFrom<D::Proto>>::Error>,
+    {
+        DomainFuture {
+            inner: self.nonverifiable_get_raw(key),
+            _marker: std::marker::PhantomData,
+        }
+    }
+
     /// Gets a value from the verifiable key-value store as a proto type.
     ///
     /// # Returns