feat: account assets, utxos, and totals REST handlers (WIP)

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

Author: whankinsiv

common/src/queries/accounts.rs

@@ -15,20 +15,19 @@ pub const DEFAULT_HISTORICAL_ACCOUNTS_QUERY_TOPIC: (&str, &str) = (
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub enum AccountsStateQuery {
     GetAccountInfo { account: StakeAddress },
+    GetAccountsUtxoValuesMap { stake_addresses: Vec<StakeAddress> },
+    GetAccountsUtxoValuesSum { stake_addresses: Vec<StakeAddress> },
+    GetAccountsBalancesMap { stake_addresses: Vec<StakeAddress> },
+    GetAccountsBalancesSum { stake_addresses: Vec<StakeAddress> },
+
+    // Served from historical accounts state
     GetAccountRewardHistory { account: StakeAddress },
     GetAccountHistory { stake_key: Vec<u8> },
     GetAccountRegistrationHistory { account: StakeAddress },
     GetAccountDelegationHistory { account: StakeAddress },
     GetAccountMIRHistory { account: StakeAddress },
     GetAccountWithdrawalHistory { account: StakeAddress },
     GetAccountAssociatedAddresses { account: StakeAddress },
-    GetAccountAssets { stake_key: Vec<u8> },
-    GetAccountAssetsTotals { stake_key: Vec<u8> },
-    GetAccountUTxOs { stake_key: Vec<u8> },
-    GetAccountsUtxoValuesMap { stake_addresses: Vec<StakeAddress> },
-    GetAccountsUtxoValuesSum { stake_addresses: Vec<StakeAddress> },
-    GetAccountsBalancesMap { stake_addresses: Vec<StakeAddress> },
-    GetAccountsBalancesSum { stake_addresses: Vec<StakeAddress> },
 
     // Epochs-related queries
     GetActiveStakes {},
@@ -49,20 +48,19 @@ pub enum AccountsStateQuery {
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub enum AccountsStateQueryResponse {
     AccountInfo(AccountInfo),
+    AccountsUtxoValuesMap(HashMap<StakeAddress, u64>),
+    AccountsUtxoValuesSum(u64),
+    AccountsBalancesMap(HashMap<StakeAddress, u64>),
+    AccountsBalancesSum(u64),
+
+    // Served from historical accounts state
     AccountRewardHistory(Vec<AccountReward>),
     AccountHistory(AccountHistory),
     AccountRegistrationHistory(Vec<RegistrationUpdate>),
     AccountDelegationHistory(Vec<DelegationUpdate>),
     AccountMIRHistory(Vec<AccountWithdrawal>),
     AccountWithdrawalHistory(Vec<AccountWithdrawal>),
     AccountAssociatedAddresses(Vec<ShelleyAddress>),
-    AccountAssets(AccountAssets),
-    AccountAssetsTotals(AccountAssetsTotals),
-    AccountUTxOs(AccountUTxOs),
-    AccountsUtxoValuesMap(HashMap<StakeAddress, u64>),
-    AccountsUtxoValuesSum(u64),
-    AccountsBalancesMap(HashMap<StakeAddress, u64>),
-    AccountsBalancesSum(u64),
 
     // Epochs-related responses
     ActiveStakes(u64),
@@ -163,21 +161,6 @@ pub struct AccountReward {
     pub reward_type: RewardType,
 }
 
-#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
-pub struct AccountWithdrawalHistory {}
-
-#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
-pub struct AccountAssociatedAddresses {}
-
-#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
-pub struct AccountAssets {}
-
-#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
-pub struct AccountAssetsTotals {}
-
-#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
-pub struct AccountUTxOs {}
-
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct OptimalPoolSizing {
     pub total_supply: u64, // total_supply - reserves

modules/rest_blockfrost/src/handlers/accounts.rs

@@ -8,7 +8,7 @@ use acropolis_common::queries::blocks::{
 };
 use acropolis_common::queries::utils::query_state;
 use acropolis_common::serialization::{Bech32Conversion, Bech32WithHrp};
-use acropolis_common::{DRepChoice, StakeAddress};
+use acropolis_common::{DRepChoice, ShelleyAddress, StakeAddress};
 use anyhow::{anyhow, Result};
 use caryatid_sdk::Context;
 
@@ -635,6 +635,71 @@ pub async fn handle_account_addresses_blockfrost(
     }
 }
 
+/// Handle `/accounts/{stake_address}/addresses/assets` Blockfrost-compatible endpoint
+pub async fn handle_account_assets_blockfrost(
+    _context: Arc<Context<Message>>,
+    _params: Vec<String>,
+    _handlers_config: Arc<HandlersConfig>,
+) -> Result<RESTResponse> {
+    Ok(RESTResponse::with_text(501, "Not implemented"))
+}
+
+/// Handle `/accounts/{stake_address}/addresses/total` Blockfrost-compatible endpoint
+pub async fn handle_account_totals_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"));
+    };
+
+    Ok(RESTResponse::with_text(501, "Not implemented"))
+}
+
+/// Handle `/accounts/{stake_address}/utxos` Blockfrost-compatible endpoint
+pub async fn handle_account_utxos_blockfrost(
+    _context: Arc<Context<Message>>,
+    _params: Vec<String>,
+    _handlers_config: Arc<HandlersConfig>,
+) -> Result<RESTResponse> {
+    Ok(RESTResponse::with_text(501, "Not implemented"))
+}
+
 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,10 +17,11 @@ mod types;
 mod utils;
 use handlers::{
     accounts::{
-        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,
+        handle_account_addresses_blockfrost, handle_account_assets_blockfrost,
+        handle_account_delegations_blockfrost, handle_account_mirs_blockfrost,
+        handle_account_registrations_blockfrost, handle_account_rewards_blockfrost,
+        handle_account_totals_blockfrost, handle_account_utxos_blockfrost,
+        handle_account_withdrawals_blockfrost, handle_single_account_blockfrost,
     },
     addresses::{
         handle_address_asset_utxos_blockfrost, handle_address_extended_blockfrost,
@@ -90,6 +91,16 @@ const DEFAULT_HANDLE_ACCOUNT_ADDRESSES_TOPIC: (&str, &str) = (
     "handle-topic-account-addresses",
     "rest.get.accounts.*.addresses",
 );
+const DEFAULT_HANDLE_ACCOUNT_ASSETS_TOPIC: (&str, &str) = (
+    "handle-topic-account-assets",
+    "rest.get.accounts.*.addresses.assets",
+);
+const DEFAULT_HANDLE_ACCOUNT_TOTALS_TOPIC: (&str, &str) = (
+    "handle-topic-account-totals",
+    "rest.get.accounts.*.addresses.total",
+);
+const DEFAULT_HANDLE_ACCOUNT_UTXOS_TOPIC: (&str, &str) =
+    ("handle-topic-account-utxos", "rest.get.accounts.*.utxos");
 
 // Blocks topics
 const DEFAULT_HANDLE_BLOCKS_LATEST_HASH_NUMBER_TOPIC: (&str, &str) =
@@ -324,6 +335,30 @@ impl BlockfrostREST {
             handle_account_addresses_blockfrost,
         );
 
+        // Handler for /accounts/{stake_address}/addresses/assets
+        register_handler(
+            context.clone(),
+            DEFAULT_HANDLE_ACCOUNT_ASSETS_TOPIC,
+            handlers_config.clone(),
+            handle_account_assets_blockfrost,
+        );
+
+        // Handler for /accounts/{stake_address}/addreesses/total
+        register_handler(
+            context.clone(),
+            DEFAULT_HANDLE_ACCOUNT_TOTALS_TOPIC,
+            handlers_config.clone(),
+            handle_account_totals_blockfrost,
+        );
+
+        // Handler for /accounts/{stake_address}/utxos
+        register_handler(
+            context.clone(),
+            DEFAULT_HANDLE_ACCOUNT_UTXOS_TOPIC,
+            handlers_config.clone(),
+            handle_account_utxos_blockfrost,
+        );
+
         // Handler for /blocks/latest, /blocks/{hash_or_number}
         register_handler(
             context.clone(),