Spv proof

Cargo.toml

@@ -88,7 +88,7 @@ num-rational = { version = "0.2", features = ["serde", "bigint", "bigint-std"] }
 num-traits = "0.2"
 rpc = { path = "mm2src/mm2_bitcoin/rpc" }
 rpc_task = { path = "mm2src/rpc_task" }
-parking_lot = { version = "0.11", features = ["nightly"] }
+parking_lot = { version = "0.12.0", features = ["nightly"] }
 parity-util-mem = "0.9"
 # AP: portfolio RPCs are not documented and not used as of now
 # so the crate is disabled to speed up the entire removal of C code
@@ -110,6 +110,7 @@ ser_error = { path = "mm2src/derives/ser_error" }
 ser_error_derive = { path = "mm2src/derives/ser_error_derive" }
 serialization = { path = "mm2src/mm2_bitcoin/serialization" }
 serialization_derive = { path = "mm2src/mm2_bitcoin/serialization_derive" }
+spv_validation = { path = "mm2src/mm2_bitcoin/spv_validation" }
 sp-runtime-interface = { version = "3.0.0", default-features = false, features = ["disable_target_static_assertions"] }
 sp-trie = { version = "3.0", default-features = false }
 

README.md

@@ -15,8 +15,8 @@ The current state can be considered as very early alpha.
 1. (Optional) OSX: run `LIBRARY_PATH=/usr/local/opt/openssl/lib`
 1. Run
     ```
-    rustup install nightly-2021-12-16
-    rustup default nightly-2021-12-16
+    rustup install nightly-2022-02-01
+    rustup default nightly-2022-02-01
     rustup component add rustfmt-preview
     ```
 1. Run `cargo build` (or `cargo build -vv` to get verbose build output).

mm2src/coins/Cargo.toml

@@ -13,7 +13,7 @@ doctest = false
 
 [dependencies]
 async-std = { version = "1.5", features = ["unstable"] }
-async-trait = "0.1"
+async-trait = "0.1.52"
 base64 = "0.10.0"
 bigdecimal = { version = "0.1.0", features = ["serde"] }
 bip32 = { version = "0.2.2", default-features = false, features = ["alloc", "secp256k1-ffi"] }
@@ -52,7 +52,7 @@ lightning-invoice = "0.12.0"
 metrics = "0.12"
 mocktopus = "0.7.0"
 num-traits = "0.2"
-parking_lot = { version = "0.11", features = ["nightly"] }
+parking_lot = { version = "0.12.0", features = ["nightly"] }
 primitives = { path = "../mm2_bitcoin/primitives" }
 prost = "0.8"
 rand = { version = "0.7", features = ["std", "small_rng"] }
@@ -69,6 +69,7 @@ serde_derive = "1.0"
 serde_json = { version = "1.0", features = ["preserve_order", "raw_value"] }
 serialization = { path = "../mm2_bitcoin/serialization" }
 serialization_derive = { path = "../mm2_bitcoin/serialization_derive" }
+spv_validation = { path = "../mm2_bitcoin/spv_validation" }
 sha2 = "0.8"
 sha3 = "0.8"
 utxo_signer = { path = "utxo_signer" }

mm2src/coins/lightning_persister/Cargo.toml

@@ -15,7 +15,7 @@ bitcoin = "0.27.1"
 common = { path = "../../common" }
 lightning = "0.0.104"
 libc = "0.2"
-parking_lot = { version = "0.11", features = ["nightly"] }
+parking_lot = { version = "0.12.0", features = ["nightly"] }
 secp256k1 = { version = "0.20" }
 serde_json = "1.0"
 

mm2src/coins/utxo.rs

@@ -29,12 +29,19 @@ mod bchd_pb;
 pub mod qtum;
 pub mod rpc_clients;
 pub mod slp;
+pub mod utxo_block_header_storage;
 pub mod utxo_builder;
 pub mod utxo_common;
 pub mod utxo_standard;
 pub mod utxo_withdraw;
 
 #[cfg(not(target_arch = "wasm32"))] pub mod tx_cache;
+#[cfg(target_arch = "wasm32")]
+pub mod utxo_indexedb_block_header_storage;
+#[cfg(not(target_arch = "wasm32"))]
+pub mod utxo_sql_block_header_storage;
+pub mod utxo_wrapper_block_header_storage;
+use utxo_wrapper_block_header_storage::BlockHeaderStorage;
 
 use async_trait::async_trait;
 use bigdecimal::BigDecimal;
@@ -69,6 +76,7 @@ use rpc::v1::types::{Bytes as BytesJson, Transaction as RpcTransaction, H256 as
 use script::{Builder, Script, SignatureVersion, TransactionInputSigner};
 use serde_json::{self as json, Value as Json};
 use serialization::{serialize, serialize_with_flags, SERIALIZE_TRANSACTION_WITNESS};
+use spv_validation::types::SPVError;
 use std::array::TryFromSliceError;
 use std::collections::{HashMap, HashSet};
 use std::convert::TryInto;
@@ -94,6 +102,7 @@ use super::{BalanceError, BalanceFut, BalanceResult, CoinsContext, DerivationMet
             Transaction, TransactionDetails, TransactionEnum, TransactionFut, WithdrawError, WithdrawRequest};
 use crate::coin_balance::HDAddressBalanceChecker;
 use crate::hd_wallet::{HDAccountOps, HDAccountsMutex, HDAddress, HDWalletCoinOps, HDWalletOps, InvalidBip44ChainError};
+use crate::utxo::utxo_block_header_storage::BlockHeaderStorageError;
 
 #[cfg(test)] pub mod utxo_tests;
 #[cfg(target_arch = "wasm32")] pub mod utxo_wasm_tests;
@@ -471,6 +480,7 @@ pub struct UtxoCoinConf {
     /// Block count for median time past calculation
     pub mtp_block_count: NonZeroU64,
     pub estimate_fee_mode: Option<EstimateFeeMode>,
+    pub block_header_storage_params: Option<UtxoBlockHeaderVerificationParams>,
     /// The minimum number of confirmations at which a transaction is considered mature
     pub mature_confirmations: u32,
     /// The number of blocks used for estimate_fee/estimate_smart_fee RPC calls
@@ -501,6 +511,7 @@ pub struct UtxoCoinFields {
     pub history_sync_state: Mutex<HistorySyncState>,
     /// Path to the TX cache directory
     pub tx_cache_directory: Option<PathBuf>,
+    pub block_headers_storage: Option<BlockHeaderStorage>,
     /// The cache of recently send transactions used to track the spent UTXOs and replace them with new outputs
     /// The daemon needs some time to update the listunspent list for address which makes it return already spent UTXOs
     /// This cache helps to prevent UTXO reuse in such cases
@@ -536,6 +547,31 @@ impl From<UnsupportedAddr> for WithdrawError {
     fn from(e: UnsupportedAddr) -> Self { WithdrawError::InvalidAddress(e.to_string()) }
 }
 
+#[derive(Debug)]
+pub enum GetBlockHeaderError {
+    StorageError(BlockHeaderStorageError),
+    RpcError(JsonRpcError),
+    SerializationError(serialization::Error),
+    SPVError(SPVError),
+    NativeNotSupported(String),
+}
+
+impl From<JsonRpcError> for GetBlockHeaderError {
+    fn from(err: JsonRpcError) -> Self { GetBlockHeaderError::RpcError(err) }
+}
+
+impl From<SPVError> for GetBlockHeaderError {
+    fn from(e: SPVError) -> Self { GetBlockHeaderError::SPVError(e) }
+}
+
+impl From<serialization::Error> for GetBlockHeaderError {
+    fn from(err: serialization::Error) -> Self { GetBlockHeaderError::SerializationError(err) }
+}
+
+impl From<BlockHeaderStorageError> for GetBlockHeaderError {
+    fn from(err: BlockHeaderStorageError) -> Self { GetBlockHeaderError::StorageError(err) }
+}
+
 impl UtxoCoinFields {
     pub fn transaction_preimage(&self) -> TransactionInputSigner {
         let lock_time = if self.conf.ticker == "KMD" {
@@ -1024,6 +1060,14 @@ pub struct UtxoMergeParams {
     pub max_merge_at_once: usize,
 }
 
+#[derive(Clone, Debug, Deserialize, Serialize)]
+pub struct UtxoBlockHeaderVerificationParams {
+    pub difficulty_check: bool,
+    pub constant_difficulty: bool,
+    pub blocks_limit_to_check: u64,
+    pub check_every: f64,
+}
+
 #[derive(Clone, Debug, Deserialize, Serialize)]
 pub struct UtxoActivationParams {
     pub mode: UtxoRpcMode,
@@ -1044,6 +1088,7 @@ pub enum UtxoFromLegacyReqErr {
     UnexpectedMethod,
     InvalidElectrumServers(json::Error),
     InvalidMergeParams(json::Error),
+    InvalidBlockHeaderVerificationParams(json::Error),
     InvalidRequiredConfs(json::Error),
     InvalidRequiresNota(json::Error),
     InvalidAddressFormat(json::Error),

mm2src/coins/utxo/qtum_delegation.rs

@@ -124,14 +124,13 @@ impl QtumCoin {
         let delegation_output = self.remove_delegation_output(QRC20_GAS_LIMIT_DEFAULT, QRC20_GAS_PRICE_DEFAULT)?;
         let outputs = vec![delegation_output];
         let my_address = self.my_address().map_to_mm(DelegationError::InternalError)?;
-        Ok(self
-            .generate_delegation_transaction(
-                outputs,
-                my_address,
-                QRC20_GAS_LIMIT_DEFAULT,
-                TransactionType::RemoveDelegation,
-            )
-            .await?)
+        self.generate_delegation_transaction(
+            outputs,
+            my_address,
+            QRC20_GAS_LIMIT_DEFAULT,
+            TransactionType::RemoveDelegation,
+        )
+        .await
     }
 
     async fn am_i_currently_staking(&self) -> Result<Option<String>, MmError<StakingInfosError>> {
@@ -252,14 +251,13 @@ impl QtumCoin {
 
         let outputs = vec![delegation_output];
         let my_address = self.my_address().map_to_mm(DelegationError::InternalError)?;
-        Ok(self
-            .generate_delegation_transaction(
-                outputs,
-                my_address,
-                QRC20_GAS_LIMIT_DELEGATION,
-                TransactionType::StakingDelegation,
-            )
-            .await?)
+        self.generate_delegation_transaction(
+            outputs,
+            my_address,
+            QRC20_GAS_LIMIT_DELEGATION,
+            TransactionType::StakingDelegation,
+        )
+        .await
     }
 
     async fn generate_delegation_transaction(

mm2src/coins/utxo/rpc_clients.rs

@@ -1025,7 +1025,7 @@ impl Into<BlockHeaderNonce> for ElectrumNonce {
 
 #[derive(Debug, Deserialize)]
 pub struct ElectrumBlockHeadersRes {
-    count: u64,
+    pub count: u64,
     pub hex: BytesJson,
     #[allow(dead_code)]
     max: u64,
@@ -1044,8 +1044,8 @@ pub struct ElectrumBlockHeaderV12 {
 }
 
 impl ElectrumBlockHeaderV12 {
-    pub fn hash(&self) -> H256Json {
-        let block_header = BlockHeader {
+    fn as_block_header(&self) -> BlockHeader {
+        BlockHeader {
             version: self.version as u32,
             previous_header_hash: self.prev_block_hash.into(),
             merkle_root_hash: self.merkle_root.into(),
@@ -1064,7 +1064,17 @@ impl ElectrumBlockHeaderV12 {
             n_height: None,
             n_nonce_u64: None,
             mix_hash: None,
-        };
+        }
+    }
+
+    pub fn as_hex(&self) -> String {
+        let block_header = self.as_block_header();
+        let serialized = serialize(&block_header);
+        hex::encode(serialized)
+    }
+
+    pub fn hash(&self) -> H256Json {
+        let block_header = self.as_block_header();
         BlockHeader::hash(&block_header).into()
     }
 }

mm2src/coins/utxo/utxo_block_header_storage.rs

@@ -0,0 +1,77 @@
+use crate::utxo::rpc_clients::ElectrumBlockHeader;
+use async_trait::async_trait;
+use chain::BlockHeader;
+use common::mm_error::MmError;
+use derive_more::Display;
+use std::collections::HashMap;
+
+#[derive(Debug, Deserialize, Display, Serialize, SerializeErrorType)]
+#[serde(tag = "error_type", content = "error_data")]
+pub enum BlockHeaderStorageError {
+    #[display(fmt = "The storage cannot be initialized for {}", _0)]
+    InitializationError(String),
+    #[display(fmt = "The storage is not initialized for {} - reason: {}", ticker, reason)]
+    NotInitializedError { ticker: String, reason: String },
+    #[display(fmt = "Can't add to the storage for {} - reason: {}", ticker, reason)]
+    AddToStorageError { ticker: String, reason: String },
+    #[display(fmt = "Can't add to the storage for {} - reason: {}", ticker, reason)]
+    GetFromStorageError { ticker: String, reason: String },
+    #[display(
+        fmt = "Can't retrieve the table from the storage for {} - reason: {}",
+        ticker,
+        reason
+    )]
+    CantRetrieveTableError { ticker: String, reason: String },
+    #[display(fmt = "Can't query from the storage - query: {} - reason: {}", query, reason)]
+    QueryError { query: String, reason: String },
+    #[display(fmt = "Can't retrieve string from row - reason: {}", reason)]
+    StringRowError { reason: String },
+    #[display(fmt = "Can't execute query from storage for {} - reason: {}", ticker, reason)]
+    ExecutionError { ticker: String, reason: String },
+    #[display(fmt = "Can't start a transaction from storage for {} - reason: {}", ticker, reason)]
+    TransactionError { ticker: String, reason: String },
+    #[display(fmt = "Can't commit a transaction from storage for {} - reason: {}", ticker, reason)]
+    CommitError { ticker: String, reason: String },
+    #[display(fmt = "Can't decode/deserialize from storage for {} - reason: {}", ticker, reason)]
+    DecodeError { ticker: String, reason: String },
+}
+
+#[async_trait]
+pub trait BlockHeaderStorageOps: Send + Sync + 'static {
+    /// Initializes collection/tables in storage for a specified coin
+    async fn init(&self, for_coin: &str) -> Result<(), MmError<BlockHeaderStorageError>>;
+
+    async fn is_initialized_for(&self, for_coin: &str) -> Result<bool, MmError<BlockHeaderStorageError>>;
+
+    // Adds multiple block headers to the selected coin's header storage
+    // Should store it as `TICKER_HEIGHT=hex_string`
+    // use this function for headers that comes from `blockchain_headers_subscribe`
+    async fn add_electrum_block_headers_to_storage(
+        &self,
+        for_coin: &str,
+        headers: Vec<ElectrumBlockHeader>,
+    ) -> Result<(), MmError<BlockHeaderStorageError>>;
+
+    // Adds multiple block headers to the selected coin's header storage
+    // Should store it as `TICKER_HEIGHT=hex_string`
+    // use this function for headers that comes from `blockchain_block_headers`
+    async fn add_block_headers_to_storage(
+        &self,
+        for_coin: &str,
+        headers: HashMap<u64, BlockHeader>,
+    ) -> Result<(), MmError<BlockHeaderStorageError>>;
+
+    /// Gets the block header by height from the selected coin's storage as BlockHeader
+    async fn get_block_header(
+        &self,
+        for_coin: &str,
+        height: u64,
+    ) -> Result<Option<BlockHeader>, MmError<BlockHeaderStorageError>>;
+
+    /// Gets the block header by height from the selected coin's storage as hex
+    async fn get_block_header_raw(
+        &self,
+        for_coin: &str,
+        height: u64,
+    ) -> Result<Option<String>, MmError<BlockHeaderStorageError>>;
+}