[r2r] Zcoin native mode support integration & multi lightwalletd servers support

mm2src/coins/Cargo.toml

@@ -41,6 +41,7 @@ ethkey = { git = "https://github.com/artemii235/parity-ethereum.git" }
 futures01 = { version = "0.1", package = "futures" }
 # using select macro requires the crate to be named futures, compilation failed with futures03 name
 futures = { version = "0.3", package = "futures", features = ["compat", "async-await"] }
+group = "0.8.0"
 gstuff = { version = "0.7", features = ["nightly"] }
 hex = "0.4.2"
 http = "0.2"

mm2src/coins/utxo/rpc_clients.rs

@@ -511,14 +511,14 @@ pub enum EstimateFeeMethod {
     SmartFee,
 }
 
-#[derive(Debug, Deserialize)]
+#[derive(Debug, Deserialize, Serialize)]
 #[serde(untagged)]
 pub enum BlockNonce {
     String(String),
     U64(u64),
 }
 
-#[derive(Debug, Deserialize)]
+#[derive(Debug, Deserialize, Serialize)]
 pub struct VerboseBlock {
     /// Block hash
     pub hash: H256Json,
@@ -1124,7 +1124,7 @@ impl NativeClientImpl {
 
     /// https://developer.bitcoin.org/reference/rpc/getblockheader.html
     pub fn get_block_header_bytes(&self, block_hash: H256Json) -> RpcRes<BytesJson> {
-        let verbose = 0;
+        let verbose = false;
         rpc_func!(self, "getblockheader", block_hash, verbose)
     }
 }

mm2src/coins/z_coin.rs

@@ -31,21 +31,20 @@ use futures::compat::Future01CompatExt;
 use futures::lock::Mutex as AsyncMutex;
 use futures::{FutureExt, TryFutureExt};
 use futures01::Future;
-use http::Uri;
 use keys::hash::H256;
 use keys::{KeyPair, Message, Public};
 use mm2_core::mm_ctx::MmArc;
 use mm2_err_handle::prelude::*;
 use mm2_number::{BigDecimal, MmNumber};
 #[cfg(test)] use mocktopus::macros::*;
+use parking_lot::Mutex;
 use primitives::bytes::Bytes;
 use rpc::v1::types::{Bytes as BytesJson, Transaction as RpcTransaction, H256 as H256Json};
 use script::{Builder as ScriptBuilder, Opcode, Script, TransactionInputSigner};
 use serde_json::Value as Json;
 use serialization::CoinVariant;
 use std::collections::{HashMap, HashSet};
 use std::path::PathBuf;
-use std::str::FromStr;
 use std::sync::Arc;
 use zcash_client_backend::data_api::WalletRead;
 use zcash_client_backend::encoding::{decode_payment_address, encode_extended_spending_key, encode_payment_address};
@@ -70,9 +69,10 @@ use z_htlc::{z_p2sh_spend, z_send_dex_fee, z_send_htlc};
 
 mod z_rpc;
 pub use z_rpc::SyncStatus;
-use z_rpc::{init_light_client, SaplingSyncConnector, SaplingSyncGuard, WalletDbShared};
+use z_rpc::{init_light_client, init_native_client, SaplingSyncConnector, SaplingSyncGuard, WalletDbShared};
 
 mod z_coin_errors;
+use crate::z_coin::z_rpc::{create_wallet_db, BlockDb};
 pub use z_coin_errors::*;
 
 #[cfg(all(test, feature = "zhtlc-native-tests"))]
@@ -766,29 +766,39 @@ impl<'a> UtxoCoinWithIguanaPrivKeyBuilder for ZCoinBuilder<'a> {
         );
 
         let evk = ExtendedFullViewingKey::from(&self.z_spending_key);
+        let cache_db_path = self.db_dir_path.join(format!("{}_cache.db", self.ticker));
+        let wallet_db_path = self.db_dir_path.join(format!("{}_wallet.db", self.ticker));
+        let blocks_db =
+            async_blocking(|| BlockDb::for_path(cache_db_path).map_to_mm(ZcoinClientInitError::BlocksDbInitFailure))
+                .await?;
+        let wallet_db = create_wallet_db(
+            wallet_db_path,
+            self.protocol_info.consensus_params.clone(),
+            self.protocol_info.check_point_block.clone(),
+            evk,
+        )
+        .await?;
+        let wallet_db = Arc::new(Mutex::new(wallet_db));
         let (sync_state_connector, light_wallet_db) = match &self.z_coin_params.mode {
             ZcoinRpcMode::Native => {
-                return MmError::err(ZCoinBuildError::NativeModeIsNotSupportedYet);
+                let native_client = self.native_client()?;
+                init_native_client(
+                    native_client,
+                    blocks_db,
+                    wallet_db,
+                    self.protocol_info.consensus_params.clone(),
+                )
+                .await?
             },
             ZcoinRpcMode::Light {
                 light_wallet_d_servers, ..
             } => {
-                let cache_db_path = self.db_dir_path.join(format!("{}_light_cache.db", self.ticker));
-                let wallet_db_path = self.db_dir_path.join(format!("{}_light_wallet.db", self.ticker));
                 // TODO multi lightwalletd servers support will be added on the next iteration
-                let uri = Uri::from_str(
-                    light_wallet_d_servers
-                        .first()
-                        .or_mm_err(|| ZCoinBuildError::EmptyLightwalletdUris)?,
-                )?;
-
                 init_light_client(
-                    uri,
-                    cache_db_path,
-                    wallet_db_path,
+                    light_wallet_d_servers.clone(),
+                    blocks_db,
+                    wallet_db,
                     self.protocol_info.consensus_params.clone(),
-                    self.protocol_info.check_point_block,
-                    evk,
                 )
                 .await?
             },

mm2src/coins/z_coin/z_coin_errors.rs

@@ -3,6 +3,7 @@ use crate::utxo::rpc_clients::UtxoRpcError;
 use crate::utxo::utxo_builder::UtxoCoinBuildError;
 use crate::WithdrawError;
 use crate::{NumConversError, PrivKeyNotAllowed};
+use common::jsonrpc_client::JsonRpcError;
 use db_common::sqlite::rusqlite::Error as SqliteError;
 use db_common::sqlite::rusqlite::Error as SqlError;
 use derive_more::Display;
@@ -19,6 +20,9 @@ pub enum UpdateBlocksCacheErr {
     GrpcError(tonic::Status),
     BlocksDbError(SqliteError),
     ZcashSqliteError(ZcashClientError),
+    UtxoRpcError(UtxoRpcError),
+    InternalError(String),
+    JsonRpcError(JsonRpcError),
 }
 
 impl From<tonic::Status> for UpdateBlocksCacheErr {
@@ -33,18 +37,32 @@ impl From<ZcashClientError> for UpdateBlocksCacheErr {
     fn from(err: ZcashClientError) -> Self { UpdateBlocksCacheErr::ZcashSqliteError(err) }
 }
 
+impl From<UtxoRpcError> for UpdateBlocksCacheErr {
+    fn from(err: UtxoRpcError) -> Self { UpdateBlocksCacheErr::UtxoRpcError(err) }
+}
+
+impl From<JsonRpcError> for UpdateBlocksCacheErr {
+    fn from(err: JsonRpcError) -> Self { UpdateBlocksCacheErr::JsonRpcError(err) }
+}
+
 #[derive(Debug, Display)]
 #[non_exhaustive]
-pub enum ZcoinLightClientInitError {
+pub enum ZcoinClientInitError {
     TlsConfigFailure(tonic::transport::Error),
     ConnectionFailure(tonic::transport::Error),
     BlocksDbInitFailure(SqliteError),
     WalletDbInitFailure(SqliteError),
     ZcashSqliteError(ZcashClientError),
+    EmptyLightwalletdUris,
+    InvalidUri(InvalidUri),
 }
 
-impl From<ZcashClientError> for ZcoinLightClientInitError {
-    fn from(err: ZcashClientError) -> Self { ZcoinLightClientInitError::ZcashSqliteError(err) }
+impl From<ZcashClientError> for ZcoinClientInitError {
+    fn from(err: ZcashClientError) -> Self { ZcoinClientInitError::ZcashSqliteError(err) }
+}
+
+impl From<InvalidUri> for ZcoinClientInitError {
+    fn from(err: InvalidUri) -> Self { ZcoinClientInitError::InvalidUri(err) }
 }
 
 #[derive(Debug, Display)]
@@ -182,10 +200,7 @@ pub enum ZCoinBuildError {
         path: String,
     },
     Io(std::io::Error),
-    EmptyLightwalletdUris,
-    NativeModeIsNotSupportedYet,
-    InvalidLightwalletdUri(InvalidUri),
-    LightClientInitErr(ZcoinLightClientInitError),
+    RpcClientInitErr(ZcoinClientInitError),
     ZCashParamsNotFound,
 }
 
@@ -205,12 +220,8 @@ impl From<std::io::Error> for ZCoinBuildError {
     fn from(err: std::io::Error) -> ZCoinBuildError { ZCoinBuildError::Io(err) }
 }
 
-impl From<InvalidUri> for ZCoinBuildError {
-    fn from(err: InvalidUri) -> Self { ZCoinBuildError::InvalidLightwalletdUri(err) }
-}
-
-impl From<ZcoinLightClientInitError> for ZCoinBuildError {
-    fn from(err: ZcoinLightClientInitError) -> Self { ZCoinBuildError::LightClientInitErr(err) }
+impl From<ZcoinClientInitError> for ZCoinBuildError {
+    fn from(err: ZcoinClientInitError) -> Self { ZCoinBuildError::RpcClientInitErr(err) }
 }
 
 pub(super) enum SqlTxHistoryError {