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

.github/workflows/test.yml

@@ -117,7 +117,9 @@ jobs:
         uses: ./.github/actions/cargo-cache
 
       - name: Test
-        run: cargo test --test 'mm2_tests_main' --no-fail-fast
+        run: |
+          wget -O - https://raw.githubusercontent.com/KomodoPlatform/komodo/master/zcutil/fetch-params-alt.sh | bash
+          cargo test --test 'mm2_tests_main' --no-fail-fast
 
   # https://docs.github.com/en/actions/learn-github-actions/usage-limits-billing-and-administration#usage-limits
   # https://github.com/KomodoPlatform/atomicDEX-API/actions/runs/4419618128/jobs/7748266141#step:4:1790
@@ -161,7 +163,10 @@ jobs:
         uses: ./.github/actions/cargo-cache
 
       - name: Test
-        run: cargo test --test 'mm2_tests_main' --no-fail-fast
+        run: |
+          Invoke-WebRequest -Uri https://github.com/KomodoPlatform/komodo/raw/d456be35acd1f8584e1e4f971aea27bd0644d5c5/zcutil/wget64.exe -OutFile \wget64.exe
+          Invoke-WebRequest -Uri https://raw.githubusercontent.com/KomodoPlatform/komodo/master/zcutil/fetch-params-alt.bat -OutFile \cmd.bat && \cmd.bat
+          cargo test --test 'mm2_tests_main' --no-fail-fast
 
   docker-tests:
     timeout-minutes: 90

mm2src/coins/utxo/utxo_builder/mod.rs

@@ -5,7 +5,7 @@ mod utxo_conf_builder;
 pub use utxo_arc_builder::{MergeUtxoArcOps, UtxoArcBuilder};
 pub use utxo_coin_builder::{UtxoCoinBuildError, UtxoCoinBuildResult, UtxoCoinBuilder, UtxoCoinBuilderCommonOps,
                             UtxoFieldsWithGlobalHDBuilder, UtxoFieldsWithHardwareWalletBuilder,
-                            UtxoFieldsWithIguanaSecretBuilder};
+                            UtxoFieldsWithIguanaSecretBuilder, DAY_IN_SECONDS};
 pub use utxo_conf_builder::{UtxoConfBuilder, UtxoConfError, UtxoConfResult};
 
 #[cfg(test)]

mm2src/coins/utxo/utxo_builder/utxo_coin_builder.rs

@@ -16,7 +16,7 @@ use common::custom_futures::repeatable::{Ready, Retry};
 use common::executor::{abortable_queue::AbortableQueue, AbortSettings, AbortableSystem, AbortedError, SpawnAbortable,
                        Timer};
 use common::log::{error, info, LogOnError};
-use common::small_rng;
+use common::{now_sec, small_rng};
 use crypto::{Bip32DerPathError, CryptoCtx, CryptoCtxError, GlobalHDAccountArc, HwWalletType, Secp256k1Secret,
              StandardHDPathError, StandardHDPathToCoin};
 use derive_more::Display;
@@ -44,6 +44,8 @@ cfg_native! {
     use std::path::{Path, PathBuf};
 }
 
+pub const DAY_IN_SECONDS: u64 = 86400;
+
 pub type UtxoCoinBuildResult<T> = Result<T, MmError<UtxoCoinBuildError>>;
 
 #[derive(Debug, Display)]
@@ -85,6 +87,7 @@ pub enum UtxoCoinBuildError {
     Internal(String),
     #[display(fmt = "SPV params verificaiton failed. Error: {_0}")]
     SPVError(SPVError),
+    ErrorCalculatingStartingHeight(String),
 }
 
 impl From<UtxoConfError> for UtxoCoinBuildError {
@@ -667,6 +670,43 @@ pub trait UtxoCoinBuilderCommonOps {
 
         (None, None)
     }
+
+    /// 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.
+    ///
+    fn calculate_starting_height_from_date(&self, date: u64, current_block_height: u64) -> UtxoCoinBuildResult<u64> {
+        let avg_blocktime = self.conf()["avg_blocktime"]
+            .as_u64()
+            .ok_or_else(|| format!("avg_blocktime not specified in {} coin config", self.ticker()))
+            .map_to_mm(UtxoCoinBuildError::ErrorCalculatingStartingHeight)?;
+        let blocks_per_day = DAY_IN_SECONDS / avg_blocktime;
+        let current_time_s = now_sec();
+
+        if current_time_s < date {
+            return MmError::err(UtxoCoinBuildError::ErrorCalculatingStartingHeight(format!(
+                "{} sync date must be earlier then current date",
+                self.ticker()
+            )));
+        };
+
+        let secs_since_date = current_time_s - date;
+        let days_since_date = (secs_since_date / DAY_IN_SECONDS) - 1;
+        let blocks_to_sync = (days_since_date * blocks_per_day) + blocks_per_day;
+
+        if current_block_height < blocks_to_sync {
+            return MmError::err(UtxoCoinBuildError::ErrorCalculatingStartingHeight(format!(
+                "{} current_block_height: {current_block_height} must be greater than blocks_to_sync: {blocks_to_sync}",
+                self.ticker(),
+            )));
+        }
+
+        let block_to_sync_from = current_block_height - blocks_to_sync;
+
+        Ok(block_to_sync_from)
+    }
 }
 
 /// Attempts to parse native daemon conf file and return rpcport, rpcuser and rpcpassword

mm2src/coins/z_coin.rs

@@ -755,6 +755,12 @@ impl AsRef<UtxoCoinFields> for ZCoin {
     fn as_ref(&self) -> &UtxoCoinFields { &self.utxo_arc }
 }
 
+#[derive(Clone, Debug, Deserialize, Serialize)]
+pub enum SyncStartPoint {
+    Date(u64),
+    Height(u64),
+}
+
 #[derive(Clone, Debug, Deserialize, Serialize)]
 #[serde(tag = "rpc", content = "rpc_data")]
 pub enum ZcoinRpcMode {
@@ -763,6 +769,9 @@ 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.
+        sync_params: Option<SyncStartPoint>,
     },
 }
 
@@ -888,39 +897,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

@@ -1,11 +1,18 @@
+use crate::utxo::utxo_builder::UtxoCoinBuildError;
 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::utxo::utxo_builder::{UtxoCoinBuilderCommonOps, DAY_IN_SECONDS};
+    use crate::z_coin::{CheckPointBlockInfo, extended_spending_key_from_protocol_info_and_policy, SyncStartPoint,
+                    ZcoinConsensusParams, ZcoinRpcMode};
+    use crate::z_coin::z_rpc::{create_wallet_db, ZRpcOps};
 
+    use common::now_sec;
+    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 +28,14 @@ pub enum WalletDbError {
     ZcoinClientInitError(ZcoinClientInitError),
     ZCoinBuildError(String),
     IndexedDBError(String),
+    GrpcError(String),
+    DecodeError(String),
+    UtxoCoinBuildError(UtxoCoinBuildError),
+}
+
+#[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 +48,74 @@ pub struct WalletDbShared {
     ticker: String,
 }
 
+#[cfg(not(target_arch = "wasm32"))]
+async fn checkpoint_block_from_height(
+    height: u64,
+    rpc: &mut impl ZRpcOps,
+) -> MmResult<Option<CheckPointBlockInfo>, WalletDbError> {
+    let tree_state = rpc
+        .get_tree_state(height)
+        .await
+        .mm_err(|err| WalletDbError::GrpcError(err.to_string()))?;
+    let hash = H256::from_str(&tree_state.hash)
+        .map_err(|err| WalletDbError::DecodeError(err.to_string()))?
+        .reversed();
+    let sapling_tree = Bytes::new(
+        FromHex::from_hex(&tree_state.tree).map_err(|err: FromHexError| WalletDbError::DecodeError(err.to_string()))?,
+    );
+
+    Ok(Some(CheckPointBlockInfo {
+        height: tree_state.height as u32,
+        hash,
+        time: tree_state.time,
+        sapling_tree,
+    }))
+}
+
 #[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 current_block_height = rpc
+            .get_block_height()
+            .await
+            .map_err(|err| WalletDbError::GrpcError(err.to_string()))?;
+        let sync_block = match &zcoin_builder.z_coin_params.mode {
+            ZcoinRpcMode::Light { sync_params, .. } => {
+                let sync_height = match sync_params {
+                    Some(SyncStartPoint::Date(date)) => zcoin_builder
+                        .calculate_starting_height_from_date(*date, current_block_height)
+                        .mm_err(WalletDbError::UtxoCoinBuildError)?,
+                    Some(SyncStartPoint::Height(height)) => *height,
+                    None => zcoin_builder
+                        .calculate_starting_height_from_date(now_sec() - DAY_IN_SECONDS, current_block_height)
+                        .mm_err(WalletDbError::UtxoCoinBuildError)?,
+                };
+
+                checkpoint_block_from_height(sync_height, rpc).await?
+            },
+
+            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)),