feat: account addresses REST handler

Signed-off-by: William Hankins <william@sundae.fi>

Author: whankinsiv

modules/rest_blockfrost/src/handlers/accounts.rs

@@ -14,7 +14,8 @@ use caryatid_sdk::Context;
 
 use crate::handlers_config::HandlersConfig;
 use crate::types::{
-    AccountRewardREST, AccountWithdrawalREST, DelegationUpdateREST, RegistrationUpdateREST,
+    AccountAddressREST, AccountRewardREST, AccountWithdrawalREST, DelegationUpdateREST,
+    RegistrationUpdateREST,
 };
 
 #[derive(serde::Serialize)]
@@ -564,6 +565,76 @@ pub async fn handle_account_rewards_blockfrost(
     }
 }
 
+pub async fn handle_account_addresses_blockfrost(
+    context: Arc<Context<Message>>,
+    params: Vec<String>,
+    handlers_config: Arc<HandlersConfig>,
+) -> Result<RESTResponse> {
+    let account = 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::GetAccountAssociatedAddresses { account },
+    )));
+
+    // Get addresses from historical accounts state
+    let addresses = query_state(
+        &context,
+        &handlers_config.historical_accounts_query_topic,
+        msg,
+        |message| match message {
+            Message::StateQueryResponse(StateQueryResponse::Accounts(
+                AccountsStateQueryResponse::AccountAssociatedAddresses(addresses),
+            )) => Ok(Some(addresses)),
+            Message::StateQueryResponse(StateQueryResponse::Accounts(
+                AccountsStateQueryResponse::NotFound,
+            )) => Ok(None),
+            Message::StateQueryResponse(StateQueryResponse::Accounts(
+                AccountsStateQueryResponse::Error(e),
+            )) => Err(anyhow::anyhow!(
+                "Internal server error while retrieving account addresses: {e}"
+            )),
+            _ => Err(anyhow::anyhow!(
+                "Unexpected message type while retrieving account addresses"
+            )),
+        },
+    )
+    .await?;
+
+    let Some(addresses) = addresses else {
+        return Ok(RESTResponse::with_text(404, "Account not found"));
+    };
+
+    let rest_response = match addresses
+        .iter()
+        .map(|r| {
+            Ok::<_, anyhow::Error>(AccountAddressREST {
+                address: r.to_string().map_err(|e| anyhow!("invalid address: {e}"))?,
+            })
+        })
+        .collect::<Result<Vec<AccountAddressREST>, _>>()
+    {
+        Ok(v) => v,
+        Err(e) => {
+            return Ok(RESTResponse::with_text(
+                500,
+                &format!("Failed to convert address 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 addresses: {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

@@ -17,9 +17,10 @@ mod types;
 mod utils;
 use handlers::{
     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,
+        handle_account_addresses_blockfrost, 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,
@@ -85,6 +86,10 @@ const DEFAULT_HANDLE_ACCOUNT_REWARDS_TOPIC: (&str, &str) = (
     "handle-topic-account-rewards",
     "rest.get.accounts.*.rewards",
 );
+const DEFAULT_HANDLE_ACCOUNT_ADDRESSES_TOPIC: (&str, &str) = (
+    "handle-topic-account-addresses",
+    "rest.get.accounts.*.addresses",
+);
 
 // Blocks topics
 const DEFAULT_HANDLE_BLOCKS_LATEST_HASH_NUMBER_TOPIC: (&str, &str) =
@@ -311,6 +316,14 @@ impl BlockfrostREST {
             handle_account_rewards_blockfrost,
         );
 
+        // Handler for /accounts/{stake_address}/addresses
+        register_handler(
+            context.clone(),
+            DEFAULT_HANDLE_ACCOUNT_ADDRESSES_TOPIC,
+            handlers_config.clone(),
+            handle_account_addresses_blockfrost,
+        );
+
         // Handler for /blocks/latest, /blocks/{hash_or_number}
         register_handler(
             context.clone(),

modules/rest_blockfrost/src/types.rs

@@ -894,3 +894,8 @@ impl TryFrom<&AccountReward> for AccountRewardREST {
         })
     }
 }
+
+#[derive(Serialize)]
+pub struct AccountAddressREST {
+    pub address: String,
+}