feat: Add ledger status RPC, expand deamonStatus

Adrian Nagy · Adrian Nagy · commit 48228e2ad454 · 2025-03-24T09:10:27.000+01:00
diff --git a/node/common/src/service/rpc/mod.rs b/node/common/src/service/rpc/mod.rs
@@ -16,7 +16,7 @@ use node::rpc::{
     RpcReadinessCheckResponse, RpcRequest, RpcSnarkPoolCompletedJobsResponse,
     RpcSnarkPoolPendingJobsGetResponse, RpcStateGetError, RpcStatusGetResponse,
     RpcTransactionInjectResponse, RpcTransactionPoolResponse, RpcTransactionStatusGetResponse,
-    RpcTransitionFrontierUserCommandsResponse,
+    RpcTransitionFrontierUserCommandsResponse, RpcLedgerStatusGetResponse,
 };
 use serde::{Deserialize, Serialize};
 
@@ -326,6 +326,7 @@ 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);
 }
 
 #[cfg(test)]
diff --git a/node/native/src/graphql/constants.rs b/node/native/src/graphql/constants.rs
@@ -120,6 +120,42 @@ impl GraphQLDaemonStatus {
         }))
     }
 
+    async fn ledger_merkle_root(&self, context: &Context) -> juniper::FieldResult<Option<String>> {
+        let best_tip = context.get_or_fetch_best_tip().await;
+
+        Ok(best_tip.map(|best_tip| best_tip.merkle_root_hash().to_string()))
+        // match best_tip {
+        //     Some(best_tip) => {
+        //         println!("best_tip_ledger_merkle_root {:?}", best_tip.merkle_root_hash());
+        //         let ledger_status = context
+        //             .get_or_fetch_ledger_status(best_tip.merkle_root_hash())
+        //             .await;
+        //         Ok(ledger_status
+        //             .map(|ledger_status| ledger_status.best_tip_staged_ledger_hash.to_string()))
+        //     }
+        //     None => Ok(None),
+        // }
+    }
+
+    async fn state_hash(&self, context: &Context) -> juniper::FieldResult<Option<String>> {
+        let best_tip = context.get_or_fetch_best_tip().await;
+        Ok(best_tip.map(|best_tip| best_tip.hash().to_string()))
+    }
+
+    async fn num_accounts(&self, context: &Context) -> juniper::FieldResult<Option<i32>> {
+        let best_tip = context.get_or_fetch_best_tip().await;
+
+        match best_tip {
+            Some(best_tip) => {
+                let ledger_status = context
+                    .get_or_fetch_ledger_status(best_tip.merkle_root_hash())
+                    .await;
+                Ok(ledger_status.map(|ledger_status| ledger_status.num_accounts as i32))
+            }
+            None => Ok(None),
+        }
+    }
+
     // highestUnvalidatedBlockLengthReceived
     async fn highest_unvalidated_block_length_received(
         &self,
diff --git a/node/native/src/graphql/mod.rs b/node/native/src/graphql/mod.rs
@@ -3,16 +3,18 @@ use juniper::{graphql_value, EmptySubscription, FieldError, GraphQLEnum, RootNod
 use ledger::Account;
 use mina_p2p_messages::v2::{
     conv, MinaBaseSignedCommandStableV2, MinaBaseUserCommandStableV2,
-    MinaBaseZkappCommandTStableV1WireStableV1, TokenIdKeyHash, TransactionHash,
+    MinaBaseZkappCommandTStableV1WireStableV1, TokenIdKeyHash, TransactionHash, LedgerHash
 };
 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
+        SyncStatsQuery, RpcStatusGetResponse, RpcNodeStatus, RpcBestChainResponse,
+        RpcLedgerStatusGetResponse
     },
     stats::sync::SyncKind,
     BuildEnv,
@@ -103,6 +105,7 @@ pub(crate) struct Context {
     rpc_sender: RpcSender,
     statemachine_status_cache: OnceCell<Option<RpcNodeStatus>>,
     best_tip_cache: OnceCell<Option<AppliedBlock>>,
+    ledger_status_cache: OnceCell<Option<LedgerStatus>>,
 }
 
 impl juniper::Context for Context {}
@@ -113,6 +116,7 @@ impl Context {
             rpc_sender,
             statemachine_status_cache: OnceCell::new(),
             best_tip_cache: OnceCell::new(),
+            ledger_status_cache: OnceCell::new(),
         }
     }
 
@@ -139,6 +143,21 @@ impl Context {
             .await
             .clone()
     }
+
+    pub(crate) async fn get_or_fetch_ledger_status(
+        &self,
+        ledger_hash: &LedgerHash,
+    ) -> RpcLedgerStatusGetResponse {
+        self.ledger_status_cache
+            .get_or_init(|| async {
+                self.rpc_sender
+                    .oneshot_request(RpcRequest::LedgerStatusGet(ledger_hash.clone()))
+                    .await
+                    .flatten()
+            })
+            .await
+            .clone()
+    }
 }
 
 #[derive(Clone, Copy, Debug, GraphQLEnum)]
diff --git a/node/src/action_kind.rs b/node/src/action_kind.rs
@@ -484,6 +484,9 @@ pub enum ActionKind {
     RpcLedgerAccountsGetInit,
     RpcLedgerAccountsGetPending,
     RpcLedgerAccountsGetSuccess,
+    RpcLedgerStatusGetInit,
+    RpcLedgerStatusGetPending,
+    RpcLedgerStatusGetSuccess,
     RpcMessageProgressGet,
     RpcP2pConnectionIncomingAnswerReady,
     RpcP2pConnectionIncomingError,
@@ -534,6 +537,7 @@ pub enum ActionKind {
     RpcEffectfulHealthCheck,
     RpcEffectfulHeartbeatGet,
     RpcEffectfulLedgerAccountsGetSuccess,
+    RpcEffectfulLedgerStatusGetSuccess,
     RpcEffectfulMessageProgressGet,
     RpcEffectfulP2pConnectionIncomingError,
     RpcEffectfulP2pConnectionIncomingRespond,
@@ -730,7 +734,7 @@ pub enum ActionKind {
 }
 
 impl ActionKind {
-    pub const COUNT: u16 = 620;
+    pub const COUNT: u16 = 624;
 }
 
 impl std::fmt::Display for ActionKind {
@@ -1103,6 +1107,9 @@ impl ActionKindGet for RpcAction {
             Self::TransactionStatusGet { .. } => ActionKind::RpcTransactionStatusGet,
             Self::BlockGet { .. } => ActionKind::RpcBlockGet,
             Self::ConsensusTimeGet { .. } => ActionKind::RpcConsensusTimeGet,
+            Self::LedgerStatusGetInit { .. } => ActionKind::RpcLedgerStatusGetInit,
+            Self::LedgerStatusGetPending { .. } => ActionKind::RpcLedgerStatusGetPending,
+            Self::LedgerStatusGetSuccess { .. } => ActionKind::RpcLedgerStatusGetSuccess,
             Self::PooledUserCommands { .. } => ActionKind::RpcPooledUserCommands,
             Self::PooledZkappCommands { .. } => ActionKind::RpcPooledZkappCommands,
             Self::GenesisBlock { .. } => ActionKind::RpcGenesisBlock,
@@ -1180,6 +1187,7 @@ impl ActionKindGet for RpcEffectfulAction {
             Self::PooledZkappCommands { .. } => ActionKind::RpcEffectfulPooledZkappCommands,
             Self::GenesisBlock { .. } => ActionKind::RpcEffectfulGenesisBlock,
             Self::ConsensusTimeGet { .. } => ActionKind::RpcEffectfulConsensusTimeGet,
+            Self::LedgerStatusGetSuccess { .. } => ActionKind::RpcEffectfulLedgerStatusGetSuccess,
         }
     }
 }
diff --git a/node/src/event_source/event.rs b/node/src/event_source/event.rs
@@ -79,6 +79,7 @@ impl std::fmt::Display for Event {
                     RpcRequest::PooledZkappCommands(..) => write!(f, "PooledZkappCommands"),
                     RpcRequest::GenesisBlockGet => write!(f, "GenesisBlock"),
                     RpcRequest::ConsensusTimeGet(..) => write!(f, "ConsensusTimeGet"),
+                    RpcRequest::LedgerStatusGet(..) => write!(f, "LedgerStatusGet"),
                 }
             }
             Self::ExternalSnarkWorker(event) => {
diff --git a/node/src/event_source/event_source_effects.rs b/node/src/event_source/event_source_effects.rs
@@ -402,12 +402,19 @@ pub fn event_source_effects<S: Service>(store: &mut Store<S>, action: EventSourc
                 }
                 RpcRequest::PooledZkappCommands(query) => {
                     store.dispatch(RpcAction::PooledZkappCommands { rpc_id, query });
+                }
                 RpcRequest::ConsensusTimeGet(query) => {
                     store.dispatch(RpcAction::ConsensusTimeGet { rpc_id, query });
                 }
                 RpcRequest::GenesisBlockGet => {
                     store.dispatch(RpcAction::GenesisBlock { rpc_id });
                 }
+                RpcRequest::LedgerStatusGet(ledger_hash) => {
+                    store.dispatch(RpcAction::LedgerStatusGetInit {
+                        rpc_id,
+                        ledger_hash,
+                    });
+                }
             },
             Event::ExternalSnarkWorker(e) => match e {
                 ExternalSnarkWorkerEvent::Started => {
diff --git a/node/src/ledger/ledger_manager.rs b/node/src/ledger/ledger_manager.rs
@@ -1,7 +1,7 @@
 use super::{
-    read::{LedgerReadId, LedgerReadRequest, LedgerReadResponse},
+    read::{LedgerReadId, LedgerReadRequest, LedgerReadResponse, LedgerStatus},
     write::{LedgerWriteRequest, LedgerWriteResponse},
-    {LedgerCtx, LedgerService},
+    LedgerCtx, LedgerService,
 };
 use crate::{
     account::AccountPublicKey, ledger::LedgerAddress, rpc::AccountQuery,
@@ -250,6 +250,16 @@ impl LedgerRequest {
 
                         LedgerReadResponse::AccountsForRpc(rpc_id, res, account_query)
                     }
+                    LedgerReadRequest::GetLedgerStatus(rpc_id, ledger_hash) => {
+                        let res = ledger_ctx.get_num_accounts(ledger_hash).map(
+                            |(num_accounts, ledger_hash)| LedgerStatus {
+                                num_accounts,
+                                best_tip_staged_ledger_hash: ledger_hash,
+                            },
+                        );
+
+                        LedgerReadResponse::GetLedgerStatus(rpc_id, res)
+                    }
                 },
             ),
             LedgerRequest::AccountsSet {
diff --git a/node/src/ledger/read/ledger_read_reducer.rs b/node/src/ledger/read/ledger_read_reducer.rs
@@ -199,6 +199,12 @@ impl LedgerReadState {
                     account_query,
                 });
             }
+            (_, LedgerReadResponse::GetLedgerStatus(rpc_id, resp)) => {
+                dispatcher.push(RpcAction::LedgerStatusGetSuccess {
+                    rpc_id,
+                    response: resp.clone(),
+                });
+            }
         }
     }
 
diff --git a/node/src/ledger/read/mod.rs b/node/src/ledger/read/mod.rs
@@ -34,6 +34,7 @@ pub enum LedgerReadKind {
     GetStagedLedgerAuxAndPendingCoinbases,
     ScanStateSummary,
     AccountsForRpc,
+    GetLedgerStatus,
 }
 
 #[derive(Serialize, Deserialize, Debug, PartialEq, Clone)]
@@ -49,6 +50,13 @@ pub enum LedgerReadRequest {
     // rpcs
     ScanStateSummary(v2::MinaBaseStagedLedgerHashStableV1),
     AccountsForRpc(RpcId, v2::LedgerHash, AccountQuery),
+    GetLedgerStatus(RpcId, v2::LedgerHash),
+}
+
+#[derive(Serialize, Deserialize, Debug, PartialEq, Clone)]
+pub struct LedgerStatus {
+    pub num_accounts: u64,
+    pub best_tip_staged_ledger_hash: v2::LedgerHash,
 }
 
 #[derive(Serialize, Deserialize, Debug, Clone)]
@@ -64,6 +72,7 @@ pub enum LedgerReadResponse {
     // rpcs
     ScanStateSummary(Result<Vec<Vec<RpcScanStateSummaryScanStateJob>>, String>),
     AccountsForRpc(RpcId, Vec<Account>, AccountQuery),
+    GetLedgerStatus(RpcId, Option<LedgerStatus>),
 }
 
 #[derive(Serialize, Deserialize, Debug, Clone)]
@@ -85,6 +94,7 @@ impl LedgerReadRequest {
             }
             Self::ScanStateSummary(..) => LedgerReadKind::ScanStateSummary,
             Self::AccountsForRpc(..) => LedgerReadKind::AccountsForRpc,
+            Self::GetLedgerStatus(..) => LedgerReadKind::GetLedgerStatus,
         }
     }
 
@@ -103,6 +113,7 @@ impl LedgerReadRequest {
             Self::ScanStateSummary(..) => 100,
             // TODO(adonagy): not sure
             Self::AccountsForRpc(..) => 10,
+            Self::GetLedgerStatus(..) => 1,
         };
         cost.max(1)
     }
@@ -121,6 +132,7 @@ impl LedgerReadResponse {
             }
             Self::ScanStateSummary(..) => LedgerReadKind::ScanStateSummary,
             Self::AccountsForRpc(..) => LedgerReadKind::AccountsForRpc,
+            Self::GetLedgerStatus(..) => LedgerReadKind::GetLedgerStatus,
         }
     }
 }
@@ -145,5 +157,9 @@ pub enum LedgerReadInitCallback {
         callback: Callback<(bool, P2pRpcId, PeerId)>,
         args: (bool, P2pRpcId, PeerId),
     },
+    RpcLedgerStatusGetPending {
+        callback: Callback<RequestId<RpcIdType>>,
+        args: RequestId<RpcIdType>,
+    },
     None,
 }
diff --git a/node/src/ledger_effectful/ledger_effectful_effects.rs b/node/src/ledger_effectful/ledger_effectful_effects.rs
@@ -43,6 +43,9 @@ pub fn ledger_effectful_effects<S>(
                 LedgerReadInitCallback::P2pChannelsResponsePending { callback, args } => {
                     store.dispatch_callback(callback, args);
                 }
+                LedgerReadInitCallback::RpcLedgerStatusGetPending { callback, args } => {
+                    store.dispatch_callback(callback, args);
+                }
                 LedgerReadInitCallback::None => {}
             }
         }
diff --git a/node/src/rpc/mod.rs b/node/src/rpc/mod.rs
@@ -13,6 +13,7 @@ use mina_p2p_messages::v2::{
     MinaBaseSignedCommandPayloadBodyStableV2, MinaBaseSignedCommandStableV2,
     MinaBaseTransactionStatusStableV2, MinaBaseUserCommandStableV2,
     MinaBaseZkappCommandTStableV1WireStableV1, MinaTransactionTransactionStableV2,
+    LedgerHash, 
     SnarkWorkerWorkerRpcsVersionedGetWorkV2TResponse, StateHash, TransactionHash,
     TransactionSnarkWorkTStableV2,
 };
@@ -45,7 +46,7 @@ use serde::{Deserialize, Serialize};
 use crate::external_snark_worker::{
     ExternalSnarkWorkerError, ExternalSnarkWorkerWorkError, SnarkWorkSpecError,
 };
-use crate::ledger::read::{LedgerReadId, LedgerReadKind};
+use crate::ledger::read::{LedgerReadId, LedgerReadKind, LedgerStatus};
 use crate::ledger::write::LedgerWriteKind;
 use crate::p2p::connection::incoming::P2pConnectionIncomingInitOpts;
 use crate::p2p::connection::outgoing::P2pConnectionOutgoingInitOpts;
@@ -95,6 +96,7 @@ pub enum RpcRequest {
     PooledZkappCommands(PooledZkappsCommandsQuery),
     GenesisBlockGet,
     ConsensusTimeGet(ConsensusTimeQuery),
+    LedgerStatusGet(LedgerHash),
 }
 
 #[derive(Serialize, Deserialize, Debug, Clone)]
@@ -387,6 +389,7 @@ pub type RpcPooledUserCommandsResponse = Vec<MinaBaseSignedCommandStableV2>;
 pub type RpcPooledZkappCommandsResponse = Vec<MinaBaseZkappCommandTStableV1WireStableV1>;
 pub type RpcGenesisBlockResponse = Option<ArcBlockWithHash>;
 pub type RpcConsensusTimeGetResponse = Option<ConsensusTime>;
+pub type RpcLedgerStatusGetResponse = Option<LedgerStatus>;
 
 #[derive(Serialize, Deserialize, Debug, Clone, strum_macros::Display)]
 #[strum(serialize_all = "SCREAMING_SNAKE_CASE")]
diff --git a/node/src/rpc/rpc_actions.rs b/node/src/rpc/rpc_actions.rs
@@ -1,7 +1,7 @@
 use ledger::transaction_pool::{diff, ValidCommandWithHash};
 use ledger::Account;
-use mina_p2p_messages::v2::MinaBaseUserCommandStableV2;
 use mina_p2p_messages::v2::TokenIdKeyHash;
+use mina_p2p_messages::v2::{LedgerHash, MinaBaseUserCommandStableV2};
 use openmina_core::block::AppliedBlock;
 use openmina_core::snark::SnarkJobId;
 use openmina_core::ActionEvent;
@@ -17,6 +17,7 @@ use crate::p2p::connection::P2pConnectionResponse;
 use super::{
     ActionStatsQuery, GetBlockQuery, PooledUserCommandsQuery, PooledZkappsCommandsQuery, RpcId,
     RpcScanStateSummaryGetQuery, RpcScanStateSummaryScanStateJob, SyncStatsQuery, ConsensusTimeQuery,
+    RpcLedgerStatusGetResponse,
 };
 
 #[derive(Serialize, Deserialize, Debug, Clone, ActionEvent)]
@@ -219,6 +220,17 @@ pub enum RpcAction {
         rpc_id: RpcId,
         query: ConsensusTimeQuery,
     },
+    LedgerStatusGetInit {
+        rpc_id: RpcId,
+        ledger_hash: LedgerHash,
+    },
+    LedgerStatusGetPending {
+        rpc_id: RpcId,
+    },
+    LedgerStatusGetSuccess {
+        rpc_id: RpcId,
+        response: RpcLedgerStatusGetResponse,
+    },
 
     PooledUserCommands {
         rpc_id: RpcId,
@@ -370,6 +382,17 @@ impl redux::EnablingCondition<crate::State> for RpcAction {
             RpcAction::TransitionFrontierUserCommandsGet { .. } => true,
             RpcAction::BlockGet { .. } => true,
             RpcAction::ConsensusTimeGet { .. } => true,
+            RpcAction::LedgerStatusGetInit { .. } => state.transition_frontier.best_tip().is_some(),
+            RpcAction::LedgerStatusGetPending { rpc_id } => state
+                .rpc
+                .requests
+                .get(rpc_id)
+                .is_some_and(|v| v.status.is_init()),
+            RpcAction::LedgerStatusGetSuccess { rpc_id, .. } => state
+                .rpc
+                .requests
+                .get(rpc_id)
+                .is_some_and(|v| v.status.is_pending()),
             RpcAction::Finish { rpc_id } => state
                 .rpc
                 .requests
diff --git a/node/src/rpc/rpc_reducer.rs b/node/src/rpc/rpc_reducer.rs
diff --git a/node/src/rpc_effectful/rpc_effectful_action.rs b/node/src/rpc_effectful/rpc_effectful_action.rs
diff --git a/node/src/rpc_effectful/rpc_effectful_effects.rs b/node/src/rpc_effectful/rpc_effectful_effects.rs
diff --git a/node/src/rpc_effectful/rpc_service.rs b/node/src/rpc_effectful/rpc_service.rs
diff --git a/node/testing/src/service/rpc_service.rs b/node/testing/src/service/rpc_service.rs

Original file line number	Diff line number	Diff line change
`@@ -79,6 +79,7 @@ impl std::fmt::Display for Event {`
`79`	`79`	`RpcRequest::PooledZkappCommands(..) => write!(f, "PooledZkappCommands"),`
`80`	`80`	`RpcRequest::GenesisBlockGet => write!(f, "GenesisBlock"),`
`81`	`81`	`RpcRequest::ConsensusTimeGet(..) => write!(f, "ConsensusTimeGet"),`
	`82`	`+ RpcRequest::LedgerStatusGet(..) => write!(f, "LedgerStatusGet"),`
`82`	`83`	`}`
`83`	`84`	`}`
`84`	`85`	`Self::ExternalSnarkWorker(event) => {`
Original file line number	Diff line number	Diff line change
`@@ -199,6 +199,12 @@ impl LedgerReadState {`
`199`	`199`	`account_query,`
`200`	`200`	`});`
`201`	`201`	`}`
	`202`	`+ (_, LedgerReadResponse::GetLedgerStatus(rpc_id, resp)) => {`
	`203`	`+ dispatcher.push(RpcAction::LedgerStatusGetSuccess {`
	`204`	`+ rpc_id,`
	`205`	`+ response: resp.clone(),`
	`206`	`+ });`
	`207`	`+ }`
`202`	`208`	`}`
`203`	`209`	`}`
`204`	`210`
Original file line number	Diff line number	Diff line change
`@@ -34,6 +34,7 @@ pub enum LedgerReadKind {`
`34`	`34`	`GetStagedLedgerAuxAndPendingCoinbases,`
`35`	`35`	`ScanStateSummary,`
`36`	`36`	`AccountsForRpc,`
	`37`	`+ GetLedgerStatus,`
`37`	`38`	`}`
`38`	`39`
`39`	`40`	`#[derive(Serialize, Deserialize, Debug, PartialEq, Clone)]`
`@@ -49,6 +50,13 @@ pub enum LedgerReadRequest {`
`49`	`50`	`// rpcs`
`50`	`51`	`ScanStateSummary(v2::MinaBaseStagedLedgerHashStableV1),`
`51`	`52`	`AccountsForRpc(RpcId, v2::LedgerHash, AccountQuery),`
	`53`	`+ GetLedgerStatus(RpcId, v2::LedgerHash),`
	`54`	`+}`
	`55`	`+`
	`56`	`+#[derive(Serialize, Deserialize, Debug, PartialEq, Clone)]`
	`57`	`+pub struct LedgerStatus {`
	`58`	`+ pub num_accounts: u64,`
	`59`	`+ pub best_tip_staged_ledger_hash: v2::LedgerHash,`
`52`	`60`	`}`
`53`	`61`
`54`	`62`	`#[derive(Serialize, Deserialize, Debug, Clone)]`
`@@ -64,6 +72,7 @@ pub enum LedgerReadResponse {`
`64`	`72`	`// rpcs`
`65`	`73`	`ScanStateSummary(Result<Vec<Vec<RpcScanStateSummaryScanStateJob>>, String>),`
`66`	`74`	`AccountsForRpc(RpcId, Vec<Account>, AccountQuery),`
	`75`	`+ GetLedgerStatus(RpcId, Option<LedgerStatus>),`
`67`	`76`	`}`
`68`	`77`
`69`	`78`	`#[derive(Serialize, Deserialize, Debug, Clone)]`
`@@ -85,6 +94,7 @@ impl LedgerReadRequest {`
`85`	`94`	`}`
`86`	`95`	`Self::ScanStateSummary(..) => LedgerReadKind::ScanStateSummary,`
`87`	`96`	`Self::AccountsForRpc(..) => LedgerReadKind::AccountsForRpc,`
	`97`	`+ Self::GetLedgerStatus(..) => LedgerReadKind::GetLedgerStatus,`
`88`	`98`	`}`
`89`	`99`	`}`
`90`	`100`
`@@ -103,6 +113,7 @@ impl LedgerReadRequest {`
`103`	`113`	`Self::ScanStateSummary(..) => 100,`
`104`	`114`	`// TODO(adonagy): not sure`
`105`	`115`	`Self::AccountsForRpc(..) => 10,`
	`116`	`+ Self::GetLedgerStatus(..) => 1,`
`106`	`117`	`};`
`107`	`118`	`cost.max(1)`
`108`	`119`	`}`
`@@ -121,6 +132,7 @@ impl LedgerReadResponse {`
`121`	`132`	`}`
`122`	`133`	`Self::ScanStateSummary(..) => LedgerReadKind::ScanStateSummary,`
`123`	`134`	`Self::AccountsForRpc(..) => LedgerReadKind::AccountsForRpc,`
	`135`	`+ Self::GetLedgerStatus(..) => LedgerReadKind::GetLedgerStatus,`
`124`	`136`	`}`
`125`	`137`	`}`
`126`	`138`	`}`
`@@ -145,5 +157,9 @@ pub enum LedgerReadInitCallback {`
`145`	`157`	`callback: Callback<(bool, P2pRpcId, PeerId)>,`
`146`	`158`	`args: (bool, P2pRpcId, PeerId),`
`147`	`159`	`},`
	`160`	`+ RpcLedgerStatusGetPending {`
	`161`	`+ callback: Callback<RequestId<RpcIdType>>,`
	`162`	`+ args: RequestId<RpcIdType>,`
	`163`	`+ },`
`148`	`164`	`None,`
`149`	`165`	`}`
Original file line number	Diff line number	Diff line change
`@@ -43,6 +43,9 @@ pub fn ledger_effectful_effects<S>(`
`43`	`43`	`LedgerReadInitCallback::P2pChannelsResponsePending { callback, args } => {`
`44`	`44`	`store.dispatch_callback(callback, args);`
`45`	`45`	`}`
	`46`	`+ LedgerReadInitCallback::RpcLedgerStatusGetPending { callback, args } => {`
	`47`	`+ store.dispatch_callback(callback, args);`
	`48`	`+ }`
`46`	`49`	`LedgerReadInitCallback::None => {}`
`47`	`50`	`}`
`48`	`51`	`}`