feat(zcoin): allow ARRR to sync using a start date

mm2src/coins/z_coin.rs

@@ -96,6 +96,9 @@ cfg_native!(
     use zcash_primitives::transaction::builder::Builder as ZTxBuilder;
     use zcash_proofs::default_params_folder;
     use z_rpc::{init_native_client};
+
+    pub mod z_rpc_methods;
+    use crate::z_coin::z_rpc_methods::{GetMinimumHeightError, GetMinimumHeightResponse};
 );
 
 #[allow(unused)] mod z_coin_errors;
@@ -749,12 +752,46 @@ impl ZCoin {
             paging_options: request.paging_options,
         })
     }
+
+    #[cfg(not(target_arch = "wasm32"))]
+    pub async fn get_minimum_header_from_cache(&self) -> MmResult<GetMinimumHeightResponse, GetMinimumHeightError> {
+        let sync = self
+            .sync_status()
+            .await
+            .map_err(|err| GetMinimumHeightError::TemporaryError(err.to_string()))?;
+        let wallet_db = self.z_fields.light_wallet_db.db.lock();
+        let extrema = wallet_db
+            .block_height_extrema()
+            .map_to_mm(|err| GetMinimumHeightError::StorageError(err.to_string()))?;
+
+        match sync {
+            SyncStatus::UpdatingBlocksCache { .. } => MmError::err(GetMinimumHeightError::UpdatingBlocksCache(
+                "Blocks cache still bulding, try again later".to_string(),
+            )),
+            SyncStatus::BuildingWalletDb { .. } => MmError::err(GetMinimumHeightError::BuildingWalletDb(
+                "Wallets cache still bulding, try again later".to_string(),
+            )),
+            SyncStatus::TemporaryError(_) => MmError::err(GetMinimumHeightError::TemporaryError(
+                "Temporary error occured".to_string(),
+            )),
+            SyncStatus::Finished { .. } => Ok(GetMinimumHeightResponse {
+                height: extrema.map(|(min, _max)| min.into()),
+                status: "Finished".to_string(),
+            }),
+        }
+    }
 }
 
 impl AsRef<UtxoCoinFields> for ZCoin {
     fn as_ref(&self) -> &UtxoCoinFields { &self.utxo_arc }
 }
 
+#[derive(Clone, Debug, Deserialize, Serialize)]
+pub struct LightWalletSyncParams {
+    pub date: Option<u32>,
+    pub height: Option<u32>,
+}
+
 #[derive(Clone, Debug, Deserialize, Serialize)]
 #[serde(tag = "rpc", content = "rpc_data")]
 pub enum ZcoinRpcMode {
@@ -763,6 +800,14 @@ pub enum ZcoinRpcMode {
     Light {
         electrum_servers: Vec<ElectrumRpcRequest>,
         light_wallet_d_servers: Vec<String>,
+        /// Specifies the parameters for synchronizing the wallet from a specific block. This overrides the
+        /// `CheckPointBlockInfo` configuration in the coin settings.
+        ///
+        /// # Note:
+        /// The `LightWalletSyncParams.date` field takes the highest priority, overriding both the
+        /// `LightWalletSyncParams.height` and `CheckPointBlockInfo` if specified. Followed by `LightWalletSyncParams
+        /// .height`.
+        sync_params: Option<LightWalletSyncParams>,
     },
 }
 
@@ -888,39 +933,15 @@ impl<'a> UtxoCoinBuilder for ZCoinBuilder<'a> {
         );
 
         let blocks_db = self.blocks_db().await?;
-        let wallet_db = WalletDbShared::new(&self)
-            .await
-            .map_err(|err| ZCoinBuildError::ZcashDBError(err.to_string()))?;
-
         let (sync_state_connector, light_wallet_db) = match &self.z_coin_params.mode {
             #[cfg(not(target_arch = "wasm32"))]
             ZcoinRpcMode::Native => {
                 let native_client = self.native_client()?;
-                init_native_client(
-                    self.ticker.into(),
-                    native_client,
-                    blocks_db,
-                    wallet_db,
-                    self.protocol_info.consensus_params.clone(),
-                    self.z_coin_params.scan_blocks_per_iteration,
-                    self.z_coin_params.scan_interval_ms,
-                )
-                .await?
+                init_native_client(&self, native_client, blocks_db).await?
             },
             ZcoinRpcMode::Light {
                 light_wallet_d_servers, ..
-            } => {
-                init_light_client(
-                    self.ticker.into(),
-                    light_wallet_d_servers.clone(),
-                    blocks_db,
-                    wallet_db,
-                    self.protocol_info.consensus_params.clone(),
-                    self.z_coin_params.scan_blocks_per_iteration,
-                    self.z_coin_params.scan_interval_ms,
-                )
-                .await?
-            },
+            } => init_light_client(&self, light_wallet_d_servers.clone(), blocks_db).await?,
         };
         let z_fields = ZCoinFields {
             dex_fee_addr,

mm2src/coins/z_coin/storage/walletdb/mod.rs

@@ -2,10 +2,16 @@ use crate::z_coin::{ZCoinBuilder, ZcoinClientInitError};
 use mm2_err_handle::prelude::*;
 
 cfg_native!(
-    use crate::z_coin::{extended_spending_key_from_protocol_info_and_policy, ZcoinConsensusParams};
-    use crate::z_coin::z_rpc::create_wallet_db;
+    use crate::z_coin::{CheckPointBlockInfo, extended_spending_key_from_protocol_info_and_policy, ZcoinConsensusParams,
+                    ZcoinRpcMode};
+    use crate::z_coin::z_rpc::{create_wallet_db, ZRpcOps};
 
+    use common::now_sec;
+    use common::log::info;
+    use hex::{FromHex, FromHexError};
     use parking_lot::Mutex;
+    use rpc::v1::types::{Bytes, H256};
+    use std::str::FromStr;
     use std::sync::Arc;
     use zcash_client_sqlite::WalletDb;
     use zcash_primitives::zip32::ExtendedFullViewingKey;
@@ -21,6 +27,13 @@ pub enum WalletDbError {
     ZcoinClientInitError(ZcoinClientInitError),
     ZCoinBuildError(String),
     IndexedDBError(String),
+    GrpcError(String),
+    DecodeError(String),
+}
+
+#[cfg(not(target_arch = "wasm32"))]
+impl From<tonic::Status> for WalletDbError {
+    fn from(err: tonic::Status) -> Self { WalletDbError::GrpcError(err.to_string()) }
 }
 
 #[derive(Clone)]
@@ -33,27 +46,115 @@ pub struct WalletDbShared {
     ticker: String,
 }
 
+/// Calculates the starting block height based on a given date and the current block height.
+///
+/// # Arguments
+/// * `date`: The date in seconds representing the desired starting date.
+/// * `current_block_height`: The current block height at the time of calculation.
+///
+#[cfg(not(target_arch = "wasm32"))]
+fn calculate_starting_height_from_date(date: u32, current_block_height: u64) -> Result<u32, String> {
+    let blocks_prod_per_day = 24 * 60;
+    let current_time_s = now_sec();
+
+    let date = date as u64;
+    if current_time_s < date {
+        return Err("sync_param_date must be earlier then current date".to_string());
+    };
+
+    let secs_since_date = current_time_s - date;
+    let days_since_date = (secs_since_date / 86400) - 1;
+    let blocks_to_sync = (days_since_date * blocks_prod_per_day) + blocks_prod_per_day;
+    let block_to_sync_from = current_block_height - blocks_to_sync;
+
+    Ok(block_to_sync_from as u32)
+}
+
 #[cfg(not(target_arch = "wasm32"))]
 impl<'a> WalletDbShared {
-    pub async fn new(zcoin_builder: &ZCoinBuilder<'a>) -> MmResult<Self, WalletDbError> {
+    pub async fn new(zcoin_builder: &ZCoinBuilder<'a>, rpc: &mut impl ZRpcOps) -> MmResult<Self, WalletDbError> {
         let z_spending_key = match zcoin_builder.z_spending_key {
             Some(ref z_spending_key) => z_spending_key.clone(),
             None => extended_spending_key_from_protocol_info_and_policy(
                 &zcoin_builder.protocol_info,
                 &zcoin_builder.priv_key_policy,
             )
-            .map_err(|err| WalletDbError::ZCoinBuildError(err.to_string()))?,
+            .mm_err(|err| WalletDbError::ZCoinBuildError(err.to_string()))?,
+        };
+
+        let sync_block = match zcoin_builder.z_coin_params.mode.clone() {
+            ZcoinRpcMode::Light { sync_params, .. } => {
+                let sync_height = match sync_params {
+                    Some(params) => {
+                        if let Some(date) = params.date {
+                            let current_block_height = rpc
+                                .get_block_height()
+                                .await
+                                .map_err(|err| WalletDbError::GrpcError(err.to_string()))?;
+
+                            let starting_height = calculate_starting_height_from_date(date, current_block_height)
+                                .map_err(|err| {
+                                    WalletDbError::ZcoinClientInitError(ZcoinClientInitError::ZcashDBError(err))
+                                })?;
+
+                            info!(
+                        "Found date in sync params for {}. Walletdb will be built using block height {} as the \
+                        starting \
+                        block for scanning and updating walletdb",
+                        zcoin_builder.ticker, starting_height
+                    );
+                            Some(starting_height)
+                        } else {
+                            if params.height.is_some() {
+                                info!(
+                            "Found height in sync params for {}. Walletdb will be built using block height {:?} as the \
+                            starting block for scanning and updating walletdb",
+                            zcoin_builder.ticker, params.height
+                        );
+                            }
+                            params.height
+                        }
+                    },
+                    None => None,
+                };
+
+                match sync_height {
+                    Some(height) => {
+                        let block = rpc
+                            .get_tree_state(height)
+                            .await
+                            .map_err(|err| WalletDbError::GrpcError(err.to_string()))?;
+                        let hash = H256::from_str(&block.hash)
+                            .map_err(|err| WalletDbError::DecodeError(err.to_string()))?
+                            .reversed();
+                        let sapling_tree = Bytes::new(
+                            FromHex::from_hex(&block.tree)
+                                .map_err(|err: FromHexError| WalletDbError::DecodeError(err.to_string()))?,
+                        );
+
+                        Some(CheckPointBlockInfo {
+                            height: block.height as u32,
+                            hash,
+                            time: block.time,
+                            sapling_tree,
+                        })
+                    },
+                    None => zcoin_builder.protocol_info.check_point_block.clone(),
+                }
+            },
+            ZcoinRpcMode::Native => zcoin_builder.protocol_info.check_point_block.clone(),
         };
+
         let wallet_db = create_wallet_db(
             zcoin_builder
                 .db_dir_path
                 .join(format!("{}_wallet.db", zcoin_builder.ticker)),
             zcoin_builder.protocol_info.consensus_params.clone(),
-            zcoin_builder.protocol_info.check_point_block.clone(),
+            sync_block,
             ExtendedFullViewingKey::from(&z_spending_key),
         )
         .await
-        .map_err(|err| MmError::new(WalletDbError::ZcoinClientInitError(err.into_inner())))?;
+        .mm_err(WalletDbError::ZcoinClientInitError)?;
 
         Ok(Self {
             db: Arc::new(Mutex::new(wallet_db)),

mm2src/coins/z_coin/z_coin_errors.rs

@@ -279,3 +279,29 @@ pub enum SpendableNotesError {
 
 #[derive(Debug, Display)]
 pub enum ZCoinBalanceError {}
+
+#[derive(Debug, Display)]
+pub enum ZcoinRpcError {
+    #[cfg(not(target_arch = "wasm32"))]
+    GrpcError(tonic::Status),
+    UtxoRpcError(UtxoRpcError),
+    JsonRpcError(JsonRpcError),
+    UpdateBlocksCacheErr(UpdateBlocksCacheErr),
+}
+
+#[cfg(not(target_arch = "wasm32"))]
+impl From<tonic::Status> for ZcoinRpcError {
+    fn from(err: tonic::Status) -> Self { Self::GrpcError(err) }
+}
+
+impl From<UtxoRpcError> for ZcoinRpcError {
+    fn from(err: UtxoRpcError) -> Self { ZcoinRpcError::UtxoRpcError(err) }
+}
+
+impl From<JsonRpcError> for ZcoinRpcError {
+    fn from(err: JsonRpcError) -> Self { ZcoinRpcError::JsonRpcError(err) }
+}
+
+impl From<UpdateBlocksCacheErr> for ZcoinRpcError {
+    fn from(err: UpdateBlocksCacheErr) -> Self { ZcoinRpcError::UpdateBlocksCacheErr(err) }
+}