feat(grapqhl): Expand accounts with delegators + cleaned up account loading

Author: Adrian Nagy

node/common/src/service/rpc/mod.rs

@@ -9,14 +9,15 @@ pub mod transition_frontier;
 
 use node::rpc::{
     RpcBestChainResponse, RpcBlockProducerStatsGetResponse, RpcConsensusConstantsGetResponse,
-    RpcConsensusTimeGetResponse, RpcDiscoveryBoostrapStatsResponse, RpcDiscoveryRoutingTableResponse,
-    RpcGenesisBlockResponse, RpcGetBlockResponse, RpcHealthCheckResponse, RpcHeartbeatGetResponse,
-    RpcLedgerAccountsResponse, RpcLedgerSlimAccountsResponse, RpcMessageProgressResponse,
-    RpcPeersGetResponse, RpcPooledUserCommandsResponse, RpcPooledZkappCommandsResponse,
-    RpcReadinessCheckResponse, RpcRequest, RpcSnarkPoolCompletedJobsResponse,
-    RpcSnarkPoolPendingJobsGetResponse, RpcStateGetError, RpcStatusGetResponse,
-    RpcTransactionInjectResponse, RpcTransactionPoolResponse, RpcTransactionStatusGetResponse,
-    RpcTransitionFrontierUserCommandsResponse, RpcLedgerStatusGetResponse,
+    RpcConsensusTimeGetResponse, RpcDiscoveryBoostrapStatsResponse,
+    RpcDiscoveryRoutingTableResponse, RpcGenesisBlockResponse, RpcGetBlockResponse,
+    RpcHealthCheckResponse, RpcHeartbeatGetResponse, RpcLedgerAccountDelegatorsGetResponse,
+    RpcLedgerAccountsResponse, RpcLedgerSlimAccountsResponse, RpcLedgerStatusGetResponse,
+    RpcMessageProgressResponse, RpcPeersGetResponse, RpcPooledUserCommandsResponse,
+    RpcPooledZkappCommandsResponse, RpcReadinessCheckResponse, RpcRequest,
+    RpcSnarkPoolCompletedJobsResponse, RpcSnarkPoolPendingJobsGetResponse, RpcStateGetError,
+    RpcStatusGetResponse, RpcTransactionInjectResponse, RpcTransactionPoolResponse,
+    RpcTransactionStatusGetResponse, RpcTransitionFrontierUserCommandsResponse,
 };
 use serde::{Deserialize, Serialize};
 
@@ -327,6 +328,10 @@ impl node::rpc_effectful::RpcService for NodeService {
     rpc_service_impl!(respond_genesis_block, RpcGenesisBlockResponse);
     rpc_service_impl!(respond_consensus_time_get, RpcConsensusTimeGetResponse);
     rpc_service_impl!(respond_ledger_status_get, RpcLedgerStatusGetResponse);
+    rpc_service_impl!(
+        respond_ledger_account_delegators_get,
+        RpcLedgerAccountDelegatorsGetResponse
+    );
 }
 
 #[cfg(test)]

node/native/src/graphql/account.rs

@@ -153,32 +153,32 @@ impl GraphQLAccount {
             // A delegate always has the default token id
             let delegate_id = AccountId::new_with_default_token(delegate_key.clone());
             // Use the loader to fetch the delegate account
-            let delegate_result =
-                context
-                    .account_loader
-                    .try_load(delegate_id)
-                    .await
-                    .map_err(|e| {
-                        juniper::FieldError::new(
-                            format!("Failed to load delegate account: {}", e),
-                            juniper::Value::null(),
-                        )
-                    })?;
-
-            // Handle the result
-            match delegate_result {
-                Ok(account) => Ok(Some(Box::new(account))),
-                Err(e) => Err(juniper::FieldError::new(
-                    format!("Error loading delegate account: {}", e),
-                    juniper::Value::null(),
-                )),
-            }
+            Ok(context.load_account(delegate_id).await.map(Box::new))
         } else {
             // No delegate
             Ok(None)
         }
     }
 
+    pub async fn delegators(&self, context: &Context) -> FieldResult<Vec<GraphQLAccount>> {
+        if let Some(best_tip) = context.get_or_fetch_best_tip().await {
+            let staking_ledger_hash = best_tip.staking_epoch_ledger_hash();
+
+            let id = self.inner.id();
+            let delegators = context
+                .fetch_delegators(staking_ledger_hash.clone(), id.clone())
+                .await
+                .unwrap_or_default();
+
+            Ok(delegators
+                .into_iter()
+                .map(GraphQLAccount::try_from)
+                .collect::<Result<Vec<_>, _>>()?)
+        } else {
+            Ok(vec![])
+        }
+    }
+
     fn voting_for(&self) -> &str {
         &self.voting_for
     }

node/native/src/graphql/block.rs

@@ -42,47 +42,24 @@ impl GraphQLBlock {
 
     async fn creator_account(&self, context: &Context) -> FieldResult<Box<GraphQLAccount>> {
         let account_id = AccountId::new_with_default_token(self.creator_account_key.clone());
-        let account_result = context
-            .account_loader
-            .try_load(account_id)
-            .await
-            .map_err(|e| {
-                juniper::FieldError::new(
-                    format!("Failed to load delegate account: {}", e),
-                    juniper::Value::null(),
-                )
-            })?;
-
-        // Handle the result
-        match account_result {
-            Ok(account) => Ok(Box::new(account)),
-            Err(e) => Err(juniper::FieldError::new(
-                format!("Error loading delegate account: {}", e),
+        if let Some(account) = context.load_account(account_id).await {
+            Ok(Box::new(account))
+        } else {
+            Err(juniper::FieldError::new(
+                "Failed to load creator account".to_string(),
                 juniper::Value::null(),
-            )),
+            ))
         }
     }
-
     async fn winner_account(&self, context: &Context) -> FieldResult<Box<GraphQLAccount>> {
         let account_id = AccountId::new_with_default_token(self.winner_account_key.clone());
-        let account_result = context
-            .account_loader
-            .try_load(account_id)
-            .await
-            .map_err(|e| {
-                juniper::FieldError::new(
-                    format!("Failed to load delegate account: {}", e),
-                    juniper::Value::null(),
-                )
-            })?;
-
-        // Handle the result
-        match account_result {
-            Ok(account) => Ok(Box::new(account)),
-            Err(e) => Err(juniper::FieldError::new(
-                format!("Error loading delegate account: {}", e),
+        if let Some(account) = context.load_account(account_id).await {
+            Ok(Box::new(account))
+        } else {
+            Err(juniper::FieldError::new(
+                "Failed to load winner account".to_string(),
                 juniper::Value::null(),
-            )),
+            ))
         }
     }
 

node/native/src/graphql/mod.rs

@@ -1,7 +1,7 @@
-use account::{create_account_loader, AccountLoader};
+use account::{create_account_loader, AccountLoader, GraphQLAccount};
 use block::{GraphQLBlock, GraphQLSnarkJob, GraphQLUserCommands};
 use juniper::{graphql_value, EmptySubscription, FieldError, GraphQLEnum, RootNode};
-use ledger::Account;
+use ledger::{Account, AccountId};
 use mina_p2p_messages::v2::{
     conv, LedgerHash, MinaBaseSignedCommandStableV2, MinaBaseUserCommandStableV2,
     MinaBaseZkappCommandTStableV1WireStableV1, TokenIdKeyHash, TransactionHash,
@@ -10,12 +10,12 @@ use node::{
     account::AccountPublicKey,
     ledger::read::LedgerStatus,
     rpc::{
-        AccountQuery, GetBlockQuery, PooledCommandsQuery, RpcGenesisBlockResponse,
-        RpcGetBlockResponse, RpcPooledUserCommandsResponse, RpcPooledZkappCommandsResponse,
-        RpcRequest, RpcSnarkPoolCompletedJobsResponse, RpcSnarkPoolPendingJobsGetResponse,
-        RpcSyncStatsGetResponse, RpcTransactionInjectResponse, RpcTransactionStatusGetResponse,
-        SyncStatsQuery, RpcStatusGetResponse, RpcNodeStatus, RpcBestChainResponse,
-        RpcLedgerStatusGetResponse
+        AccountQuery, GetBlockQuery, PooledCommandsQuery, RpcBestChainResponse,
+        RpcGenesisBlockResponse, RpcGetBlockResponse, RpcLedgerAccountDelegatorsGetResponse,
+        RpcLedgerStatusGetResponse, RpcNodeStatus, RpcPooledUserCommandsResponse,
+        RpcPooledZkappCommandsResponse, RpcRequest, RpcSnarkPoolCompletedJobsResponse,
+        RpcSnarkPoolPendingJobsGetResponse, RpcStatusGetResponse, RpcSyncStatsGetResponse,
+        RpcTransactionInjectResponse, RpcTransactionStatusGetResponse, SyncStatsQuery,
     },
     stats::sync::SyncKind,
     BuildEnv,
@@ -162,6 +162,24 @@ impl Context {
             .await
             .clone()
     }
+
+    pub(crate) async fn load_account(&self, account_id: AccountId) -> Option<GraphQLAccount> {
+        self.account_loader.try_load(account_id).await.ok()?.ok()
+    }
+
+    pub async fn fetch_delegators(
+        &self,
+        ledger_hash: LedgerHash,
+        account_id: AccountId,
+    ) -> RpcLedgerAccountDelegatorsGetResponse {
+        self.rpc_sender
+            .oneshot_request(RpcRequest::LedgerAccountDelegatorsGet(
+                ledger_hash.clone(),
+                account_id.clone(),
+            ))
+            .await
+            .flatten()
+    }
 }
 
 #[derive(Clone, Copy, Debug, GraphQLEnum)]

node/src/action_kind.rs

@@ -481,6 +481,9 @@ pub enum ActionKind {
     RpcGlobalStateGet,
     RpcHealthCheck,
     RpcHeartbeatGet,
+    RpcLedgerAccountDelegatorsGetInit,
+    RpcLedgerAccountDelegatorsGetPending,
+    RpcLedgerAccountDelegatorsGetSuccess,
     RpcLedgerAccountsGetInit,
     RpcLedgerAccountsGetPending,
     RpcLedgerAccountsGetSuccess,
@@ -536,6 +539,7 @@ pub enum ActionKind {
     RpcEffectfulGlobalStateGet,
     RpcEffectfulHealthCheck,
     RpcEffectfulHeartbeatGet,
+    RpcEffectfulLedgerAccountDelegatorsGetSuccess,
     RpcEffectfulLedgerAccountsGetSuccess,
     RpcEffectfulLedgerStatusGetSuccess,
     RpcEffectfulMessageProgressGet,
@@ -734,7 +738,7 @@ pub enum ActionKind {
 }
 
 impl ActionKind {
-    pub const COUNT: u16 = 624;
+    pub const COUNT: u16 = 628;
 }
 
 impl std::fmt::Display for ActionKind {
@@ -1110,6 +1114,15 @@ impl ActionKindGet for RpcAction {
             Self::LedgerStatusGetInit { .. } => ActionKind::RpcLedgerStatusGetInit,
             Self::LedgerStatusGetPending { .. } => ActionKind::RpcLedgerStatusGetPending,
             Self::LedgerStatusGetSuccess { .. } => ActionKind::RpcLedgerStatusGetSuccess,
+            Self::LedgerAccountDelegatorsGetInit { .. } => {
+                ActionKind::RpcLedgerAccountDelegatorsGetInit
+            }
+            Self::LedgerAccountDelegatorsGetPending { .. } => {
+                ActionKind::RpcLedgerAccountDelegatorsGetPending
+            }
+            Self::LedgerAccountDelegatorsGetSuccess { .. } => {
+                ActionKind::RpcLedgerAccountDelegatorsGetSuccess
+            }
             Self::PooledUserCommands { .. } => ActionKind::RpcPooledUserCommands,
             Self::PooledZkappCommands { .. } => ActionKind::RpcPooledZkappCommands,
             Self::GenesisBlock { .. } => ActionKind::RpcGenesisBlock,
@@ -1188,6 +1201,9 @@ impl ActionKindGet for RpcEffectfulAction {
             Self::GenesisBlock { .. } => ActionKind::RpcEffectfulGenesisBlock,
             Self::ConsensusTimeGet { .. } => ActionKind::RpcEffectfulConsensusTimeGet,
             Self::LedgerStatusGetSuccess { .. } => ActionKind::RpcEffectfulLedgerStatusGetSuccess,
+            Self::LedgerAccountDelegatorsGetSuccess { .. } => {
+                ActionKind::RpcEffectfulLedgerAccountDelegatorsGetSuccess
+            }
         }
     }
 }

node/src/event_source/event.rs

@@ -80,6 +80,9 @@ impl std::fmt::Display for Event {
                     RpcRequest::GenesisBlockGet => write!(f, "GenesisBlock"),
                     RpcRequest::ConsensusTimeGet(..) => write!(f, "ConsensusTimeGet"),
                     RpcRequest::LedgerStatusGet(..) => write!(f, "LedgerStatusGet"),
+                    RpcRequest::LedgerAccountDelegatorsGet(..) => {
+                        write!(f, "LedgerAccountDelegatorsGet")
+                    }
                 }
             }
             Self::ExternalSnarkWorker(event) => {

node/src/event_source/event_source_effects.rs

@@ -415,6 +415,13 @@ pub fn event_source_effects<S: Service>(store: &mut Store<S>, action: EventSourc
                         ledger_hash,
                     });
                 }
+                RpcRequest::LedgerAccountDelegatorsGet(ledger_hash, account_id) => {
+                    store.dispatch(RpcAction::LedgerAccountDelegatorsGetInit {
+                        rpc_id,
+                        ledger_hash,
+                        account_id,
+                    });
+                }
             },
             Event::ExternalSnarkWorker(e) => match e {
                 ExternalSnarkWorkerEvent::Started => {

node/src/ledger/ledger_manager.rs

@@ -263,6 +263,10 @@ impl LedgerRequest {
 
                         LedgerReadResponse::GetLedgerStatus(rpc_id, res)
                     }
+                    LedgerReadRequest::GetAccountDelegators(rpc_id, ledger_hash, account_id) => {
+                        let res = ledger_ctx.get_account_delegators(&ledger_hash, &account_id);
+                        LedgerReadResponse::GetAccountDelegators(rpc_id, res)
+                    }
                 },
             ),
             LedgerRequest::AccountsSet {

node/src/ledger/ledger_service.rs

@@ -522,6 +522,23 @@ impl LedgerCtx {
         Ok(())
     }
 
+    pub fn get_account_delegators(
+        &self,
+        ledger_hash: &LedgerHash,
+        account_id: &AccountId,
+    ) -> Option<Vec<Account>> {
+        let (mask, _) = self.mask(ledger_hash)?;
+        let mut accounts = Vec::new();
+
+        mask.iter(|account| {
+            if account.delegate == Some(account_id.public_key.clone()) {
+                accounts.push(account.clone());
+            }
+        });
+
+        Some(accounts)
+    }
+
     #[allow(clippy::type_complexity)]
     pub fn producers_with_delegates<F: FnMut(&CompressedPubKey) -> bool>(
         &self,

node/src/ledger/read/ledger_read_reducer.rs

@@ -205,6 +205,12 @@ impl LedgerReadState {
                     response: resp.clone(),
                 });
             }
+            (_, LedgerReadResponse::GetAccountDelegators(rpc_id, resp)) => {
+                dispatcher.push(RpcAction::LedgerAccountDelegatorsGetSuccess {
+                    rpc_id,
+                    response: resp.clone(),
+                });
+            }
         }
     }