feat: add account rewards REST handler

Signed-off-by: William Hankins <[email protected]>

Author: whankinsiv

common/src/queries/accounts.rs

@@ -49,7 +49,7 @@ pub enum AccountsStateQuery {
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub enum AccountsStateQueryResponse {
     AccountInfo(AccountInfo),
-    AccountRewardHistory(Vec<RewardHistory>),
+    AccountRewardHistory(Vec<AccountReward>),
     AccountHistory(AccountHistory),
     AccountRegistrationHistory(Vec<RegistrationUpdate>),
     AccountDelegationHistory(Vec<DelegationUpdate>),
@@ -152,7 +152,7 @@ pub struct AccountWithdrawal {
 #[derive(
     Debug, Clone, minicbor::Decode, minicbor::Encode, serde::Serialize, serde::Deserialize,
 )]
-pub struct RewardHistory {
+pub struct AccountReward {
     #[n(0)]
     pub epoch: u32,
     #[n(1)]

common/src/types.rs

@@ -230,6 +230,16 @@ pub enum RewardType {
     PoolRefund,
 }
 
+impl fmt::Display for RewardType {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            RewardType::Leader => write!(f, "leader"),
+            RewardType::Member => write!(f, "member"),
+            RewardType::PoolRefund => write!(f, "pool_deposit_refund"),
+        }
+    }
+}
+
 pub type PolicyId = [u8; 28];
 pub type NativeAssets = Vec<(PolicyId, Vec<NativeAsset>)>;
 pub type NativeAssetsDelta = Vec<(PolicyId, Vec<NativeAssetDelta>)>;

modules/historical_accounts_state/src/immutable_historical_account_store.rs

@@ -1,7 +1,7 @@
 use std::{collections::HashMap, path::Path};
 
 use acropolis_common::{
-    queries::accounts::{AccountWithdrawal, DelegationUpdate, RegistrationUpdate, RewardHistory},
+    queries::accounts::{AccountReward, AccountWithdrawal, DelegationUpdate, RegistrationUpdate},
     ShelleyAddress, StakeAddress,
 };
 use anyhow::Result;
@@ -155,9 +155,9 @@ impl ImmutableHistoricalAccountStore {
     pub async fn get_reward_history(
         &self,
         account: &StakeAddress,
-    ) -> Result<Option<Vec<RewardHistory>>> {
+    ) -> Result<Option<Vec<AccountReward>>> {
         let mut immutable_rewards =
-            self.collect_partition::<RewardHistory>(&self.rewards_history, account.get_hash())?;
+            self.collect_partition::<AccountReward>(&self.rewards_history, account.get_hash())?;
 
         self.merge_pending(
             account,

modules/historical_accounts_state/src/state.rs

@@ -8,7 +8,7 @@ use acropolis_common::{
         AddressDeltasMessage, StakeRewardDeltasMessage, TxCertificatesMessage, WithdrawalsMessage,
     },
     queries::accounts::{
-        AccountWithdrawal, DelegationUpdate, RegistrationStatus, RegistrationUpdate, RewardHistory,
+        AccountReward, AccountWithdrawal, DelegationUpdate, RegistrationStatus, RegistrationUpdate,
     },
     BlockInfo, InstantaneousRewardTarget, PoolId, ShelleyAddress, StakeAddress, TxCertificate,
     TxIdentifier,
@@ -24,7 +24,7 @@ use anyhow::Result;
 
 #[derive(Debug, Default, Clone)]
 pub struct AccountEntry {
-    pub reward_history: Option<Vec<RewardHistory>>,
+    pub reward_history: Option<Vec<AccountReward>>,
     pub active_stake_history: Option<Vec<ActiveStakeHistory>>,
     pub delegation_history: Option<Vec<DelegationUpdate>>,
     pub registration_history: Option<Vec<RegistrationUpdate>>,
@@ -108,7 +108,7 @@ impl State {
         let volatile = self.volatile.window.back_mut().expect("window should never be empty");
         for reward in reward_deltas.deltas.iter() {
             let entry = volatile.entry(reward.stake_address.clone()).or_default();
-            let update = RewardHistory {
+            let update = AccountReward {
                 epoch,
                 amount: reward.delta,
                 pool: reward.pool.clone(),
@@ -240,7 +240,7 @@ impl State {
     pub async fn get_reward_history(
         &self,
         account: &StakeAddress,
-    ) -> Result<Option<Vec<RewardHistory>>> {
+    ) -> Result<Option<Vec<AccountReward>>> {
         let immutable = self.immutable.get_reward_history(account).await?;
 
         let mut volatile = Vec::new();

modules/rest_blockfrost/src/handlers/accounts.rs

@@ -13,7 +13,9 @@ use anyhow::{anyhow, Result};
 use caryatid_sdk::Context;
 
 use crate::handlers_config::HandlersConfig;
-use crate::types::{AccountWithdrawalREST, DelegationUpdateREST, RegistrationUpdateREST};
+use crate::types::{
+    AccountRewardREST, AccountWithdrawalREST, DelegationUpdateREST, RegistrationUpdateREST,
+};
 
 #[derive(serde::Serialize)]
 pub struct StakeAccountRest {
@@ -434,8 +436,8 @@ pub async fn handle_account_withdrawals_blockfrost(
         msg,
         |message| match message {
             Message::StateQueryResponse(StateQueryResponse::Accounts(
-                AccountsStateQueryResponse::AccountWithdrawalHistory(registrations),
-            )) => Ok(Some(registrations)),
+                AccountsStateQueryResponse::AccountWithdrawalHistory(withdrawals),
+            )) => Ok(Some(withdrawals)),
             Message::StateQueryResponse(StateQueryResponse::Accounts(
                 AccountsStateQueryResponse::NotFound,
             )) => Ok(None),
@@ -505,6 +507,71 @@ pub async fn handle_account_withdrawals_blockfrost(
     }
 }
 
+pub async fn handle_account_rewards_blockfrost(
+    context: Arc<Context<Message>>,
+    params: Vec<String>,
+    handlers_config: Arc<HandlersConfig>,
+) -> Result<RESTResponse> {
+    let stake_address = match parse_stake_address(&params) {
+        Ok(addr) => addr,
+        Err(resp) => return Ok(resp),
+    };
+
+    // Prepare the message
+    let msg = Arc::new(Message::StateQuery(StateQuery::Accounts(
+        AccountsStateQuery::GetAccountRegistrationHistory {
+            account: stake_address,
+        },
+    )));
+
+    // Get rewards from historical accounts state
+    let rewards = query_state(
+        &context,
+        &handlers_config.historical_accounts_query_topic,
+        msg,
+        |message| match message {
+            Message::StateQueryResponse(StateQueryResponse::Accounts(
+                AccountsStateQueryResponse::AccountRewardHistory(rewards),
+            )) => Ok(Some(rewards)),
+            Message::StateQueryResponse(StateQueryResponse::Accounts(
+                AccountsStateQueryResponse::NotFound,
+            )) => Ok(None),
+            Message::StateQueryResponse(StateQueryResponse::Accounts(
+                AccountsStateQueryResponse::Error(e),
+            )) => Err(anyhow::anyhow!(
+                "Internal server error while retrieving account info: {e}"
+            )),
+            _ => Err(anyhow::anyhow!(
+                "Unexpected message type while retrieving account info"
+            )),
+        },
+    )
+    .await?;
+
+    let Some(rewards) = rewards else {
+        return Ok(RESTResponse::with_text(404, "Account not found"));
+    };
+
+    let rest_response =
+        match rewards.iter().map(|r| r.try_into()).collect::<Result<Vec<AccountRewardREST>, _>>() {
+            Ok(v) => v,
+            Err(e) => {
+                return Ok(RESTResponse::with_text(
+                    500,
+                    &format!("Failed to convert reward entry: {e}"),
+                ))
+            }
+        };
+
+    match serde_json::to_string_pretty(&rest_response) {
+        Ok(json) => Ok(RESTResponse::with_json(200, &json)),
+        Err(e) => Ok(RESTResponse::with_text(
+            500,
+            &format!("Internal server error while serializing withdrawal history: {e}"),
+        )),
+    }
+}
+
 fn parse_stake_address(params: &[String]) -> Result<StakeAddress, RESTResponse> {
     let Some(stake_key) = params.first() else {
         return Err(RESTResponse::with_text(

modules/rest_blockfrost/src/rest_blockfrost.rs

@@ -16,7 +16,11 @@ mod handlers_config;
 mod types;
 mod utils;
 use handlers::{
-    accounts::handle_single_account_blockfrost,
+    accounts::{
+        handle_account_delegations_blockfrost, handle_account_mirs_blockfrost,
+        handle_account_registrations_blockfrost, handle_account_rewards_blockfrost,
+        handle_account_withdrawals_blockfrost, handle_single_account_blockfrost,
+    },
     addresses::{
         handle_address_asset_utxos_blockfrost, handle_address_extended_blockfrost,
         handle_address_single_blockfrost, handle_address_totals_blockfrost,
@@ -58,13 +62,7 @@ use handlers::{
     },
 };
 
-use crate::{
-    handlers::accounts::{
-        handle_account_delegations_blockfrost, handle_account_mirs_blockfrost,
-        handle_account_registrations_blockfrost, handle_account_withdrawals_blockfrost,
-    },
-    handlers_config::HandlersConfig,
-};
+use crate::handlers_config::HandlersConfig;
 
 // Accounts topics
 const DEFAULT_HANDLE_SINGLE_ACCOUNT_TOPIC: (&str, &str) =
@@ -83,6 +81,10 @@ const DEFAULT_HANDLE_ACCOUNT_WITHDRAWALS_TOPIC: (&str, &str) = (
     "handle-topic-account-withdrawals",
     "rest.get.accounts.*.withdrawals",
 );
+const DEFAULT_HANDLE_ACCOUNT_REWARDS_TOPIC: (&str, &str) = (
+    "handle-topic-account-rewards",
+    "rest.get.accounts.*.rewards",
+);
 
 // Blocks topics
 const DEFAULT_HANDLE_BLOCKS_LATEST_HASH_NUMBER_TOPIC: (&str, &str) =
@@ -301,6 +303,14 @@ impl BlockfrostREST {
             handle_account_withdrawals_blockfrost,
         );
 
+        // Handler for /accounts/{stake_address}/rewards
+        register_handler(
+            context.clone(),
+            DEFAULT_HANDLE_ACCOUNT_REWARDS_TOPIC,
+            handlers_config.clone(),
+            handle_account_rewards_blockfrost,
+        );
+
         // Handler for /blocks/latest, /blocks/{hash_or_number}
         register_handler(
             context.clone(),

modules/rest_blockfrost/src/types.rs

@@ -2,10 +2,9 @@ use crate::cost_models::{PLUTUS_V1, PLUTUS_V2, PLUTUS_V3};
 use acropolis_common::{
     messages::EpochActivityMessage,
     protocol_params::{Nonce, NonceVariant, ProtocolParams},
-    queries::blocks::BlockInfo,
-    queries::governance::DRepActionUpdate,
+    queries::{accounts::AccountReward, blocks::BlockInfo, governance::DRepActionUpdate},
     rest_helper::ToCheckedF64,
-    serialization::{DisplayFromBech32, PoolPrefix},
+    serialization::{Bech32WithHrp, DisplayFromBech32, PoolPrefix},
     AssetAddressEntry, AssetMetadataStandard, AssetMintRecord, KeyHash, PolicyAsset,
     PoolEpochState, PoolUpdateAction, Relay, TxHash, Vote,
 };
@@ -874,3 +873,24 @@ pub struct AccountWithdrawalREST {
     pub tx_hash: String,
     pub amount: String,
 }
+
+#[derive(Serialize)]
+pub struct AccountRewardREST {
+    pub epoch: u32,
+    pub amount: String,
+    pub pool_id: String,
+    #[serde(rename = "type")]
+    pub reward_type: String,
+}
+
+impl TryFrom<&AccountReward> for AccountRewardREST {
+    type Error = anyhow::Error;
+    fn try_from(value: &AccountReward) -> Result<Self, Self::Error> {
+        Ok(Self {
+            epoch: value.epoch,
+            amount: value.amount.to_string(),
+            pool_id: value.pool.to_bech32_with_hrp("pool")?,
+            reward_type: value.reward_type.to_string(),
+        })
+    }
+}