rpc: Add getwalletstatus

Closes #316.

Author: str4d

zallet/src/components/json_rpc/methods.rs

@@ -29,6 +29,7 @@ mod get_operation;
 mod get_raw_transaction;
 #[cfg(zallet_build = "wallet")]
 mod get_wallet_info;
+mod get_wallet_status;
 #[cfg(zallet_build = "wallet")]
 mod help;
 mod list_accounts;
@@ -57,6 +58,10 @@ mod z_send_many;
 /// The general JSON-RPC interface, containing the methods provided in all Zallet builds.
 #[rpc(server)]
 pub(crate) trait Rpc {
+    /// Returns wallet status information.
+    #[method(name = "getwalletstatus")]
+    async fn get_wallet_status(&self) -> get_wallet_status::Response;
+
     /// Returns the list of accounts created with `z_getnewaccount` or `z_recoveraccounts`.
     ///
     /// # Arguments
@@ -551,6 +556,10 @@ impl WalletRpcImpl {
 
 #[async_trait]
 impl RpcServer for RpcImpl {
+    async fn get_wallet_status(&self) -> get_wallet_status::Response {
+        get_wallet_status::call(self.wallet().await?.as_ref(), self.chain().await?).await
+    }
+
     async fn list_accounts(&self, include_addresses: Option<bool>) -> list_accounts::Response {
         list_accounts::call(self.wallet().await?.as_ref(), include_addresses)
     }

zallet/src/components/json_rpc/methods/get_wallet_status.rs

@@ -0,0 +1,165 @@
+use documented::Documented;
+use jsonrpsee::core::RpcResult;
+use rand::rngs::OsRng;
+use schemars::JsonSchema;
+use serde::Serialize;
+use zaino_state::{FetchServiceSubscriber, LightWalletIndexer};
+use zcash_client_backend::data_api::{
+    BlockMetadata, WalletRead, WalletSummary, scanning::ScanRange, wallet::ConfirmationsPolicy,
+};
+use zcash_client_sqlite::{AccountUuid, WalletDb, error::SqliteClientError, util::SystemClock};
+use zcash_primitives::block::BlockHash;
+
+use crate::{
+    components::{database::DbConnection, json_rpc::server::LegacyCode},
+    network::Network,
+};
+
+/// Response to a `getwalletstatus` RPC request.
+pub(crate) type Response = RpcResult<ResultType>;
+pub(crate) type ResultType = GetWalletStatus;
+
+/// The wallet status information.
+#[derive(Clone, Debug, Serialize, Documented, JsonSchema)]
+pub(crate) struct GetWalletStatus {
+    /// The backing full node's view of the chain tip.
+    node_tip: ChainTip,
+
+    /// The wallet's view of the chain tip.
+    ///
+    /// This should only diverge from `node_tip` for very short periods of time.
+    ///
+    /// Omitted if the wallet has just been started for the first time and has not yet
+    /// begun syncing.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    wallet_tip: Option<ChainTip>,
+
+    /// The height to which the wallet is fully synced.
+    ///
+    /// The wallet only has a partial view of chain data above this height.
+    ///
+    /// Omitted if the wallet does not have any accounts or birthday data and thus has
+    /// nowhere to sync from.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    fully_synced_height: Option<u32>,
+
+    /// The height up to which the wallet has full information.
+    ///
+    /// Omitted if the wallet is fully synced (which requires that `fully_synced_height`
+    /// is equal to `wallet_tip.height`).
+    #[serde(skip_serializing_if = "Option::is_none")]
+    sync_work_remaining: Option<SyncWorkRemaining>,
+}
+
+#[derive(Clone, Debug, Serialize, JsonSchema)]
+struct ChainTip {
+    /// The hash of the block at the chain tip.
+    blockhash: String,
+
+    /// The height of the block in the chain.
+    height: u32,
+}
+
+#[derive(Clone, Debug, Serialize, JsonSchema)]
+struct SyncWorkRemaining {
+    unscanned_blocks: u32,
+
+    // TODO: Replace these with accurate unscanned note counts, which we can determine
+    // because Zallet tracks the chain tip very closely.
+    progress_numerator: u64,
+    progress_denominator: u64,
+}
+
+pub(crate) async fn call(wallet: &DbConnection, chain: FetchServiceSubscriber) -> Response {
+    let node_tip = chain
+        .get_latest_block()
+        .await
+        // TODO: Better error.
+        .map_err(|e| LegacyCode::Database.with_message(e.to_string()))?;
+
+    let (wallet_tip, block_fully_scanned, scan_ranges, wallet_summary) =
+        wallet
+            .with(wallet_data)
+            .map_err(|e| LegacyCode::Database.with_message(e.to_string()))?;
+
+    let sync_work_remaining = wallet_summary.and_then(|s| {
+        let unscanned_blocks = scan_ranges
+            .iter()
+            .map(|r| r.block_range().end - r.block_range().start)
+            .sum::<u32>();
+
+        let (progress_numerator, progress_denominator) =
+            if let Some(recovery) = s.progress().recovery() {
+                (
+                    s.progress().scan().numerator() + recovery.numerator(),
+                    s.progress().scan().denominator() + recovery.denominator(),
+                )
+            } else {
+                (
+                    *s.progress().scan().numerator(),
+                    *s.progress().scan().denominator(),
+                )
+            };
+
+        if unscanned_blocks == 0 && progress_numerator == progress_denominator {
+            None
+        } else {
+            Some(SyncWorkRemaining {
+                unscanned_blocks,
+                progress_numerator,
+                progress_denominator,
+            })
+        }
+    });
+
+    Ok(GetWalletStatus {
+        node_tip: ChainTip {
+            blockhash: BlockHash::try_from_slice(node_tip.hash.as_slice())
+                .expect("block hash missing")
+                .to_string(),
+            height: u32::try_from(node_tip.height)
+                // TODO: Better error.
+                .map_err(|e| LegacyCode::Database.with_message(e.to_string()))?,
+        },
+        wallet_tip,
+        fully_synced_height: block_fully_scanned.map(|b| b.block_height().into()),
+        sync_work_remaining,
+    })
+}
+
+fn wallet_data(
+    wallet: WalletDb<&rusqlite::Connection, Network, SystemClock, OsRng>,
+) -> Result<
+    (
+        Option<ChainTip>,
+        Option<BlockMetadata>,
+        Vec<ScanRange>,
+        Option<WalletSummary<AccountUuid>>,
+    ),
+    SqliteClientError,
+> {
+    let tip_height = wallet.chain_height()?;
+    let tip_hash = if let Some(block_height) = tip_height {
+        wallet.get_block_hash(block_height)?
+    } else {
+        None
+    };
+
+    if let Some((tip_hash, tip_height)) = tip_hash.zip(tip_height) {
+        let block_fully_scanned = wallet.block_fully_scanned()?;
+        let scan_ranges = wallet.suggest_scan_ranges()?;
+        let summary = wallet.get_wallet_summary(ConfirmationsPolicy::MIN)?;
+
+        Ok((
+            Some(ChainTip {
+                blockhash: tip_hash.to_string(),
+                height: tip_height.into(),
+            }),
+            block_fully_scanned,
+            scan_ranges,
+            summary,
+        ))
+    } else {
+        Ok((None, None, vec![], None))
+    }
+}