// Copyright The Hush Developers 2019-2022 // Released under the GPLv3 use crate::lightwallet::LightWallet; use std::borrow::Cow; use std::sync::{Arc, RwLock, Mutex, mpsc::channel}; use std::sync::atomic::{AtomicBool, AtomicI32, AtomicUsize, Ordering}; use std::path::{Path, PathBuf}; use std::fs::File; use std::collections::{HashSet, HashMap}; use std::cmp::{max, min}; use std::io; use std::io::prelude::*; use std::io::{BufReader, BufWriter, Error, ErrorKind}; use tokio::runtime::Runtime; use tokio::time::{Duration}; use crate::grpc_client::RawTransaction; use protobuf::parse_from_bytes; use threadpool::ThreadPool; use json::{object, array, JsonValue}; use zcash_primitives::transaction::{TxId, Transaction}; use zcash_client_backend::{constants::testnet, constants::mainnet, constants::regtest,}; use log::{info, warn, error, LevelFilter}; use log4rs::append::rolling_file::RollingFileAppender; use log4rs::encode::pattern::PatternEncoder; use log4rs::config::{Appender, Config, Root}; use log4rs::filter::threshold::ThresholdFilter; use log4rs::append::rolling_file::policy::compound::{ CompoundPolicy, trigger::size::SizeTrigger, roll::fixed_window::FixedWindowRoller, }; use crate::grpcconnector::{self, *}; use crate::ANCHOR_OFFSET; mod checkpoints; pub const DEFAULT_SERVER: &str = "https://lite.dragonx.is"; pub const WALLET_NAME: &str = "silentdragonxlite-wallet.dat"; pub const LOGFILE_NAME: &str = "silentdragonxlite-wallet.debug.log"; #[derive(Clone, Debug)] pub struct WalletStatus { pub is_syncing: bool, pub total_blocks: u64, pub synced_blocks: u64, } impl WalletStatus { pub fn new() -> Self { WalletStatus { is_syncing: false, total_blocks: 0, synced_blocks: 0 } } } #[derive(Clone, Debug)] pub struct LightClientConfig { pub server : http::Uri, pub chain_name : String, pub sapling_activation_height : u64, pub consensus_branch_id : String, pub anchor_offset : u32, pub no_cert_verification : bool, pub data_dir : Option } impl LightClientConfig { // Create an unconnected (to any server) config to test for local wallet etc... pub fn create_unconnected(chain_name: String, dir: Option) -> LightClientConfig { LightClientConfig { server : http::Uri::default(), chain_name : chain_name, sapling_activation_height : 0, consensus_branch_id : "".to_string(), anchor_offset : ANCHOR_OFFSET, no_cert_verification : false, data_dir : dir, } } pub fn create(server: http::Uri, dangerous: bool) -> io::Result<(LightClientConfig, u64)> { use std::net::ToSocketAddrs; // Test for a connection first format!("{}:{}", server.host().unwrap(), server.port().unwrap()) .to_socket_addrs()? .next() .ok_or(std::io::Error::new(ErrorKind::ConnectionRefused, "Couldn't resolve server!"))?; // Do a getinfo first, before opening the wallet let info = grpcconnector::get_info(&server, dangerous) .map_err(|e| std::io::Error::new(ErrorKind::ConnectionRefused, e))?; // Create a Light Client Config let config = LightClientConfig { server, chain_name : info.chain_name, sapling_activation_height : info.sapling_activation_height, consensus_branch_id : info.consensus_branch_id, anchor_offset : ANCHOR_OFFSET, no_cert_verification : dangerous, data_dir : None, }; Ok((config, info.block_height)) } /// Build the Logging config pub fn get_log_config(&self) -> io::Result { let window_size = 3; // log0, log1, log2 let fixed_window_roller = FixedWindowRoller::builder().build("zecwallet-light-wallet-log{}",window_size).unwrap(); let size_limit = 5 * 1024 * 1024; // 5MB as max log file size to roll let size_trigger = SizeTrigger::new(size_limit); let compound_policy = CompoundPolicy::new(Box::new(size_trigger),Box::new(fixed_window_roller)); Config::builder() .appender( Appender::builder() .filter(Box::new(ThresholdFilter::new(LevelFilter::Info))) .build( "logfile", Box::new( RollingFileAppender::builder() .encoder(Box::new(PatternEncoder::new("{d} {l}::{m}{n}"))) .build(self.get_log_path(), Box::new(compound_policy))?, ), ), ) .build( Root::builder() .appender("logfile") .build(LevelFilter::Debug), ) .map_err(|e|Error::new(ErrorKind::Other, format!("{}", e))) } pub fn get_zcash_data_path(&self) -> Box { let mut zcash_data_location; if self.data_dir.is_some() { zcash_data_location = PathBuf::from(&self.data_dir.as_ref().unwrap()); } else { if cfg!(target_os="macos") || cfg!(target_os="windows") { zcash_data_location = dirs::data_dir().expect("Couldn't determine app data directory!"); zcash_data_location.push("silentdragonxlite"); } else { zcash_data_location = dirs::home_dir().expect("Couldn't determine home directory!"); zcash_data_location.push(".silentdragonxlite"); }; match &self.chain_name[..] { "main" => {}, "test" => zcash_data_location.push("testnet3"), "regtest" => zcash_data_location.push("regtest"), c => panic!("Unknown chain {}", c), }; } // Create directory if it doesn't exist match std::fs::create_dir_all(zcash_data_location.clone()) { Ok(_) => zcash_data_location.into_boxed_path(), Err(e) => { eprintln!("Couldn't create zcash directory!\n{}", e); panic!("Couldn't create zcash directory!"); } } } pub fn get_wallet_path(&self) -> Box { let mut wallet_location = self.get_zcash_data_path().into_path_buf(); wallet_location.push(WALLET_NAME); wallet_location.into_boxed_path() } pub fn wallet_exists(&self) -> bool { return self.get_wallet_path().exists() } pub fn get_zcash_params_path(&self) -> io::Result> { let mut zcash_params = self.get_zcash_data_path().into_path_buf(); zcash_params.push(".."); if cfg!(target_os="macos") || cfg!(target_os="windows") { zcash_params.push("ZcashParams"); } else { zcash_params.push(".zcash-params"); } match std::fs::create_dir_all(zcash_params.clone()) { Ok(_) => Ok(zcash_params.into_boxed_path()), Err(e) => { eprintln!("Couldn't create zcash params directory\n{}", e); Err(e) } } } pub fn get_log_path(&self) -> Box { let mut log_path = self.get_zcash_data_path().into_path_buf(); log_path.push(LOGFILE_NAME); log_path.into_boxed_path() } pub fn get_initial_state(&self, height: u64) -> Option<(u64, &str, &str)> { checkpoints::get_closest_checkpoint(&self.chain_name, height) } pub fn get_server_or_default(server: Option) -> http::Uri { match server { Some(s) => { let mut s = if s.starts_with("http") {s} else { "http://".to_string() + &s}; let uri: http::Uri = s.parse().unwrap(); if uri.port().is_none() { s = s + ":443"; } s } None => DEFAULT_SERVER.to_string() }.parse().unwrap() } pub fn get_coin_type(&self) -> u32 { match &self.chain_name[..] { "main" => mainnet::COIN_TYPE, "test" => testnet::COIN_TYPE, "regtest" => regtest::COIN_TYPE, c => panic!("Unknown chain {}", c) } } pub fn hrp_sapling_address(&self) -> &str { match &self.chain_name[..] { "main" => mainnet::HRP_SAPLING_PAYMENT_ADDRESS, "test" => testnet::HRP_SAPLING_PAYMENT_ADDRESS, "regtest" => regtest::HRP_SAPLING_PAYMENT_ADDRESS, c => panic!("Unknown chain {}", c) } } pub fn hrp_sapling_private_key(&self) -> &str { match &self.chain_name[..] { "main" => mainnet::HRP_SAPLING_EXTENDED_SPENDING_KEY, "test" => testnet::HRP_SAPLING_EXTENDED_SPENDING_KEY, "regtest" => regtest::HRP_SAPLING_EXTENDED_SPENDING_KEY, c => panic!("Unknown chain {}", c) } } pub fn hrp_sapling_viewing_key(&self) -> &str { match &self.chain_name[..] { "main" => mainnet::HRP_SAPLING_EXTENDED_FULL_VIEWING_KEY, "test" => testnet::HRP_SAPLING_EXTENDED_FULL_VIEWING_KEY, "regtest" => regtest::HRP_SAPLING_EXTENDED_FULL_VIEWING_KEY, c => panic!("Unknown chain {}", c) } } pub fn base58_pubkey_address(&self) -> [u8; 1] { match &self.chain_name[..] { "main" => mainnet::B58_PUBKEY_ADDRESS_PREFIX, c => panic!("Unknown chain {}", c) } } pub fn base58_script_address(&self) -> [u8; 1] { match &self.chain_name[..] { "main" => mainnet::B58_SCRIPT_ADDRESS_PREFIX, c => panic!("Unknown chain {}", c) } } pub fn base58_secretkey_prefix(&self) -> [u8; 1] { match &self.chain_name[..] { "main" => [0xBC], "test" => [0xEF], "regtest" => [0xEF], c => panic!("Unknown chain {}", c) } } } pub struct LightClient { pub wallet : Arc>, pub config : LightClientConfig, // zcash-params pub sapling_output : Cow<'static, [u8]>, pub sapling_spend : Cow<'static, [u8]>, sync_lock : Mutex<()>, sync_status : Arc>, // The current syncing status of the Wallet. pub shutdown_flag : Arc, // Signal mempool threads to stop } impl LightClient { pub fn set_wallet_initial_state(&self, height: u64) { use std::convert::TryInto; let state = self.config.get_initial_state(height); match state { Some((height, hash, tree)) => self.wallet.read().unwrap().set_initial_block(height.try_into().unwrap(), hash, tree), _ => true, }; } fn write_file_if_not_exists(dir: &Box, name: &str, bytes: &[u8]) -> io::Result<()> { let mut file_path = dir.to_path_buf(); file_path.push(name); if !file_path.exists() { let mut file = File::create(&file_path)?; file.write_all(bytes)?; } Ok(()) } #[cfg(feature = "embed_params")] fn read_sapling_params(&mut self) { // Read Sapling Params use crate::SaplingParams; self.sapling_output = SaplingParams::get("sapling-output.params").unwrap(); self.sapling_spend = SaplingParams::get("sapling-spend.params").unwrap(); } pub fn set_sapling_params(&mut self, sapling_output: &[u8], sapling_spend: &[u8]) -> Result<(), String> { use sha2::{Sha256, Digest}; // The hashes of the params need to match const SAPLING_OUTPUT_HASH: &str = "2f0ebbcbb9bb0bcffe95a397e7eba89c29eb4dde6191c339db88570e3f3fb0e4"; const SAPLING_SPEND_HASH: &str = "8e48ffd23abb3a5fd9c5589204f32d9c31285a04b78096ba40a79b75677efc13"; if SAPLING_OUTPUT_HASH.to_string() != hex::encode(Sha256::digest(&sapling_output)) { return Err(format!("sapling-output hash didn't match. expected {}, found {}", SAPLING_OUTPUT_HASH, hex::encode(Sha256::digest(&sapling_output)) )) } if SAPLING_SPEND_HASH.to_string() != hex::encode(Sha256::digest(&sapling_spend)) { return Err(format!("sapling-spend hash didn't match. expected {}, found {}", SAPLING_SPEND_HASH, hex::encode(Sha256::digest(&sapling_spend)) )) } // Will not overwrite previous params if self.sapling_output.is_empty() { self.sapling_output = Cow::Owned(sapling_output.to_vec()); } if self.sapling_spend.is_empty() { self.sapling_spend = Cow::Owned(sapling_spend.to_vec()); } // Ensure that the sapling params are stored on disk properly as well. match self.config.get_zcash_params_path() { Ok(zcash_params_dir) => { // Create the sapling output and spend params files match LightClient::write_file_if_not_exists(&zcash_params_dir, "sapling-output.params", &self.sapling_output) { Ok(_) => {}, Err(e) => eprintln!("Warning: Couldn't write the output params!\n{}", e) }; match LightClient::write_file_if_not_exists(&zcash_params_dir, "sapling-spend.params", &self.sapling_spend) { Ok(_) => {}, Err(e) => eprintln!("Warning: Couldn't write the output params!\n{}", e) } }, Err(e) => { eprintln!("{}", e); } }; Ok(()) } /// Method to create a test-only version of the LightClient #[allow(dead_code)] pub fn unconnected(seed_phrase: String, dir: Option) -> io::Result { let config = LightClientConfig::create_unconnected("test".to_string(), dir); let mut l = LightClient { wallet : Arc::new(RwLock::new(LightWallet::new(Some(seed_phrase), &config, 0,0 )?)), config : config.clone(), sapling_output : Cow::Borrowed(&[]), sapling_spend : Cow::Borrowed(&[]), sync_lock : Mutex::new(()), sync_status : Arc::new(RwLock::new(WalletStatus::new())), shutdown_flag : Arc::new(AtomicBool::new(false)), }; l.set_wallet_initial_state(0); #[cfg(feature = "embed_params")] l.read_sapling_params(); info!("Created new wallet!"); info!("Created LightClient to {}", &config.server); Ok(l) } /// Create a brand new wallet with a new seed phrase. Will fail if a wallet file /// already exists on disk pub fn new(config: &LightClientConfig, latest_block: u64) -> io::Result { if config.wallet_exists() { return Err(Error::new(ErrorKind::AlreadyExists, "Cannot create a new wallet from seed, because a wallet already exists")); } let mut l = LightClient { wallet : Arc::new(RwLock::new(LightWallet::new(None, config, latest_block, 0)?)), config : config.clone(), sapling_output : Cow::Borrowed(&[]), sapling_spend : Cow::Borrowed(&[]), sync_lock : Mutex::new(()), sync_status : Arc::new(RwLock::new(WalletStatus::new())), shutdown_flag : Arc::new(AtomicBool::new(false)), }; l.set_wallet_initial_state(latest_block); #[cfg(feature = "embed_params")] l.read_sapling_params(); info!("Created new wallet with a new seed!"); info!("Created LightClient to {}", &config.server); l.do_save().map_err(|s| io::Error::new(ErrorKind::PermissionDenied, s))?; Ok(l) } pub fn new_from_phrase(seed_phrase: String, config: &LightClientConfig, birthday: u64,number: u64, overwrite: bool) -> io::Result { if !overwrite && config.wallet_exists() { return Err(Error::new(ErrorKind::AlreadyExists, "Cannot create a new wallet from seed, because a wallet already exists")); } let mut l = LightClient { wallet : Arc::new(RwLock::new(LightWallet::new(Some(seed_phrase), config, birthday, number)?)), config : config.clone(), sapling_output : Cow::Borrowed(&[]), sapling_spend : Cow::Borrowed(&[]), sync_lock : Mutex::new(()), sync_status : Arc::new(RwLock::new(WalletStatus::new())), shutdown_flag : Arc::new(AtomicBool::new(false)), }; // println!("Setting birthday to {}", birthday); l.set_wallet_initial_state(birthday); #[cfg(feature = "embed_params")] l.read_sapling_params(); info!("Created new wallet!"); info!("Created LightClient to {}", &config.server); l.do_save().map_err(|s| io::Error::new(ErrorKind::PermissionDenied, s))?; Ok(l) } pub fn read_from_disk(config: &LightClientConfig) -> io::Result { if !config.wallet_exists() { // Try to recover from backup let bak_path = config.get_wallet_path().with_extension("dat.bak"); if bak_path.exists() { warn!("Wallet file missing but backup found, attempting recovery from {:?}", bak_path); std::fs::copy(&bak_path, config.get_wallet_path())?; info!("Wallet recovered from backup"); } else { return Err(Error::new(ErrorKind::AlreadyExists, format!("Cannot read wallet. No file at {}", config.get_wallet_path().display()))); } } // Try to open the wallet file; if it fails (corrupted/truncated), try the backup let wallet = match File::open(config.get_wallet_path()) .and_then(|f| { let mut file_buffer = BufReader::new(f); LightWallet::read(&mut file_buffer, config) }) { Ok(w) => w, Err(e) => { warn!("Failed to read wallet file: {}, trying backup", e); let bak_path = config.get_wallet_path().with_extension("dat.bak"); if bak_path.exists() { std::fs::copy(&bak_path, config.get_wallet_path())?; let mut file_buffer = BufReader::new(File::open(config.get_wallet_path())?); LightWallet::read(&mut file_buffer, config)? } else { return Err(e); } } }; let mut lc = LightClient { wallet : Arc::new(RwLock::new(wallet)), config : config.clone(), sapling_output : Cow::Borrowed(&[]), sapling_spend : Cow::Borrowed(&[]), sync_lock : Mutex::new(()), sync_status : Arc::new(RwLock::new(WalletStatus::new())), shutdown_flag : Arc::new(AtomicBool::new(false)), }; #[cfg(feature = "embed_params")] lc.read_sapling_params(); info!("Read wallet with birthday {}", lc.wallet.read().unwrap().get_first_tx_block()); info!("Created LightClient to {}", &config.server); Ok(lc) } pub fn init_logging(&self) -> io::Result<()> { // Configure logging first. let log_config = self.config.get_log_config()?; log4rs::init_config(log_config).map_err(|e| { std::io::Error::new(ErrorKind::Other, e) })?; Ok(()) } pub fn attempt_recover_seed(config: &LightClientConfig, password: Option) -> Result { use std::io::prelude::*; use byteorder::{LittleEndian, ReadBytesExt}; use libflate::gzip::Decoder; use bip39::{Mnemonic, Language}; use zcash_primitives::serialize::Vector; let mut inp = BufReader::new(File::open(config.get_wallet_path()).unwrap()); let version = inp.read_u64::().unwrap(); println!("Reading wallet version {}", version); // At version 5, we're writing the rest of the file as a compressed stream (gzip) let mut reader: Box = if version != 5 { Box::new(inp) } else { Box::new(Decoder::new(inp).unwrap()) }; let encrypted = if version >= 4 { reader.read_u8().unwrap() > 0 } else { false }; if encrypted && password.is_none() { return Err("The wallet is encrypted and a password was not specified. Please specify the password with '--password'!".to_string()); } let mut enc_seed = [0u8; 48]; if version >= 4 { reader.read_exact(&mut enc_seed).unwrap(); } let nonce = if version >= 4 { Vector::read(&mut reader, |r| r.read_u8()).unwrap() } else { vec![] }; let phrase = if encrypted { use sodiumoxide::crypto::secretbox; use crate::lightwallet::double_sha256; // Get the doublesha256 of the password, which is the right length let key = secretbox::Key::from_slice(&double_sha256(password.unwrap().as_bytes())).unwrap(); let nonce = secretbox::Nonce::from_slice(&nonce).unwrap(); let seed = match secretbox::open(&enc_seed, &nonce, &key) { Ok(s) => s, Err(_) => return Err("Decryption failed. Is your password correct?".to_string()) }; Mnemonic::from_entropy(&seed, Language::English) } else { // Seed let mut seed_bytes = [0u8; 32]; reader.read_exact(&mut seed_bytes).unwrap(); Mnemonic::from_entropy(&seed_bytes, Language::English) }.map_err(|e| format!("Failed to read seed. {:?}", e)); phrase.map(|m| m.phrase().to_string()) } pub fn last_scanned_height(&self) -> u64 { self.wallet.read().unwrap().last_scanned_height() as u64 } // Export private keys pub fn do_export(&self, addr: Option) -> Result { if !self.wallet.read().unwrap().is_unlocked_for_spending() { error!("Wallet is locked"); return Err("Wallet is locked"); } // Clone address so it can be moved into the closure let address = addr.clone(); let wallet = self.wallet.read().unwrap(); // Go over all z addresses let z_keys = wallet.get_z_private_keys().iter() .filter( move |(addr, _, _)| address.is_none() || address.as_ref() == Some(addr)) .map( |(addr, pk, vk)| object!{ "address" => addr.clone(), "private_key" => pk.clone(), "viewing_key" => vk.clone(), } ).collect::>(); // Clone address so it can be moved into the closure let address = addr.clone(); // Go over all t addresses let t_keys = wallet.get_t_secret_keys().iter() .filter( move |(addr, _)| address.is_none() || address.as_ref() == Some(addr)) .map( |(addr, sk)| object!{ "address" => addr.clone(), "private_key" => sk.clone(), } ).collect::>(); let mut all_keys = vec![]; all_keys.extend_from_slice(&z_keys); all_keys.extend_from_slice(&t_keys); Ok(all_keys.into()) } pub fn do_address(&self) -> JsonValue { let wallet = self.wallet.read().unwrap(); // Collect z addresses let z_addresses = wallet.get_all_zaddresses(); // Collect t addresses let t_addresses = wallet.get_all_taddresses().iter().map( |a| a.clone() ) .collect::>(); object!{ "z_addresses" => z_addresses, "t_addresses" => t_addresses, } } pub fn do_balance(&self) -> JsonValue { let wallet = self.wallet.read().unwrap(); // Collect z addresses let z_addresses = wallet.z_balances_by_address().into_iter() .map(|(address, zbalance, unconfirmed, verified_zbalance, spendable_zbalance)| { object!{ "address" => address, "zbalance" => zbalance, "unconfirmed" => unconfirmed, "verified_zbalance" => verified_zbalance, "spendable_zbalance" => spendable_zbalance } }).collect::>(); // Collect t addresses let t_addresses = wallet.get_all_taddresses().iter().map( |address| { // Get the balance for this address let balance = wallet.tbalance(Some(address.clone())) ; object!{ "address" => address.clone(), "balance" => balance, } }).collect::>(); object!{ "zbalance" => wallet.zbalance(None), "unconfirmed" => wallet.unconfirmed_zbalance(None), "verified_zbalance" => wallet.verified_zbalance(None), "spendable_zbalance" => wallet.spendable_zbalance(None), "tbalance" => wallet.tbalance(None), "z_addresses" => z_addresses, "t_addresses" => t_addresses, } } pub fn do_save(&self) -> Result<(), String> { // If the wallet is encrypted but unlocked, lock it again. { let mut wallet = self.wallet.write().unwrap(); if wallet.is_encrypted() && wallet.is_unlocked_for_spending() { match wallet.lock() { Ok(_) => {}, Err(e) => { let err = format!("ERR: {}", e); error!("{}", err); return Err(e.to_string()); } } } } let r; { // Prevent any overlapping syncs during save, and don't save in the middle of a sync let _lock = self.sync_lock.lock().unwrap(); let wallet_path = self.config.get_wallet_path(); let tmp_path = wallet_path.with_extension("dat.tmp"); let bak_path = wallet_path.with_extension("dat.bak"); // Write to a temporary file first (atomic save) let wallet = self.wallet.write().unwrap(); let mut file_buffer = BufWriter::with_capacity( 1_000_000, // 1 MB write buffer File::create(&tmp_path).map_err(|e| format!("Failed to create temp file: {}", e))?); r = match wallet.write(&mut file_buffer) { Ok(_) => Ok(()), Err(e) => { let err = format!("ERR: {}", e); error!("{}", err); // Clean up temp file on write failure let _ = std::fs::remove_file(&tmp_path); Err(e.to_string()) } }; file_buffer.flush().map_err(|e| { let _ = std::fs::remove_file(&tmp_path); format!("{}", e) })?; // Only proceed with rename if the write succeeded if r.is_ok() { // Create backup of existing wallet (if it exists) if wallet_path.exists() { if let Err(e) = std::fs::copy(&wallet_path, &bak_path) { warn!("Failed to create wallet backup: {}", e); // Non-fatal: continue with the save } } // Atomically replace the wallet file with the new one if let Err(e) = std::fs::rename(&tmp_path, &wallet_path) { error!("Failed to rename temp wallet file: {}", e); // Try direct copy as fallback (rename can fail across filesystems) if let Err(e2) = std::fs::copy(&tmp_path, &wallet_path) { let _ = std::fs::remove_file(&tmp_path); return Err(format!("Failed to save wallet: {} / {}", e, e2)); } let _ = std::fs::remove_file(&tmp_path); } } } r } pub fn get_server_uri(&self) -> http::Uri { self.config.server.clone() } // DEBUG: dump the wallet's latest Sapling commitment tree so it can be diffed against the // node's `getblockmerkletree ` to localize a tree/anchor divergence. pub fn do_sapling_tree(&self) -> JsonValue { match self.wallet.read().unwrap().get_sapling_tree() { Ok((height, hash, tree)) => object!{ "height" => height, "hash" => hash, "tree" => tree, "anchor_offset" => self.config.anchor_offset, }, Err(e) => object!{ "error" => e }, } } pub fn do_info(&self) -> String { match get_info(&self.get_server_uri(), self.config.no_cert_verification) { Ok(i) => { let o = object!{ "version" => i.version, "vendor" => i.vendor, "taddr_support" => i.taddr_support, "chain_name" => i.chain_name, "sapling_activation_height" => i.sapling_activation_height, "consensus_branch_id" => i.consensus_branch_id, "latest_block_height" => i.block_height, "difficulty" => i.difficulty, "longestchain" => i.longestchain, "notarized" => i.notarized, }; o.pretty(2) }, Err(e) => e } } pub fn do_coinsupply(&self) -> String { match get_coinsupply(self.get_server_uri(), self.config.no_cert_verification) { Ok(i) => { let o = object!{ "result" => i.result, "coin" => i.coin, "height" => i.height, "supply" => i.supply, "zfunds" => i.zfunds, "total" => i.total, }; o.pretty(2) }, Err(e) => e } } pub fn do_seed_phrase(&self) -> Result { if !self.wallet.read().unwrap().is_unlocked_for_spending() { error!("Wallet is locked"); return Err("Wallet is locked"); } let wallet = self.wallet.read().unwrap(); Ok(object!{ "seed" => wallet.get_seed_phrase(), "birthday" => wallet.get_birthday() }) } // Return a list of all notes, spent and unspent pub fn do_list_notes(&self, all_notes: bool) -> JsonValue { let mut unspent_notes: Vec = vec![]; let mut spent_notes : Vec = vec![]; let mut pending_notes: Vec = vec![]; let anchor_height: i32 = self.wallet.read().unwrap().get_anchor_height() as i32; { let wallet = self.wallet.read().unwrap(); // First, collect all extfvk's that are spendable (i.e., we have the private key) let spendable_address_set: HashSet = wallet.spendable_zaddress_set(); let spendable_address: &HashSet = &spendable_address_set; // Collect Sapling notes wallet.txs.read().unwrap().iter() .flat_map( |(txid, wtx)| { let spendable_address: &HashSet = spendable_address; wtx.notes.iter().filter_map(move |nd| if !all_notes && nd.spent.is_some() { None } else { let address = LightWallet::note_address(self.config.hrp_sapling_address(), nd); let spendable = address.is_some() && spendable_address.contains(&address.clone().unwrap()) && wtx.block <= anchor_height && nd.spent.is_none() && nd.unconfirmed_spent.is_none(); Some(object!{ "created_in_block" => wtx.block, "datetime" => wtx.datetime, "created_in_txid" => format!("{}", txid), "value" => nd.note.value, "is_change" => nd.is_change, "address" => address, "spendable" => spendable, "spent" => nd.spent.map(|spent_txid| format!("{}", spent_txid)), "unconfirmed_spent" => nd.unconfirmed_spent.map(|spent_txid| format!("{}", spent_txid)), }) } ) }) .for_each( |note| { if note["spent"].is_null() && note["unconfirmed_spent"].is_null() { unspent_notes.push(note); } else if !note["spent"].is_null() { spent_notes.push(note); } else { pending_notes.push(note); } }); } let mut unspent_utxos: Vec = vec![]; let mut spent_utxos : Vec = vec![]; let mut pending_utxos: Vec = vec![]; { let wallet = self.wallet.read().unwrap(); wallet.txs.read().unwrap().iter() .flat_map( |(txid, wtx)| { wtx.utxos.iter().filter_map(move |utxo| if !all_notes && utxo.spent.is_some() { None } else { Some(object!{ "created_in_block" => wtx.block, "datetime" => wtx.datetime, "created_in_txid" => format!("{}", txid), "value" => utxo.value, "scriptkey" => hex::encode(utxo.script.clone()), "is_change" => false, // TODO: Identify notes as change if we send change to taddrs "address" => utxo.address.clone(), "spent" => utxo.spent.map(|spent_txid| format!("{}", spent_txid)), "unconfirmed_spent" => utxo.unconfirmed_spent.map(|spent_txid| format!("{}", spent_txid)), }) } ) }) .for_each( |utxo| { if utxo["spent"].is_null() && utxo["unconfirmed_spent"].is_null() { unspent_utxos.push(utxo); } else if !utxo["spent"].is_null() { spent_utxos.push(utxo); } else { pending_utxos.push(utxo); } }); } let mut res = object!{ "unspent_notes" => unspent_notes, "pending_notes" => pending_notes, "utxos" => unspent_utxos, "pending_utxos" => pending_utxos, }; if all_notes { res["spent_notes"] = JsonValue::Array(spent_notes); res["spent_utxos"] = JsonValue::Array(spent_utxos); } res } pub fn do_encryption_status(&self) -> JsonValue { let wallet = self.wallet.read().unwrap(); object!{ "encrypted" => wallet.is_encrypted(), "locked" => !wallet.is_unlocked_for_spending() } } pub fn do_list_transactions(&self) -> JsonValue { let wallet = self.wallet.read().unwrap(); // Create a list of TransactionItems from wallet txns let mut tx_list = wallet.txs.read().unwrap().iter() .flat_map(| (_k, v) | { let mut txns: Vec = vec![]; if v.total_shielded_value_spent + v.total_transparent_value_spent > 0 { // If money was spent, create a transaction. For this, we'll subtract // all the change notes. TODO: Add transparent change here to subtract it also let total_change: u64 = v.notes.iter() .filter( |nd| nd.is_change ) .map( |nd| nd.note.value ) .sum(); // TODO: What happens if change is > than sent ? // Collect outgoing metadata let outgoing_json = v.outgoing_metadata.iter() .map(|om| object!{ "address" => om.address.clone(), "value" => om.value, "memo" => LightWallet::memo_str(&Some(om.memo.clone())), }) .collect::>(); txns.push(object! { "block_height" => v.block, "datetime" => v.datetime, "txid" => format!("{}", v.txid), "amount" => total_change as i64 - v.total_shielded_value_spent as i64 - v.total_transparent_value_spent as i64, "outgoing_metadata" => outgoing_json, }); } // For each sapling note that is not a change, add a Tx. txns.extend(v.notes.iter() .filter( |nd| !nd.is_change ) .enumerate() .map ( |(i, nd)| object! { "block_height" => v.block, "datetime" => v.datetime, "position" => i, "txid" => format!("{}", v.txid), "amount" => nd.note.value as i64, "address" => LightWallet::note_address(self.config.hrp_sapling_address(), nd), "memo" => LightWallet::memo_str(&nd.memo), }) ); // Get the total transparent received let total_transparent_received = v.utxos.iter().map(|u| u.value).sum::(); if total_transparent_received > v.total_transparent_value_spent { // Create an input transaction for the transparent value as well. txns.push(object!{ "block_height" => v.block, "datetime" => v.datetime, "txid" => format!("{}", v.txid), "amount" => total_transparent_received as i64 - v.total_transparent_value_spent as i64, "address" => v.utxos.iter().map(|u| u.address.clone()).collect::>().join(","), "memo" => None:: }) } txns }) .collect::>(); // Add the incoming Mempool - incoming_mempool flag is atm useless, but we can use that in future maybe tx_list.extend( wallet.incoming_mempool_txs.read().unwrap().iter().flat_map(|(_, wtxs)| { wtxs.iter().flat_map(|wtx| { wtx.incoming_metadata.iter() .enumerate() .map(move |(i, om)| object! { "block_height" => wtx.block.clone(), "datetime" => wtx.datetime.clone(), "position" => i, "txid" => format!("{}", wtx.txid), "amount" => om.value as i64, "address" => om.address.clone(), "memo" => LightWallet::memo_str(&Some(om.memo.clone())), "unconfirmed" => true, "incoming_mempool" => true, } ) }) }) ); // Add in all mempool txns tx_list.extend(wallet.mempool_txs.read().unwrap().iter().map( |(_, wtx)| { use zcash_primitives::transaction::components::amount::DEFAULT_FEE; use std::convert::TryInto; let amount: u64 = wtx.outgoing_metadata.iter().map(|om| om.value).sum::(); let fee: u64 = DEFAULT_FEE.try_into().unwrap(); // Collect outgoing metadata let outgoing_json = wtx.outgoing_metadata.iter() .map(|om| object!{ "address" => om.address.clone(), "value" => om.value, "memo" => LightWallet::memo_str(&Some(om.memo.clone())), }).collect::>(); object! { "block_height" => wtx.block, "datetime" => wtx.datetime, "txid" => format!("{}", wtx.txid), "amount" => -1 * (fee + amount) as i64, "unconfirmed" => true, "outgoing_metadata" => outgoing_json, } })); tx_list.sort_by( |a, b| if a["block_height"] == b["block_height"] { a["txid"].as_str().cmp(&b["txid"].as_str()) } else { a["block_height"].as_i32().cmp(&b["block_height"].as_i32()) } ); JsonValue::Array(tx_list) } /// Create a new address, deriving it from the seed. pub fn do_new_address(&self, addr_type: &str) -> Result { if !self.wallet.read().unwrap().is_unlocked_for_spending() { error!("Wallet is locked"); return Err("Wallet is locked".to_string()); } let new_address = { let wallet = self.wallet.write().unwrap(); let addr = match addr_type { "zs" => wallet.add_zaddr(), "R" => wallet.add_taddr(), _ => { let e = format!("Unrecognized address type: {}", addr_type); error!("{}", e); return Err(e); } }; if addr.starts_with("Error") { let e = format!("Error creating new address: {}", addr); error!("{}", e); return Err(e); } addr }; self.do_save()?; Ok(array![new_address]) } /// Import a new private key pub fn do_import_tk(&self, sk: String, birthday: u64) -> Result { // Checked before "locked": unlocking would not help (s1-D1). No "Error: " prefix here; the console // import/timport commands add it. if self.wallet.read().unwrap().is_encrypted() { let e = "Can't import a private key while the wallet is encrypted - remove encryption, import, then encrypt again".to_string(); error!("{}", e); return Err(e); } if !self.wallet.read().unwrap().is_unlocked_for_spending() { error!("Wallet is locked"); return Err("Wallet is locked".to_string()); } let new_address = { let mut wallet = self.wallet.write().unwrap(); let addr = wallet.import_taddr(sk, birthday); if addr.starts_with("Error") { let e = format!("Error creating new address{}", addr); error!("{}", e); return Err(e); } addr }; self.do_save()?; Ok(array![new_address]) } // Start Mempool-Monitor pub fn start_mempool_monitor(lc: Arc) -> Result<(), String> { let config = lc.config.clone(); let uri = config.server.clone(); // TLS verification follows the config (default on), as block sync does; `dangerous` is the only bypass. let no_cert = config.no_cert_verification; let shutdown = lc.shutdown_flag.clone(); let (incoming_mempool_tx, incoming_mempool_rx) = std::sync::mpsc::channel::(); // Thread for receive transactions let shutdown_rx = lc.shutdown_flag.clone(); std::thread::spawn(move || { while let Ok(rtx) = incoming_mempool_rx.recv() { if shutdown_rx.load(Ordering::Relaxed) { break; } if let Ok(tx) = Transaction::read( &rtx.data[..]) { let light_wallet_clone = lc.wallet.clone(); // One bad mempool tx must not end this thread: the mempool monitor would stop silently. let scanned = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| { light_wallet_clone.read().unwrap().scan_full_mempool_tx(&tx, rtx.height as i32, 0, true); })); if scanned.is_err() { error!("Scanning mempool tx {} panicked; skipped it", tx.txid()); } } } }); // Thread mempool monitor std::thread::spawn(move || { let mut rt = Runtime::new().unwrap(); rt.block_on(async { loop { if shutdown.load(Ordering::Relaxed) { info!("Mempool monitor shutting down"); break; } let incoming_mempool_tx_clone = incoming_mempool_tx.clone(); let send_closure = move |rtx: RawTransaction| { incoming_mempool_tx_clone.send(rtx).map_err(|e| Box::new(e) as Box) }; match grpcconnector::monitor_mempool(&uri.clone(), no_cert, send_closure).await { Ok(_) => info!("Mempool monitor loop successful"), Err(e) => { // If the server doesn't implement GetMempoolStream, stop the monitor instead // of reconnecting forever against a method that will never succeed (log spam // + needless churn). Other errors fall through to the periodic retry below. if e.to_string().contains("Unimplemented") { info!("Server does not implement GetMempoolStream; stopping mempool monitor"); return; } warn!("Mempool monitor returned {:?}, will restart listening", e); } } // Sleep in 1-second increments so we can check shutdown flag for _ in 0..10 { if shutdown.load(Ordering::Relaxed) { info!("Mempool monitor shutting down during sleep"); return; } std::thread::sleep(Duration::from_secs(1)); } } }); }); Ok(()) } /// Signal all background threads to stop pub fn shutdown(&self) { self.shutdown_flag.store(true, Ordering::Relaxed); info!("Shutdown flag set"); } /// Convinence function to determine what type of key this is and import it pub fn do_import_key(&self, key: String, birthday: u64) -> Result { if key.starts_with(self.config.hrp_sapling_private_key()) { self.do_import_sk(key, birthday) } else if key.starts_with(self.config.hrp_sapling_viewing_key()) { self.do_import_vk(key, birthday) } else { Err(format!("'{}' was not recognized as either a spending key or a viewing key because it didn't start with either '{}' or '{}'", key, self.config.hrp_sapling_private_key(), self.config.hrp_sapling_viewing_key())) } } /// Import a new private key pub fn do_import_sk(&self, sk: String, birthday: u64) -> Result { // Checked before "locked": unlocking would not help (s1-D1). No "Error: " prefix here; the console // import/timport commands add it. if self.wallet.read().unwrap().is_encrypted() { let e = "Can't import a private key while the wallet is encrypted - remove encryption, import, then encrypt again".to_string(); error!("{}", e); return Err(e); } if !self.wallet.read().unwrap().is_unlocked_for_spending() { error!("Wallet is locked"); return Err("Wallet is locked".to_string()); } let new_address = { let mut wallet = self.wallet.write().unwrap(); let addr = wallet.add_imported_sk(sk, birthday); if addr.starts_with("Error") { let e = format!("Error creating new address{}", addr); error!("{}", e); return Err(e); } addr }; self.do_save()?; Ok(array![new_address]) } /// Import a new viewing key pub fn do_import_vk(&self, vk: String, birthday: u64) -> Result { if !self.wallet.read().unwrap().is_unlocked_for_spending() { error!("Wallet is locked"); return Err("Wallet is locked".to_string()); } let new_address = { let mut wallet = self.wallet.write().unwrap(); let addr = wallet.add_imported_vk(vk, birthday); if addr.starts_with("Error") { let e = format!("Error creating new address{}", addr); error!("{}", e); return Err(e); } addr }; self.do_save()?; Ok(array![new_address]) } pub fn do_new_sietchaddress(&self, addr_type: &str) -> Result { let zdust_address = { let wallet = self.wallet.write().unwrap(); match addr_type { "zs" => wallet.add_zaddrdust(), _ => { let e = format!("Unrecognized address type: {}", addr_type); error!("{}", e); return Err(e); } } }; Ok(array![zdust_address]) } pub fn clear_state(&self) { // Read the birthday into a local first: the wallet read guard must NOT be alive while // clear_state_from waits for sync_lock (lock order is sync_lock -> wallet, as in do_save/do_sync). // Held across the call it was also a recursive read lock, which a queued writer (a save) deadlocks. let birthday = self.wallet.read().unwrap().get_birthday(); self.clear_state_from(birthday); } pub fn clear_state_from(&self, height: u64) { // Serialize with sync/save/send: a sync that has already snapshotted the wallet's notes would // otherwise find them gone mid-scan. No caller holds sync_lock, and the order is sync_lock -> wallet. let _sync = self.sync_lock.lock().unwrap(); // First, clear the state from the wallet self.wallet.read().unwrap().clear_blocks(); // Then set the initial block self.set_wallet_initial_state(height); info!("Cleared wallet state to height {}", height); } pub fn do_rescan(&self) -> Result { if !self.wallet.read().unwrap().is_unlocked_for_spending() { warn!("Wallet is locked, new HD addresses won't be added!"); } info!("Rescan starting"); self.clear_state(); // Then, do a sync, which will force a full rescan from the initial state let response = self.do_sync(true); self.do_save()?; info!("Rescan finished"); response } /// Return the syncing status of the wallet pub fn do_scan_status(&self) -> WalletStatus { self.sync_status.read().unwrap().clone() } pub fn do_sync(&self, print_updates: bool) -> Result { let mut retry_count = 0; loop { match self.do_sync_internal(print_updates, retry_count) { Ok(j) => return Ok(j), Err(e) => { retry_count += 1; if retry_count > 5 { return Err(e); } // Sleep exponentially backing off std::thread::sleep(std::time::Duration::from_secs((2 as u64).pow(retry_count))); } } } } pub fn do_shield(&self, address: Option) -> Result { use zcash_primitives::transaction::components::amount::DEFAULT_FEE; use std::convert::TryInto; let fee = DEFAULT_FEE.try_into().unwrap(); let tbal = self.wallet.read().unwrap().tbalance(None); // Make sure there is a balance, and it is greated than the amount if tbal <= fee { return Err(format!("Not enough transparent balance to shield. Have {} puposhis, need more than {} puposhis to cover tx fee", tbal, fee)); } let addr = address.or(self.wallet.read().unwrap().get_all_zaddresses().get(0).map(|s| s.clone())).unwrap(); let fee: u64 = DEFAULT_FEE.try_into().unwrap(); let result = { let _lock = self.sync_lock.lock().unwrap(); self.wallet.read().unwrap().send_to_address( u32::from_str_radix(&self.config.consensus_branch_id, 16).unwrap(), &self.sapling_spend, &self.sapling_output, true, vec![(&addr, tbal - fee, None)], &fee, |txbytes| broadcast_raw_tx(&self.get_server_uri(),self.config.no_cert_verification, txbytes) ) }; result.map(|(txid, _)| txid) } fn do_sync_internal(&self, print_updates: bool, retry_count: u32) -> Result { // We can only do one sync at a time because we sync blocks in serial order // If we allow multiple syncs, they'll all get jumbled up. let _lock = self.sync_lock.lock().unwrap(); // Sync is 3 parts // 1. Get the latest block // 2. Get all the blocks that we don't have // 3. Find all new Txns that don't have the full Tx, and get them as full transactions // and scan them, mainly to get the memos let mut last_scanned_height = self.wallet.read().unwrap().last_scanned_height() as u64; // This will hold the latest block fetched from the RPC let latest_block = fetch_latest_block(&self.get_server_uri(), self.config.no_cert_verification)?.height; if latest_block < last_scanned_height { let w = format!("Server's latest block({}) is behind ours({})", latest_block, last_scanned_height); warn!("{}", w); return Err(w); } info!("Latest block is {}", latest_block); // Get the end height to scan to. // get_block_range streams an ENTIRE range over ONE gRPC connection, so the batch size is // the dominant factor in how many TCP connections a sync opens. The old 1000 meant ~1300 // connections for a full sync, which on Windows exhausted socket buffers (WSAENOBUFS / os // error 10055). A large batch (25k) cuts that ~50x (~52 connections for a full sync) with // no extra memory — blocks are still streamed + scanned incrementally, not buffered. let scan_batch_size = 25000; let mut end_height = std::cmp::min(last_scanned_height + scan_batch_size, latest_block); // If there's nothing to scan, just return if last_scanned_height == latest_block { info!("Nothing to sync, returning"); return Ok(object!{ "result" => "success" }) } { let mut status = self.sync_status.write().unwrap(); status.is_syncing = true; status.synced_blocks = last_scanned_height; status.total_blocks = latest_block; } // Count how many bytes we've downloaded let bytes_downloaded = Arc::new(AtomicUsize::new(0)); let mut total_reorg = 0; // Collect all txns in blocks that we have a tx in. We'll fetch all these // txs along with our own, so that the server doesn't learn which ones // belong to us. let all_new_txs = Arc::new(RwLock::new(vec![])); // Create a new threadpool (upto 8, atleast 2 threads) to scan with let pool = ThreadPool::new(max(2, min(8, num_cpus::get()))); // Create a single Tokio runtime for all block fetches to avoid per-batch overhead let mut rt = tokio::runtime::Runtime::new() .map_err(|e| format!("Error creating runtime: {:?}", e))?; // Fetch CompactBlocks in increments let mut pass = 0; loop { pass +=1 ; // Collect all block times, because we'll need to update transparent tx // datetime via the block height timestamp let block_times = Arc::new(RwLock::new(HashMap::new())); let local_light_wallet = self.wallet.clone(); let local_bytes_downloaded = bytes_downloaded.clone(); let start_height = last_scanned_height + 1; info!("Start height is {}", start_height); // Show updates only if we're syncing a lot of blocks if print_updates && (latest_block - start_height) > 100 { print!("Syncing {}/{}\r", start_height, latest_block); io::stdout().flush().ok().expect("Could not flush stdout"); } { let mut status = self.sync_status.write().unwrap(); status.is_syncing = true; status.synced_blocks = start_height; status.total_blocks = latest_block; } // Fetch compact blocks info!("Fetching blocks {}-{}", start_height, end_height); let all_txs = all_new_txs.clone(); let block_times_inner = block_times.clone(); let last_invalid_height = Arc::new(AtomicI32::new(0)); let last_invalid_height_inner = last_invalid_height.clone(); let tpool = pool.clone(); fetch_blocks_with_runtime(&mut rt, &self.get_server_uri(), start_height, end_height, self.config.no_cert_verification, pool.clone(), move |encoded_block: &[u8], height: u64| { // Process the block only if there were no previous errors if last_invalid_height_inner.load(Ordering::SeqCst) > 0 { return; } // Parse the block and save it's time. We'll use this timestamp for // transactions in this block that might belong to us. let block: Result = parse_from_bytes(encoded_block); match block { Ok(b) => { block_times_inner.write().unwrap().insert(b.height, b.time); }, Err(_) => {} } match local_light_wallet.read().unwrap().scan_block_with_pool(encoded_block, &tpool) { Ok(block_txns) => { // Add to global tx list all_txs.write().unwrap().extend_from_slice(&block_txns.iter().map(|txid| (txid.clone(), height as i32)).collect::>()[..]); }, Err(invalid_height) => { // Block at this height seems to be invalid, so invalidate up till that point last_invalid_height_inner.store(invalid_height, Ordering::SeqCst); } }; local_bytes_downloaded.fetch_add(encoded_block.len(), Ordering::SeqCst); })?; { let t = self.wallet.read().unwrap(); let mut d = t.total_scan_duration.write().unwrap(); d.clear(); d.push(std::time::Duration::new(0, 0)); } // Check if there was any invalid block, which means we might have to do a reorg let invalid_height = last_invalid_height.load(Ordering::SeqCst); if invalid_height > 0 { total_reorg += self.wallet.read().unwrap().invalidate_block(invalid_height); warn!("Invalidated block at height {}. Total reorg is now {}", invalid_height, total_reorg); } // Make sure we're not re-orging too much! if total_reorg > (crate::lightwallet::MAX_REORG - 1) as u64 { error!("Reorg has now exceeded {} blocks!", crate::lightwallet::MAX_REORG); return Err(format!("Reorg has exceeded {} blocks. Aborting.", crate::lightwallet::MAX_REORG)); } if invalid_height > 0 { // Reset the scanning heights last_scanned_height = (invalid_height - 1) as u64; end_height = std::cmp::min(last_scanned_height + scan_batch_size, latest_block); warn!("Reorg: reset scanning from {} to {}", last_scanned_height, end_height); continue; } // If it got here, that means the blocks are scanning properly now. // So, reset the total_reorg total_reorg = 0; // If this is the first pass after a retry, fetch older t address txids too, becuse // they might have been missed last time. let transparent_start_height = if pass == 1 && retry_count > 0 { start_height - scan_batch_size } else { start_height }; // Fetch the txids our transparent addresses are involved with. TLS verification follows the // config (default on); `dangerous` is the only way to turn it off. self.scan_taddress_txids(&pool, block_times, transparent_start_height, end_height, self.config.no_cert_verification)?; // Do block height accounting last_scanned_height = end_height; end_height = last_scanned_height + scan_batch_size; if last_scanned_height >= latest_block { break; } else if end_height > latest_block { end_height = latest_block; } } if print_updates{ println!(""); // New line to finish up the updates } info!("Synced to {}, Downloaded {} kB", latest_block, bytes_downloaded.load(Ordering::SeqCst) / 1024); { let mut status = self.sync_status.write().unwrap(); status.is_syncing = false; status.synced_blocks = latest_block; status.total_blocks = latest_block; } // Get the Raw transaction for all the wallet transactions { let decoy_txids = all_new_txs.read().unwrap(); match self.scan_fill_fulltxs(&mut rt, &pool, decoy_txids.to_vec()) { Ok(_) => Ok(object!{ "result" => "success", "latest_block" => latest_block, "downloaded_bytes" => bytes_downloaded.load(Ordering::SeqCst) }), Err(e) => Err(format!("Error fetching all txns for memos: {}", e)) } } } fn scan_taddress_txids( &self, pool: &ThreadPool, block_times: Arc>>, start_height: u64, end_height: u64, no_cert: bool ) -> Result, String> { // The per-address job: fetch the address's txids and full-scan each tx (scan_full_tx). self.scan_taddress_txids_with(pool, { let wallet = self.wallet.clone(); let server_uri = self.get_server_uri(); move |address: String| -> Result<(), String> { let wallet = wallet.clone(); let block_times = block_times.clone(); fetch_transparent_txids( &server_uri, address, start_height, end_height, no_cert, move |tx_bytes: &[u8], height: u64| { let tx_result = Transaction::read(tx_bytes) .map_err(|e| format!("Failed to read transaction: {:?}", e)); match tx_result { Ok(tx) => { let datetime_result = block_times.read() .map_err(|e| format!("Failed to read block times: {:?}", e)) .and_then(|bt| bt.get(&height).cloned().ok_or_else(|| format!("No datetime for height: {}", height))); match datetime_result { Ok(datetime) => { match wallet.read().map_err(|e| format!("Failed to read wallet: {:?}", e)) { Ok(w) => { w.scan_full_tx(&tx, height as i32, datetime as u64); }, Err(e) => { error!("Error reading wallet: {}", e); }, } }, Err(e) => { error!("Error processing transaction: {}", e); }, } }, Err(e) => { error!("Error reading transaction: {}", e); }, } } ) } }) } // The t-address collector; `job` is the per-address work (a private seam, so a test can make a job panic). Every // job sends exactly one result, a panicking one included, and only the jobs hold senders: the collector can // neither wait forever on a job that died (with sync_lock held) nor report a partial scan as success. fn scan_taddress_txids_with(&self, pool: &ThreadPool, job: F) -> Result, String> where F: Fn(String) -> Result<(), String> + Send + Sync + 'static { let addresses = self.wallet.read() .map_err(|e| format!("Failed to read wallet: {:?}", e))? .get_all_taddresses().iter() .cloned() .collect::>(); let job = Arc::new(job); let (ctx, crx) = channel(); let num_addresses = addresses.len(); for address in addresses { let address_clone = address.clone(); let ctx = ctx.clone(); let job = job.clone(); pool.execute(move || { let r = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| (*job)(address))) .unwrap_or_else(|_| Err("t-address scan job panicked".to_string())); match ctx.send(r) { Ok(_) => info!("Successfully sent data for address: {}", address_clone), Err(e) => error!("Failed to send data for address: {}: {:?}", address_clone, e), } }); } drop(ctx); // Ends once every job has sent its result and dropped its sender. let results: Vec> = crx.iter().collect(); if results.len() != num_addresses { return Err(format!("t-address scan: {} of {} jobs reported", results.len(), num_addresses)); } results.into_iter().collect() } fn scan_fill_fulltxs(&self, rt: &mut Runtime, pool: &ThreadPool, decoy_txids: Vec<(TxId, i32)>) -> Result<(), String> { // We need to first copy over the Txids from the wallet struct, because // we need to free the read lock from here (Because we'll self.wallet.txs later) let own_txids: Vec<(TxId, i32)> = self.wallet.read().unwrap().txs.read().unwrap().values() .filter(|wtx| wtx.full_tx_scanned == false) .map(|wtx| (wtx.txid.clone(), wtx.block)) .collect::>(); info!("Fetching {} new txids, total {} with decoy", own_txids.len(), decoy_txids.len()); // Own txs and decoys go out as ONE (txid, height)-sorted, de-duplicated list, exactly as // before, over one shared connection on the sync runtime. Request order, retries and the // stop rule are identical for own txs and decoys, so the server cannot tell them apart. let (items, own_set) = crate::fulltx_fetch::plan_fetch_list(own_txids, decoy_txids); let policy = crate::fulltx_fetch::FetchPolicy::for_pool(pool); let fetch = grpcconnector::make_shared_tx_fetcher(self.get_server_uri(), self.config.no_cert_verification); let scan = crate::fulltx_fetch::wallet_scan_fn(self.wallet.clone()); crate::fulltx_fetch::run_fetch_scan(rt, items, own_set, policy, pool.clone(), fetch, scan) } pub fn do_send(&self, addrs: Vec<(&str, u64, Option)>, fee: &u64) -> Result { if !self.wallet.read().unwrap().is_unlocked_for_spending() { error!("Wallet is locked"); return Err("Wallet is locked".to_string()); } info!("Creating transaction"); let result = { let _lock = self.sync_lock.lock().unwrap(); self.wallet.write().unwrap().send_to_address( u32::from_str_radix(&self.config.consensus_branch_id, 16).unwrap(), &self.sapling_spend, &self.sapling_output, false, addrs, fee, |txbytes| broadcast_raw_tx(&self.get_server_uri(), self.config.no_cert_verification, txbytes) ) }; result.map(|(txid, _)| txid) } } #[cfg(test)] pub mod tests { use lazy_static::lazy_static; use tempdir::TempDir; use super::{LightClient, LightClientConfig}; lazy_static!{ static ref TEST_SEED: String = "youth strong sweet gorilla hammer unhappy congress stamp left stereo riot salute road tag clean toilet artefact fork certain leopard entire civil degree wonder".to_string(); } // Every client here is on the "main" chain (the "test" chain, which LightClient::unconnected // hard-codes, panics in base58_pubkey_address when the wallet is created) and lives in a temp // data dir, so nothing is ever written to the real ~/.silentdragonxlite. fn main_config(tmp: &TempDir) -> LightClientConfig { LightClientConfig::create_unconnected("main".to_string(), tmp.path().to_str().map(|s| s.to_string())) } #[test] pub fn test_encrypt_decrypt() { let tmp = TempDir::new("lctest").unwrap(); let lc = LightClient::new_from_phrase(TEST_SEED.to_string(), &main_config(&tmp), 0, 0, false).unwrap(); assert!(!lc.do_export(None).is_err()); assert!(!lc.do_new_address("zs").is_err()); assert!(!lc.do_new_address("R").is_err()); assert_eq!(lc.do_seed_phrase().unwrap()["seed"], TEST_SEED.to_string()); // Encrypt and Lock the wallet lc.wallet.write().unwrap().encrypt("password".to_string()).unwrap(); assert!(lc.do_export(None).is_err()); assert!(lc.do_seed_phrase().is_err()); assert!(lc.do_new_address("R").is_err()); assert!(lc.do_new_address("zs").is_err()); assert!(lc.do_send(vec![("zs", 0, None)], &10000).is_err()); // Do a unlock, and make sure it all works now lc.wallet.write().unwrap().unlock("password".to_string()).unwrap(); assert!(!lc.do_export(None).is_err()); assert!(!lc.do_seed_phrase().is_err()); // Can't add keys while unlocked but encrypted assert!(lc.do_new_address("R").is_err()); assert!(lc.do_new_address("zs").is_err()); // Remove encryption, which will allow adding lc.wallet.write().unwrap().remove_encryption("password".to_string()).unwrap(); assert!(lc.do_new_address("R").is_ok()); assert!(lc.do_new_address("zs").is_ok()); } #[test] pub fn test_addresses() { let tmp = TempDir::new("lctest").unwrap(); let lc = LightClient::new_from_phrase(TEST_SEED.to_string(), &main_config(&tmp), 0, 50, false).unwrap(); { let addresses = lc.do_address(); // When restoring from seed with 50 extra z-addresses, there should be 50+1 z and 5+1 t addresses assert_eq!(addresses["z_addresses"].len(), 51); assert_eq!(addresses["t_addresses"].len(), 6); } // Add new z and t addresses let taddr1 = lc.do_new_address("R").unwrap()[0].as_str().unwrap().to_string(); let taddr2 = lc.do_new_address("R").unwrap()[0].as_str().unwrap().to_string(); let zaddr1 = lc.do_new_address("zs").unwrap()[0].as_str().unwrap().to_string(); let zaddr2 = lc.do_new_address("zs").unwrap()[0].as_str().unwrap().to_string(); let addresses = lc.do_address(); assert_eq!(addresses["z_addresses"].len(), 53); assert_eq!(addresses["z_addresses"][51], zaddr1); assert_eq!(addresses["z_addresses"][52], zaddr2); assert_eq!(addresses["t_addresses"].len(), 8); assert_eq!(addresses["t_addresses"][6], taddr1); assert_eq!(addresses["t_addresses"][7], taddr2); use std::sync::{Arc, RwLock, Mutex}; use std::sync::atomic::AtomicBool; use crate::lightclient::{WalletStatus, LightWallet}; // When creating a new wallet, there is only 1 address let tmp2 = TempDir::new("lctest").unwrap(); let config = main_config(&tmp2); let lc = LightClient { wallet : Arc::new(RwLock::new(LightWallet::new(None, &config, 0, 0).unwrap())), config : config, sapling_output : std::borrow::Cow::Borrowed(&[]), sapling_spend : std::borrow::Cow::Borrowed(&[]), sync_lock : Mutex::new(()), sync_status : Arc::new(RwLock::new(WalletStatus::new())), shutdown_flag : Arc::new(AtomicBool::new(false)), }; { let addresses = lc.do_address(); // New wallets have only 1 address assert_eq!(addresses["z_addresses"].len(), 1); assert_eq!(addresses["t_addresses"].len(), 1); } } #[test] pub fn test_bad_import() { let tmp = TempDir::new("lctest").unwrap(); let lc = LightClient::new_from_phrase(TEST_SEED.to_string(), &main_config(&tmp), 0, 0, false).unwrap(); assert!(lc.do_import_sk("bad_priv_key".to_string(), 0).is_err()); assert!(lc.do_import_vk("bad_view_key".to_string(), 0).is_err()); } #[test] pub fn test_wallet_creation() { // Create a new tmp director { let tmp = TempDir::new("lctest").unwrap(); let dir_name = tmp.path().to_str().map(|s| s.to_string()); // A lightclient to a new, empty directory works. let config = LightClientConfig::create_unconnected("main".to_string(), dir_name); let lc = LightClient::new(&config, 0).unwrap(); let seed = lc.do_seed_phrase().unwrap()["seed"].as_str().unwrap().to_string(); lc.do_save().unwrap(); // Doing another new will fail, because the wallet file now already exists assert!(LightClient::new(&config, 0).is_err()); // new_from_phrase will not work either, again, because wallet file exists assert!(LightClient::new_from_phrase(TEST_SEED.to_string(), &config, 0, 0, false).is_err()); // Creating a lightclient to the same dir without a seed should re-read the same wallet // file and therefore the same seed phrase let lc2 = LightClient::read_from_disk(&config).unwrap(); assert_eq!(seed, lc2.do_seed_phrase().unwrap()["seed"].as_str().unwrap().to_string()); } // Now, get a new directory, and try to read from phrase { let tmp = TempDir::new("lctest").unwrap(); let dir_name = tmp.path().to_str().map(|s| s.to_string()); let config = LightClientConfig::create_unconnected("main".to_string(), dir_name); // read_from_disk will fail, because the dir doesn't exist assert!(LightClient::read_from_disk(&config).is_err()); // New from phrase should work becase a file doesn't exist already let lc = LightClient::new_from_phrase(TEST_SEED.to_string(), &config, 0, 0, false).unwrap(); assert_eq!(TEST_SEED.to_string(), lc.do_seed_phrase().unwrap()["seed"].as_str().unwrap().to_string()); lc.do_save().unwrap(); // Now a new will fail because wallet exists assert!(LightClient::new(&config, 0).is_err()); } } #[test] pub fn test_recover_seed() { // Create a new tmp director { let tmp = TempDir::new("lctest").unwrap(); let dir_name = tmp.path().to_str().map(|s| s.to_string()); // A lightclient to a new, empty directory works. let config = LightClientConfig::create_unconnected("main".to_string(), dir_name); let lc = LightClient::new(&config, 0).unwrap(); let seed = lc.do_seed_phrase().unwrap()["seed"].as_str().unwrap().to_string(); lc.do_save().unwrap(); assert_eq!(seed, LightClient::attempt_recover_seed(&config, None).unwrap()); // Now encrypt and save the file let pwd = "password".to_string(); lc.wallet.write().unwrap().encrypt(pwd.clone()).unwrap(); assert_eq!(seed, LightClient::attempt_recover_seed(&config, Some(pwd)).unwrap()); } } // C243 tripwire: the t-address scan and the mempool monitor must take TLS verification from the config // (no_cert_verification, which only `dangerous` sets), never from a hard-coded `true`. The needles are // joined at runtime so that this test's own source cannot match them. #[test] pub fn test_tls_verification_not_hardcoded_off() { let src = include_str!("lightclient.rs"); let taddr_needle = ["let no_cert", "= true"].join(" "); let mempool_needle = ["monitor_mempool(&uri.clone(),", "true"].join(" "); assert!(!src.contains(&taddr_needle), "the t-address scan turns TLS verification off"); assert!(!src.contains(&mempool_needle), "the mempool monitor turns TLS verification off"); } // U2: clear_state/clear_state_from serialize with a running sync (sync_lock) and hold no wallet guard // while they wait for it (lock order sync_lock -> wallet, as in do_save/do_sync). No test joins a thread // that could be deadlocked: they wait on channels with timeouts. fn shared_client(tmp: &TempDir) -> std::sync::Arc { std::sync::Arc::new(LightClient::new_from_phrase(TEST_SEED.to_string(), &main_config(tmp), 0, 0, false).unwrap()) } #[test] pub fn test_clear_state_waits_for_sync_lock() { use std::sync::mpsc::{channel, RecvTimeoutError}; use std::time::Duration; let tmp = TempDir::new("lctest").unwrap(); let lc = shared_client(&tmp); let sync = lc.sync_lock.lock().unwrap(); let (tx, rx) = channel(); let lc2 = lc.clone(); let t = std::thread::spawn(move || { lc2.clear_state_from(0); let _ = tx.send(()); }); let early = rx.recv_timeout(Duration::from_millis(300)); drop(sync); assert_eq!(early, Err(RecvTimeoutError::Timeout), "clear_state_from ran while a sync held sync_lock"); assert!(rx.recv_timeout(Duration::from_secs(5)).is_ok(), "clear_state_from did not finish after the sync ended"); t.join().unwrap(); } #[test] pub fn test_clear_state_holds_no_wallet_guard_while_waiting() { use std::sync::mpsc::channel; use std::time::Duration; let tmp = TempDir::new("lctest").unwrap(); let lc = shared_client(&tmp); let sync = lc.sync_lock.lock().unwrap(); let (btx, brx) = channel(); let lc_b = lc.clone(); let b = std::thread::spawn(move || { lc_b.clear_state(); let _ = btx.send(()); }); std::thread::sleep(Duration::from_millis(200)); let (wtx, wrx) = channel(); let lc_w = lc.clone(); let w = std::thread::spawn(move || { let _g = lc_w.wallet.write().unwrap(); let _ = wtx.send(()); }); let writer_ok = wrx.recv_timeout(Duration::from_secs(2)).is_ok(); let b_early = brx.try_recv().is_ok(); drop(sync); assert!(writer_ok, "clear_state held a wallet read guard while it waited for sync_lock (a concurrent save deadlocks)"); assert!(!b_early, "clear_state finished while a sync held sync_lock"); assert!(brx.recv_timeout(Duration::from_secs(5)).is_ok(), "clear_state did not finish after the sync ended"); b.join().unwrap(); w.join().unwrap(); } #[test] pub fn test_clear_state_does_not_leak_sync_lock() { let tmp = TempDir::new("lctest").unwrap(); let lc = shared_client(&tmp); lc.clear_state(); assert!(lc.sync_lock.try_lock().is_ok(), "clear_state left sync_lock held"); lc.clear_state_from(0); assert!(lc.sync_lock.try_lock().is_ok(), "clear_state_from left sync_lock held"); } // Regression guard only (the race is timing-dependent, so it is no fails-before proof): before the birthday // hoist, clear_state held a wallet read guard across clear_state_from, which read-locks the wallet again; a // writer queued in between deadlocks a writer-preferring RwLock (Linux futex, Windows SRW). #[test] pub fn test_clear_state_no_recursive_read_deadlock() { use std::sync::mpsc::channel; use std::time::{Duration, Instant}; let tmp = TempDir::new("lctest").unwrap(); let lc = shared_client(&tmp); let (tx, rx) = channel(); let (lc_r, tx_r) = (lc.clone(), tx.clone()); let r = std::thread::spawn(move || { for _ in 0..200 { lc_r.clear_state(); } let _ = tx_r.send(()); }); let lc_w = lc.clone(); let w = std::thread::spawn(move || { for _ in 0..200 { let _g = lc_w.wallet.write().unwrap(); } let _ = tx.send(()); }); let deadline = Instant::now() + Duration::from_secs(20); for _ in 0..2 { let left = deadline.saturating_duration_since(Instant::now()); assert!(rx.recv_timeout(left).is_ok(), "clear_state and a wallet writer deadlocked (20 s watchdog)"); } r.join().unwrap(); w.join().unwrap(); } // C251 (s2): a WIF that cannot be decoded returns Err and leaves the wallet lock usable. Before, import_taddr // panicked under the wallet write guard (bs58 unwrap / hex slice), which poisoned the wallet until restart. #[test] pub fn test_bad_import_does_not_poison() { use std::panic::{catch_unwind, AssertUnwindSafe}; let tmp = TempDir::new("lctest").unwrap(); let lc = LightClient::new_from_phrase(TEST_SEED.to_string(), &main_config(&tmp), 0, 0, false).unwrap(); let before = lc.do_address(); for bad in &["zs1notawif", "secret-extended-key-main1qqqqqqqqqq", "", "1"] { let r = catch_unwind(AssertUnwindSafe(|| lc.do_import_tk(bad.to_string(), 0))); let e = match r { Ok(Err(e)) => e, Ok(Ok(a)) => panic!("{:?} imported as {}", bad, a), Err(_) => panic!("do_import_tk({:?}) panicked", bad), }; assert!(e.contains("Couldn't decode the transparent private key"), "{:?}: {}", bad, e); assert!(bad.len() < 2 || !e.contains(bad), "the error echoes the key: {}", e); // separate statements: a read guard alive in the same expression would deadlock the write() assert!(lc.wallet.read().is_ok(), "the wallet lock is poisoned"); assert!(lc.wallet.write().is_ok(), "the wallet lock is poisoned"); } assert_eq!(lc.do_address(), before); } // C252 (s1 test 8): a private-key import into an encrypted wallet is refused with the "encrypted" reason // whether the wallet is locked or unlocked (never "Wallet is locked", which would send the user to unlock and // retry), and it leaves the wallet able to lock, save and show its real seed. Viewing keys still import. #[test] pub fn test_encrypted_import_is_clean() { let tmp = TempDir::new("lctest").unwrap(); let lc = LightClient::new_from_phrase(TEST_SEED.to_string(), &main_config(&tmp), 0, 0, false).unwrap(); let tmp2 = TempDir::new("lctest").unwrap(); let other = LightClient::new(&main_config(&tmp2), 0).unwrap(); let (wif, sk, vk) = { let w = other.wallet.read().unwrap(); let z = w.get_z_private_keys()[0].clone(); (w.get_t_secret_keys()[0].1.clone(), z.1, z.2) }; // encrypt() also locks the wallet lc.wallet.write().unwrap().encrypt("password".to_string()).unwrap(); for &unlocked in &[false, true] { if unlocked { lc.wallet.write().unwrap().unlock("password".to_string()).unwrap(); } for r in vec![lc.do_import_sk(sk.clone(), 0), lc.do_import_tk(wif.clone(), 0), lc.do_import_key(sk.clone(), 0)] { let e = r.err().expect("a private-key import must fail while the wallet is encrypted"); assert!(e.starts_with("Can't import a private key while the wallet is encrypted"), "{}", e); assert!(!e.contains("locked") && !e.contains("decode"), "{}", e); assert!(!e.contains(&wif) && !e.contains(&sk), "the error echoes the key"); } assert_eq!(lc.wallet.read().unwrap().is_unlocked_for_spending(), unlocked); } // A viewing key still imports while encrypted (its save locks the wallet again). assert!(lc.do_import_vk(vk, 0).is_ok()); assert!(!lc.wallet.read().unwrap().is_unlocked_for_spending()); assert!(lc.do_save().is_ok()); lc.wallet.write().unwrap().unlock("password".to_string()).unwrap(); assert_eq!(lc.do_seed_phrase().unwrap()["seed"], TEST_SEED.to_string()); } // C245 Fix 2 (s2-D6a seam). A t-address job that panicked left the collector waiting forever, with sync_lock // held, for a result that never came: the original sender stayed alive. Each job now reports exactly once (a // panic is an Err) and the collector counts the reports. Runs under the 15 s watchdog. #[test] pub fn test_taddress_scan_job_panic_is_error() { let (n, all_ok, one_err, one_panic) = crate::lightwallet::tests::within_watchdog("t-address scan", || { let tmp = TempDir::new("lctest").unwrap(); let lc = LightClient::new(&main_config(&tmp), 0).unwrap(); lc.do_new_address("R").unwrap(); lc.do_new_address("R").unwrap(); let addrs = lc.wallet.read().unwrap().get_all_taddresses(); let pool = threadpool::ThreadPool::new(2); let all_ok = lc.scan_taddress_txids_with(&pool, |_a: String| -> Result<(), String> { Ok(()) }); let a1 = addrs[1].clone(); let one_err = lc.scan_taddress_txids_with(&pool, move |a: String| -> Result<(), String> { if a == a1 { Err("injected error".to_string()) } else { Ok(()) } }); let a1 = addrs[1].clone(); let one_panic = lc.scan_taddress_txids_with(&pool, move |a: String| -> Result<(), String> { if a == a1 { panic!("injected t-address job panic"); } Ok(()) }); (addrs.len(), all_ok, one_err, one_panic) }); assert_eq!(n, 3); assert_eq!(all_ok, Ok(vec![(); 3])); assert_eq!(one_err, Err("injected error".to_string())); assert_eq!(one_panic, Err("t-address scan job panicked".to_string())); } }