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,44 @@ 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_s: u64,
+        current_block_height: u64,
+    ) -> UtxoCoinBuildResult<Option<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_s {
+            return MmError::err(UtxoCoinBuildError::ErrorCalculatingStartingHeight(format!(
+                "{} sync date must be earlier then current date",
+                self.ticker()
+            )));
+        };
+
+        let secs_since_date = current_time_s - date_s;
+        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 Ok(None);
+        }
+
+        let block_to_sync_from = current_block_height - blocks_to_sync;
+
+        Ok(Some(block_to_sync_from))
+    }
 }
 
 /// Attempts to parse native daemon conf file and return rpcport, rpcuser and rpcpassword

mm2src/coins/z_coin.rs

@@ -76,7 +76,7 @@ use z_htlc::{z_p2sh_spend, z_send_dex_fee, z_send_htlc};
 
 mod z_rpc;
 use z_rpc::init_light_client;
-pub use z_rpc::SyncStatus;
+pub use z_rpc::{FirstSyncBlock, SyncStatus};
 
 cfg_native!(
     use crate::{NumConversError, TransactionDetails, TxFeeDetails};
@@ -307,7 +307,10 @@ impl ZCoin {
 
     #[inline]
     pub async fn is_sapling_state_synced(&self) -> bool {
-        matches!(self.sync_status().await, Ok(SyncStatus::Finished { block_number: _ }))
+        matches!(
+            self.sync_status().await,
+            Ok(SyncStatus::Finished { block_number: _, .. })
+        )
     }
 
     #[inline]
@@ -755,14 +758,26 @@ impl AsRef<UtxoCoinFields> for ZCoin {
     fn as_ref(&self) -> &UtxoCoinFields { &self.utxo_arc }
 }
 
+#[derive(Clone, Debug, Deserialize, Serialize)]
+#[serde(rename_all = "lowercase")]
+pub enum SyncStartPoint {
+    Date(u64),
+    Height(u64),
+    Earliest,
+}
+
 #[derive(Clone, Debug, Deserialize, Serialize)]
 #[serde(tag = "rpc", content = "rpc_data")]
 pub enum ZcoinRpcMode {
     #[cfg(not(target_arch = "wasm32"))]
     Native,
+    #[serde(alias = "Electrum")]
     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 +903,17 @@ 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?
-            },
+                light_wallet_d_servers,
+                sync_params,
+                ..
+            } => init_light_client(&self, light_wallet_d_servers.clone(), blocks_db, sync_params).await?,
         };
         let z_fields = ZCoinFields {
             dex_fee_addr,

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

@@ -142,6 +142,17 @@ impl BlockDbImpl {
 
         Ok(())
     }
+
+    pub(crate) async fn get_earliest_block(&self) -> Result<u32, ZcashClientError> {
+        Ok(query_single_row(
+            &self.db.lock().unwrap(),
+            "SELECT MIN(height) from compactblocks",
+            [],
+            |row| row.get::<_, Option<u32>>(0),
+        )?
+        .flatten()
+        .unwrap_or(0))
+    }
 }
 
 #[cfg(not(target_arch = "wasm32"))]

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

@@ -2,7 +2,7 @@ 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::{CheckPointBlockInfo, extended_spending_key_from_protocol_info_and_policy, ZcoinConsensusParams};
     use crate::z_coin::z_rpc::create_wallet_db;
 
     use parking_lot::Mutex;
@@ -35,25 +35,29 @@ pub struct WalletDbShared {
 
 #[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>,
+        checkpoint_block: Option<CheckPointBlockInfo>,
+    ) -> 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 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(),
+            checkpoint_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

@@ -27,6 +27,7 @@ pub enum UpdateBlocksCacheErr {
     JsonRpcError(JsonRpcError),
     GetLiveLightClientError(String),
     ZcashDBError(String),
+    DecodeError(String),
 }
 
 #[cfg(not(target_arch = "wasm32"))]
@@ -59,6 +60,12 @@ pub enum ZcoinClientInitError {
     EmptyLightwalletdUris,
     #[display(fmt = "Fail to init clients while iterating lightwalletd urls {:?}", _0)]
     UrlIterFailure(Vec<UrlIterError>),
+    UpdateBlocksCacheErr(UpdateBlocksCacheErr),
+    UtxoCoinBuildError(UtxoCoinBuildError),
+}
+
+impl From<UpdateBlocksCacheErr> for ZcoinClientInitError {
+    fn from(err: UpdateBlocksCacheErr) -> Self { ZcoinClientInitError::UpdateBlocksCacheErr(err) }
 }
 
 #[cfg(not(target_arch = "wasm32"))]