Merge pull request #292 from input-output-hk/whankinsiv/reg-deleg-and-mir-rest-handlers

feat: registration, delegation, and MIR history account endpoints

Author: whankinsiv

common/src/queries/accounts.rs

@@ -131,6 +131,15 @@ pub enum RegistrationStatus {
     Deregistered,
 }
 
+impl std::fmt::Display for RegistrationStatus {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            RegistrationStatus::Registered => write!(f, "registered"),
+            RegistrationStatus::Deregistered => write!(f, "deregistered"),
+        }
+    }
+}
+
 #[derive(
     Debug, Clone, serde::Serialize, serde::Deserialize, minicbor::Decode, minicbor::Encode,
 )]

modules/historical_accounts_state/src/historical_accounts_state.rs

@@ -321,25 +321,28 @@ impl HistoricalAccountsState {
                 let response = match query {
                     AccountsStateQuery::GetAccountRegistrationHistory { account } => {
                         match state.lock().await.get_registration_history(&account).await {
-                            Ok(registrations) => {
+                            Ok(Some(registrations)) => {
                                 AccountsStateQueryResponse::AccountRegistrationHistory(
                                     registrations,
                                 )
                             }
+                            Ok(None) => AccountsStateQueryResponse::NotFound,
                             Err(e) => AccountsStateQueryResponse::Error(e.to_string()),
                         }
                     }
                     AccountsStateQuery::GetAccountDelegationHistory { account } => {
                         match state.lock().await.get_delegation_history(&account).await {
-                            Ok(delegations) => {
+                            Ok(Some(delegations)) => {
                                 AccountsStateQueryResponse::AccountDelegationHistory(delegations)
                             }
+                            Ok(None) => AccountsStateQueryResponse::NotFound,
                             Err(e) => AccountsStateQueryResponse::Error(e.to_string()),
                         }
                     }
                     AccountsStateQuery::GetAccountMIRHistory { account } => {
                         match state.lock().await.get_mir_history(&account).await {
-                            Ok(mirs) => AccountsStateQueryResponse::AccountMIRHistory(mirs),
+                            Ok(Some(mirs)) => AccountsStateQueryResponse::AccountMIRHistory(mirs),
+                            Ok(None) => AccountsStateQueryResponse::NotFound,
                             Err(e) => AccountsStateQueryResponse::Error(e.to_string()),
                         }
                     }

modules/historical_accounts_state/src/immutable_historical_account_store.rs

@@ -9,7 +9,7 @@ use fjall::{Keyspace, Partition, PartitionCreateOptions};
 use minicbor::{decode, to_vec};
 use rayon::iter::{IntoParallelIterator, ParallelIterator};
 use tokio::sync::Mutex;
-use tracing::{debug, error, info};
+use tracing::{debug, error};
 
 use crate::state::{AccountEntry, ActiveStakeHistory, HistoricalAccountsConfig, RewardHistory};
 
@@ -61,17 +61,21 @@ impl ImmutableHistoricalAccountStore {
     /// and addresses into their respective Fjall partitions for an entire epoch.
     /// Skips any partitions that have already stored the given epoch.
     /// All writes are batched and committed atomically, preventing on-disk corruption in case of failure.
-    pub async fn persist_epoch(&self, epoch: u32, config: &HistoricalAccountsConfig) -> Result<()> {
-        if !config.any_enabled() {
-            debug!("no persistence needed for epoch {epoch} (disabled)",);
-            return Ok(());
-        }
-
+    pub async fn persist_epoch(
+        &self,
+        epoch: u32,
+        config: &HistoricalAccountsConfig,
+    ) -> Result<u64> {
         let drained_blocks = {
             let mut pending = self.pending.lock().await;
             std::mem::take(&mut *pending)
         };
 
+        if !config.any_enabled() {
+            debug!("no persistence needed for epoch {epoch} (disabled)",);
+            return Ok(0);
+        }
+
         let mut batch = self.keyspace.batch();
         let mut change_count = 0;
 
@@ -135,10 +139,7 @@ impl ImmutableHistoricalAccountStore {
         }
 
         match batch.commit() {
-            Ok(_) => {
-                info!("committed {change_count} account changes for epoch {epoch}");
-                Ok(())
-            }
+            Ok(_) => Ok(change_count),
             Err(e) => {
                 error!("batch commit failed for epoch {epoch}: {e}");
                 Err(e.into())

modules/historical_accounts_state/src/state.rs

@@ -249,41 +249,58 @@ impl State {
     pub async fn get_registration_history(
         &self,
         account: &StakeAddress,
-    ) -> Result<Vec<RegistrationUpdate>> {
-        let mut registrations =
-            self.immutable.get_registration_history(&account).await?.unwrap_or_default();
+    ) -> Result<Option<Vec<RegistrationUpdate>>> {
+        let immutable = self.immutable.get_registration_history(&account).await?;
 
-        self.merge_volatile_history(
-            &account,
-            |e| e.registration_history.as_ref(),
-            &mut registrations,
-        );
+        let mut volatile = Vec::new();
+        self.merge_volatile_history(&account, |e| e.registration_history.as_ref(), &mut volatile);
 
-        Ok(registrations)
+        match immutable {
+            Some(mut registrations) => {
+                registrations.extend(volatile);
+                Ok(Some(registrations))
+            }
+            None if volatile.is_empty() => Ok(None),
+            None => Ok(Some(volatile)),
+        }
     }
 
     pub async fn get_delegation_history(
         &self,
         account: &StakeAddress,
-    ) -> Result<Vec<DelegationUpdate>> {
-        let mut delegations =
-            self.immutable.get_delegation_history(&account).await?.unwrap_or_default();
+    ) -> Result<Option<Vec<DelegationUpdate>>> {
+        let immutable = self.immutable.get_delegation_history(&account).await?;
 
-        self.merge_volatile_history(
-            &account,
-            |e| e.delegation_history.as_ref(),
-            &mut delegations,
-        );
+        let mut volatile = Vec::new();
+        self.merge_volatile_history(&account, |e| e.delegation_history.as_ref(), &mut volatile);
 
-        Ok(delegations)
+        match immutable {
+            Some(mut delegations) => {
+                delegations.extend(volatile);
+                Ok(Some(delegations))
+            }
+            None if volatile.is_empty() => Ok(None),
+            None => Ok(Some(volatile)),
+        }
     }
 
-    pub async fn get_mir_history(&self, account: &StakeAddress) -> Result<Vec<AccountWithdrawal>> {
-        let mut mirs = self.immutable.get_mir_history(&account).await?.unwrap_or_default();
+    pub async fn get_mir_history(
+        &self,
+        account: &StakeAddress,
+    ) -> Result<Option<Vec<AccountWithdrawal>>> {
+        let immutable = self.immutable.get_mir_history(&account).await?;
 
-        self.merge_volatile_history(&account, |e| e.mir_history.as_ref(), &mut mirs);
+        let mut volatile = Vec::new();
+        self.merge_volatile_history(&account, |e| e.mir_history.as_ref(), &mut volatile);
 
-        Ok(mirs)
+        match immutable {
+            Some(mut mirs) => {
+                mirs.extend(volatile);
+                Ok(Some(mirs))
+            }
+            None if volatile.is_empty() => Ok(None),
+            None => Ok(Some(volatile)),
+        }
     }
 
     pub async fn _get_withdrawal_history(