[1.1.0] Merge master into 1.1.0 (#2720)

* cleanup legacy "3 dot" check (#2625)

* Allow to peers behind NAT to get up to preferred_max connections (#2543)

Allow to peers behind NAT to get up to preffered_max connections

If peer has only outbound connections it's mot likely behind NAT and we should not stop it from getting more outbound connections

* Reduce usage of unwrap in p2p crate (#2627)

Also change store crate a bit

* Simplify (and fix) output_pos cleanup during chain compaction (#2609)

* expose leaf pos iterator
use it for various things in txhashset when iterating over outputs

* fix

* cleanup

* rebuild output_pos index (and clear it out first) when compacting the chain

* fixup tests

* refactor to match on (output, proof) tuple

* add comments to compact() to explain what is going on.

* get rid of some boxing around the leaf_set iterator

* cleanup

* [docs] Add switch commitment documentation (#2526)

* remove references to no-longer existing switch commitment hash

(as switch commitments were removed in ca8447f3bd
and moved into the blinding factor of the Pedersen Commitment)

* some rewording (points vs curves) and fix of small formatting issues

* Add switch commitment documentation

* [docs] Documents in grin repo had translated in Korean.  (#2604)

*  Start to M/W intro translate in Korean
*  translate in Korean
*  add korean translation  on intro
* table_of_content.md translate in Korean.
*  table_of_content_KR.md finish translate in Korean, start to translate State_KR.md
*  add state_KR.md & commit some translation in State_KR.md
*  WIP stat_KR.md translation
*  add build_KR.md && stratum_KR.md
*  finish translate stratum_KR.md & table_of_content_KR.md
*  rename intro.KR.md to intro_KR.md
*  add intro_KR.md file path each language's  intro.md
*  add Korean translation file path to stratum.md & table_of_contents.md
*  fix difference with grin/master

* Fix TxHashSet file filter for Windows. (#2641)

* Fix TxHashSet file filter for Windows.

* rustfmt

* Updating regexp

* Adding in test case

* Display the current download rate rather than the average when syncing the chain (#2633)

* When syncing the chain, calculate the displayed download speed using the current rate from the most recent iteration, rather than the average download speed from the entire syncing process.

* Replace the explicitly ignored variables in the pattern with an implicit ignore

* remove root = true from editorconfig (#2655)

* Add Medium post to intro (#2654)

Spoke to @yeastplume who agreed it makes sense to add the "Grin Transactions Explained, Step-by-Step" Medium post to intro.md

Open for suggestions on a better location.

* add a new configure item for log_max_files (#2601)

* add a new configure item for log_max_files

* rustfmt

* use a constant instead of multiple 32

* rustfmt

* Fix the build warning of deprecated trim_right_matches (#2662)

* [DOC] state.md, build.md and chain directory documents translate in Korean.  (#2649)

*  add md files for translation.

*  start to translation fast-sync, code_structure. add file build_KR.md, states_KR.md

* add dandelion_KR.md && simulation_KR.md for Korean translation.

*  add md files for translation.

*  start to translation fast-sync, code_structure. add file build_KR.md, states_KR.md

* add dandelion_KR.md && simulation_KR.md for Korean translation.

* remove some useless md files for translation. this is rearrange set up translation order.

*  add dot end of sentence & translate build.md in korean

*  remove fast-sync_KR.md

*  finish build_KR.md translation

*  finish build_KR.md translation

*  finish translation state_KR.md & add phrase in state.md to move other language md file

* translate blocks_and_headers.md && chain_sync.md in Korean

*  add . in chain_sync.md , translation finished in doc/chain dir.

* fix some miss typos

* Api documentation fixes (#2646)

* Fix the API documentation for Chain Validate (v1/chain/validate).  It was documented as a POST, but it is actually a GET request, which can be seen in its handler ChainValidationHandler
* Update the API V1 route list response to include the headers and merkleproof routes.  Also clarify that for the chain/outputs route you must specify either byids or byheight to select outputs.

* refactor(ci): reorganize CI related code (#2658)

Break-down the CI related code into smaller more maintainable pieces.

* Specify grin or nanogrins in API docs where applicable (#2642)

* Set Content-Type in API client (#2680)

* Reduce number of unwraps in chain crate (#2679)

* fix: the restart of state sync doesn't work sometimes (#2687)

* let check_txhashset_needed return true on abnormal case (#2684)

*  Reduce number of unwwaps in api crate  (#2681)

* Reduce number of unwwaps in api crate

* Format use section

* Small QoL improvements for wallet developers (#2651)

* Small changes for wallet devs

* Move create_nonce into Keychain trait

* Replace match by map_err

* Add flag to Slate to skip fee check

* Fix secp dependency

* Remove check_fee flag in Slate

* Add Japanese edition of build.md (#2697)

* catch the panic to avoid peer thread quit early (#2686)

* catch the panic to avoid peer thread quit before taking the chance to ban
* move catch wrapper logic down into the util crate
* log the panic info
* keep txhashset.rs untouched
* remove a warning

* [DOC] dandelion.md, simulation.md ,fast-sync.md and pruning.md documents translate in Korean. (#2678)

* Show response code in API client error message (#2683)

It's hard to investigate what happens when an API client error is
printed out

* Add some better logging for get_outputs_by_id failure states (#2705)

* Switch commitment doc fixes (#2645)

Fix some typos and remove the use of parentheses in a
couple of places to make the reading flow a bit better.

* docs: update/add new README.md badges (#2708)

Replace existing badges with SVG counterparts and add a bunch of new ones.

* Update intro.md (#2702)

Add mention of censoring attack prevented by range proofs

* use sandbox folder for txhashset validation on state sync (#2685)

* use sandbox folder for txhashset validation on state sync

* rustfmt

* use temp directory as the sandbox instead actual db_root txhashset dir

* rustfmt

* move txhashset overwrite to the end of full validation

* fix travis-ci test

* rustfmt

* fix: hashset have 2 folders including txhashset and header

* rustfmt

* 
(1)switch to rebuild_header_mmr instead of copy the sandbox header mmr 
(2)lock txhashset when overwriting and opening and rebuild

* minor improve on sandbox_dir

* add Japanese edition of state.md (#2703)

* Attempt to fix broken TUI locale (#2713)

Can confirm that on the same machine 1.0.2 TUI looks great and is broken on
the current master. Bump of `cursive` version fixed it for me.
Fixes #2676

* clean the header folder in sandbox (#2716)

* forgot to clean the header folder in sandbox in #2685

* Reduce number of unwraps in servers crate (#2707)

It doesn't include stratum server which is sufficiently changed in 1.1
branch and adapters, which is big enough for a separate PR.

* rustfmt

* change version to beta

servers/src/common/adapters.rs

@@ -331,14 +331,20 @@ impl p2p::ChainAdapter for NetToChainAdapter {
 		total_size: u64,
 	) -> bool {
 		match self.sync_state.status() {
-			SyncStatus::TxHashsetDownload { .. } => {
-				self.sync_state
-					.update_txhashset_download(SyncStatus::TxHashsetDownload {
-						start_time,
-						downloaded_size,
-						total_size,
-					})
-			}
+			SyncStatus::TxHashsetDownload {
+				update_time: old_update_time,
+				downloaded_size: old_downloaded_size,
+				..
+			} => self
+				.sync_state
+				.update_txhashset_download(SyncStatus::TxHashsetDownload {
+					start_time,
+					prev_update_time: old_update_time,
+					update_time: Utc::now(),
+					prev_downloaded_size: old_downloaded_size,
+					downloaded_size,
+					total_size,
+				}),
 			_ => false,
 		}
 	}
@@ -358,6 +364,7 @@ impl p2p::ChainAdapter for NetToChainAdapter {
 			.chain()
 			.txhashset_write(h, txhashset_data, self.sync_state.as_ref())
 		{
+			self.chain().clean_txhashset_sandbox();
 			error!("Failed to save txhashset archive: {}", e);
 			let is_good_data = !e.is_bad_data();
 			self.sync_state.set_sync_error(types::Error::Chain(e));

servers/src/common/types.rs

@@ -22,7 +22,8 @@ use rand::prelude::*;
 use crate::api;
 use crate::chain;
 use crate::core::global::ChainTypes;
-use crate::core::{core, pow};
+use crate::core::{core, libtx, pow};
+use crate::keychain;
 use crate::p2p;
 use crate::pool;
 use crate::pool::types::DandelionConfig;
@@ -34,6 +35,8 @@ use crate::util::RwLock;
 pub enum Error {
 	/// Error originating from the core implementation.
 	Core(core::block::Error),
+	/// Error originating from the libtx implementation.
+	LibTx(libtx::Error),
 	/// Error originating from the db storage.
 	Store(store::Error),
 	/// Error originating from the blockchain implementation.
@@ -46,12 +49,18 @@ pub enum Error {
 	Cuckoo(pow::Error),
 	/// Error originating from the transaction pool.
 	Pool(pool::PoolError),
+	/// Error originating from the keychain.
+	Keychain(keychain::Error),
 	/// Invalid Arguments.
 	ArgumentError(String),
 	/// Wallet communication error
 	WalletComm(String),
 	/// Error originating from some I/O operation (likely a file on disk).
 	IOError(std::io::Error),
+	/// Configuration error
+	Configuration(String),
+	/// General error
+	General(String),
 }
 
 impl From<core::block::Error> for Error {
@@ -99,6 +108,18 @@ impl From<pool::PoolError> for Error {
 	}
 }
 
+impl From<keychain::Error> for Error {
+	fn from(e: keychain::Error) -> Error {
+		Error::Keychain(e)
+	}
+}
+
+impl From<libtx::Error> for Error {
+	fn from(e: libtx::Error) -> Error {
+		Error::LibTx(e)
+	}
+}
+
 /// Type of seeding the server will use to find other peers on the network.
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
 pub enum ChainValidationMode {
@@ -299,6 +320,9 @@ pub enum SyncStatus {
 	/// Downloading the various txhashsets
 	TxHashsetDownload {
 		start_time: DateTime<Utc>,
+		prev_update_time: DateTime<Utc>,
+		update_time: DateTime<Utc>,
+		prev_downloaded_size: u64,
 		downloaded_size: u64,
 		total_size: u64,
 	},

servers/src/grin/dandelion_monitor.rs

@@ -183,6 +183,5 @@ fn process_expired_entries(
 			Err(e) => warn!("dand_mon: failed to fluff expired tx {}, {:?}", txhash, e),
 		};
 	}
-
 	Ok(())
 }

servers/src/grin/seed.rs

@@ -292,7 +292,7 @@ fn listen_for_addrs(
 	let addrs: Vec<PeerAddr> = rx.try_iter().collect();
 
 	// If we have a healthy number of outbound peers then we are done here.
-	if peers.healthy_peers_mix() {
+	if peers.peer_count() > peers.peer_outbound_count() && peers.healthy_peers_mix() {
 		return;
 	}
 
@@ -312,7 +312,9 @@ fn listen_for_addrs(
 				);
 				continue;
 			} else {
-				*connecting_history.get_mut(&addr).unwrap() = now;
+				if let Some(history) = connecting_history.get_mut(&addr) {
+					*history = now;
+				}
 			}
 		}
 		connecting_history.insert(addr, now);

servers/src/grin/server.rs

@@ -219,9 +219,14 @@ impl Server {
 					warn!("No seed configured, will stay solo until connected to");
 					seed::predefined_seeds(vec![])
 				}
-				p2p::Seeding::List => {
-					seed::predefined_seeds(config.p2p_config.seeds.clone().unwrap())
-				}
+				p2p::Seeding::List => match &config.p2p_config.seeds {
+					Some(seeds) => seed::predefined_seeds(seeds.clone()),
+					None => {
+						return Err(Error::Configuration(
+							"Seeds must be configured for seeding type List".to_owned(),
+						));
+					}
+				},
 				p2p::Seeding::DNSSeed => seed::dns_seeds(),
 				_ => unreachable!(),
 			};
@@ -388,13 +393,13 @@ impl Server {
 	}
 
 	/// The chain head
-	pub fn head(&self) -> chain::Tip {
-		self.chain.head().unwrap()
+	pub fn head(&self) -> Result<chain::Tip, Error> {
+		self.chain.head().map_err(|e| e.into())
 	}
 
 	/// The head of the block header chain
-	pub fn header_head(&self) -> chain::Tip {
-		self.chain.header_head().unwrap()
+	pub fn header_head(&self) -> Result<chain::Tip, Error> {
+		self.chain.header_head().map_err(|e| e.into())
 	}
 
 	/// Returns a set of stats about this server. This and the ServerStats
@@ -412,11 +417,11 @@ impl Server {
 		// for release
 		let diff_stats = {
 			let last_blocks: Vec<consensus::HeaderInfo> =
-				global::difficulty_data_to_vector(self.chain.difficulty_iter())
+				global::difficulty_data_to_vector(self.chain.difficulty_iter()?)
 					.into_iter()
 					.collect();
 
-			let tip_height = self.chain.head().unwrap().height as i64;
+			let tip_height = self.head()?.height as i64;
 			let mut height = tip_height as i64 - last_blocks.len() as i64 + 1;
 
 			let txhashset = self.chain.txhashset();
@@ -474,8 +479,8 @@ impl Server {
 			.collect();
 		Ok(ServerStats {
 			peer_count: self.peer_count(),
-			head: self.head(),
-			header_head: self.header_head(),
+			head: self.head()?,
+			header_head: self.header_head()?,
 			sync_status: self.sync_state.status(),
 			stratum_stats: stratum_stats,
 			peer_stats: peer_stats,

servers/src/grin/sync/body_sync.rs

@@ -51,11 +51,15 @@ impl BodySync {
 
 	/// Check whether a body sync is needed and run it if so.
 	/// Return true if txhashset download is needed (when requested block is under the horizon).
-	pub fn check_run(&mut self, head: &chain::Tip, highest_height: u64) -> bool {
+	pub fn check_run(
+		&mut self,
+		head: &chain::Tip,
+		highest_height: u64,
+	) -> Result<bool, chain::Error> {
 		// run the body_sync every 5s
-		if self.body_sync_due() {
-			if self.body_sync() {
-				return true;
+		if self.body_sync_due()? {
+			if self.body_sync()? {
+				return Ok(true);
 			}
 
 			self.sync_state.update(SyncStatus::BodySync {
@@ -63,23 +67,37 @@ impl BodySync {
 				highest_height: highest_height,
 			});
 		}
-		false
+		Ok(false)
 	}
 
 	/// Return true if txhashset download is needed (when requested block is under the horizon).
-	fn body_sync(&mut self) -> bool {
+	fn body_sync(&mut self) -> Result<bool, chain::Error> {
 		let mut hashes: Option<Vec<Hash>> = Some(vec![]);
-		if self
+		let txhashset_needed = match self
 			.chain
 			.check_txhashset_needed("body_sync".to_owned(), &mut hashes)
 		{
+			Ok(v) => v,
+			Err(e) => {
+				error!("body_sync: failed to call txhashset_needed: {:?}", e);
+				return Ok(false);
+			}
+		};
+		if txhashset_needed {
 			debug!(
 				"body_sync: cannot sync full blocks earlier than horizon. will request txhashset",
 			);
-			return true;
+			return Ok(true);
 		}
 
-		let mut hashes = hashes.unwrap();
+		let mut hashes = match hashes {
+			Some(v) => v,
+			None => {
+				error!("unexpected: hashes is None");
+				return Ok(false);
+			}
+		};
+
 		hashes.reverse();
 
 		let peers = self.peers.more_work_peers();
@@ -103,8 +121,8 @@ impl BodySync {
 			.collect::<Vec<_>>();
 
 		if hashes_to_get.len() > 0 {
-			let body_head = self.chain.head().unwrap();
-			let header_head = self.chain.header_head().unwrap();
+			let body_head = self.chain.head()?;
+			let header_head = self.chain.header_head()?;
 
 			debug!(
 				"block_sync: {}/{} requesting blocks {:?} from {} peers",
@@ -129,12 +147,12 @@ impl BodySync {
 				}
 			}
 		}
-		return false;
+		return Ok(false);
 	}
 
 	// Should we run block body sync and ask for more full blocks?
-	fn body_sync_due(&mut self) -> bool {
-		let blocks_received = self.blocks_received();
+	fn body_sync_due(&mut self) -> Result<bool, chain::Error> {
+		let blocks_received = self.blocks_received()?;
 
 		// some blocks have been requested
 		if self.blocks_requested > 0 {
@@ -145,7 +163,7 @@ impl BodySync {
 					"body_sync: expecting {} more blocks and none received for a while",
 					self.blocks_requested,
 				);
-				return true;
+				return Ok(true);
 			}
 		}
 
@@ -162,16 +180,16 @@ impl BodySync {
 		if self.blocks_requested < 2 {
 			// no pending block requests, ask more
 			debug!("body_sync: no pending block request, asking more");
-			return true;
+			return Ok(true);
 		}
 
-		return false;
+		Ok(false)
 	}
 
 	// Total numbers received on this chain, including the head and orphans
-	fn blocks_received(&self) -> u64 {
-		self.chain.head().unwrap().height
+	fn blocks_received(&self) -> Result<u64, chain::Error> {
+		Ok((self.chain.head()?).height
 			+ self.chain.orphans_len() as u64
-			+ self.chain.orphans_evicted_len() as u64
+			+ self.chain.orphans_evicted_len() as u64)
 	}
 }

servers/src/grin/sync/header_sync.rs

@@ -50,9 +50,13 @@ impl HeaderSync {
 		}
 	}
 
-	pub fn check_run(&mut self, header_head: &chain::Tip, highest_height: u64) -> bool {
+	pub fn check_run(
+		&mut self,
+		header_head: &chain::Tip,
+		highest_height: u64,
+	) -> Result<bool, chain::Error> {
 		if !self.header_sync_due(header_head) {
-			return false;
+			return Ok(false);
 		}
 
 		let enable_header_sync = match self.sync_state.status() {
@@ -60,7 +64,7 @@ impl HeaderSync {
 			| SyncStatus::HeaderSync { .. }
 			| SyncStatus::TxHashsetDone => true,
 			SyncStatus::NoSync | SyncStatus::Initial | SyncStatus::AwaitingPeers(_) => {
-				let sync_head = self.chain.get_sync_head().unwrap();
+				let sync_head = self.chain.get_sync_head()?;
 				debug!(
 					"sync: initial transition to HeaderSync. sync_head: {} at {}, resetting to: {} at {}",
 					sync_head.hash(),
@@ -77,10 +81,10 @@ impl HeaderSync {
 				// correctly, so reset any previous (and potentially stale) sync_head to match
 				// our last known "good" header_head.
 				//
-				self.chain.reset_sync_head().unwrap();
+				self.chain.reset_sync_head()?;
 
 				// Rebuild the sync MMR to match our updated sync_head.
-				self.chain.rebuild_sync_mmr(&header_head).unwrap();
+				self.chain.rebuild_sync_mmr(&header_head)?;
 
 				self.history_locator.retain(|&x| x.0 == 0);
 				true
@@ -95,9 +99,9 @@ impl HeaderSync {
 			});
 
 			self.syncing_peer = self.header_sync();
-			return true;
+			return Ok(true);
 		}
-		false
+		Ok(false)
 	}
 
 	fn header_sync_due(&mut self, header_head: &chain::Tip) -> bool {

servers/src/grin/sync/state_sync.rs

@@ -113,7 +113,7 @@ impl StateSync {
 		}
 
 		// run fast sync if applicable, normally only run one-time, except restart in error
-		if header_head.height == highest_height {
+		if sync_need_restart || header_head.height == highest_height {
 			let (go, download_timeout) = self.state_sync_due();
 
 			if let SyncStatus::TxHashsetDownload { .. } = self.sync_state.status() {
@@ -147,6 +147,9 @@ impl StateSync {
 
 				self.sync_state.update(SyncStatus::TxHashsetDownload {
 					start_time: Utc::now(),
+					prev_update_time: Utc::now(),
+					update_time: Utc::now(),
+					prev_downloaded_size: 0,
 					downloaded_size: 0,
 					total_size: 0,
 				});
@@ -163,9 +166,25 @@ impl StateSync {
 			let mut txhashset_head = self
 				.chain
 				.get_block_header(&header_head.prev_block_h)
-				.unwrap();
+				.map_err(|e| {
+					error!(
+						"chain error dirung getting a block header {}: {:?}",
+						&header_head.prev_block_h, e
+					);
+					p2p::Error::Internal
+				})?;
 			for _ in 0..threshold {
-				txhashset_head = self.chain.get_previous_header(&txhashset_head).unwrap();
+				txhashset_head = self
+					.chain
+					.get_previous_header(&txhashset_head)
+					.map_err(|e| {
+						error!(
+							"chain error dirung getting a previous block header {}: {:?}",
+							txhashset_head.hash(),
+							e
+						);
+						p2p::Error::Internal
+					})?;
 			}
 			let bhash = txhashset_head.hash();
 			debug!(

servers/src/grin/sync/syncer.rs

@@ -62,7 +62,7 @@ impl SyncRunner {
 		}
 	}
 
-	fn wait_for_min_peers(&self) {
+	fn wait_for_min_peers(&self) -> Result<(), chain::Error> {
 		// Initial sleep to give us time to peer with some nodes.
 		// Note: Even if we have skip peer wait we need to wait a
 		// short period of time for tests to do the right thing.
@@ -72,7 +72,7 @@ impl SyncRunner {
 			3
 		};
 
-		let head = self.chain.head().unwrap();
+		let head = self.chain.head()?;
 
 		let mut n = 0;
 		const MIN_PEERS: usize = 3;
@@ -95,12 +95,27 @@ impl SyncRunner {
 			thread::sleep(time::Duration::from_secs(1));
 			n += 1;
 		}
+		Ok(())
 	}
 
 	/// Starts the syncing loop, just spawns two threads that loop forever
 	fn sync_loop(&self) {
+		macro_rules! unwrap_or_restart_loop(
+	($obj: expr) =>(
+		match $obj {
+			Ok(v) => v,
+			Err(e) => {
+				error!("unexpected error: {:?}", e);
+				thread::sleep(time::Duration::from_secs(1));
+				continue;
+			},
+		}
+	));
+
 		// Wait for connections reach at least MIN_PEERS
-		self.wait_for_min_peers();
+		if let Err(e) = self.wait_for_min_peers() {
+			error!("wait_for_min_peers failed: {:?}", e);
+		}
 
 		// Our 3 main sync stages
 		let mut header_sync = HeaderSync::new(
@@ -132,8 +147,7 @@ impl SyncRunner {
 			thread::sleep(time::Duration::from_millis(10));
 
 			// check whether syncing is generally needed, when we compare our state with others
-			let (syncing, most_work_height) = self.needs_syncing();
-
+			let (syncing, most_work_height) = unwrap_or_restart_loop!(self.needs_syncing());
 			if most_work_height > 0 {
 				// we can occasionally get a most work height of 0 if read locks fail
 				highest_height = most_work_height;
@@ -147,13 +161,13 @@ impl SyncRunner {
 			}
 
 			// if syncing is needed
-			let head = self.chain.head().unwrap();
+			let head = unwrap_or_restart_loop!(self.chain.head());
 			let tail = self.chain.tail().unwrap_or_else(|_| head.clone());
-			let header_head = self.chain.header_head().unwrap();
+			let header_head = unwrap_or_restart_loop!(self.chain.header_head());
 
 			// run each sync stage, each of them deciding whether they're needed
 			// except for state sync that only runs if body sync return true (means txhashset is needed)
-			header_sync.check_run(&header_head, highest_height);
+			unwrap_or_restart_loop!(header_sync.check_run(&header_head, highest_height));
 
 			let mut check_state_sync = false;
 			match self.sync_state.status() {
@@ -168,7 +182,15 @@ impl SyncRunner {
 						continue;
 					}
 
-					if body_sync.check_run(&head, highest_height) {
+					let check_run = match body_sync.check_run(&head, highest_height) {
+						Ok(v) => v,
+						Err(e) => {
+							error!("check_run failed: {:?}", e);
+							continue;
+						}
+					};
+
+					if check_run {
 						check_state_sync = true;
 					}
 				}
@@ -182,8 +204,8 @@ impl SyncRunner {
 
 	/// Whether we're currently syncing the chain or we're fully caught up and
 	/// just receiving blocks through gossip.
-	fn needs_syncing(&self) -> (bool, u64) {
-		let local_diff = self.chain.head().unwrap().total_difficulty;
+	fn needs_syncing(&self) -> Result<(bool, u64), chain::Error> {
+		let local_diff = self.chain.head()?.total_difficulty;
 		let mut is_syncing = self.sync_state.is_syncing();
 		let peer = self.peers.most_work_peer();
 
@@ -191,14 +213,14 @@ impl SyncRunner {
 			p.info.clone()
 		} else {
 			warn!("sync: no peers available, disabling sync");
-			return (false, 0);
+			return Ok((false, 0));
 		};
 
 		// if we're already syncing, we're caught up if no peer has a higher
 		// difficulty than us
 		if is_syncing {
 			if peer_info.total_difficulty() <= local_diff {
-				let ch = self.chain.head().unwrap();
+				let ch = self.chain.head()?;
 				info!(
 					"synchronized at {} @ {} [{}]",
 					local_diff.to_num(),
@@ -209,12 +231,20 @@ impl SyncRunner {
 			}
 		} else {
 			// sum the last 5 difficulties to give us the threshold
-			let threshold = self
-				.chain
-				.difficulty_iter()
-				.map(|x| x.difficulty)
-				.take(5)
-				.fold(Difficulty::zero(), |sum, val| sum + val);
+			let threshold = {
+				let diff_iter = match self.chain.difficulty_iter() {
+					Ok(v) => v,
+					Err(e) => {
+						error!("failed to get difficulty iterator: {:?}", e);
+						// we handle 0 height in the caller
+						return Ok((false, 0));
+					}
+				};
+				diff_iter
+					.map(|x| x.difficulty)
+					.take(5)
+					.fold(Difficulty::zero(), |sum, val| sum + val)
+			};
 
 			let peer_diff = peer_info.total_difficulty();
 			if peer_diff > local_diff.clone() + threshold.clone() {
@@ -227,6 +257,6 @@ impl SyncRunner {
 				is_syncing = true;
 			}
 		}
-		(is_syncing, peer_info.height())
+		Ok((is_syncing, peer_info.height()))
 	}
 }

servers/src/mining/mine_block.rs

@@ -138,7 +138,7 @@ fn build_block(
 
 	// Determine the difficulty our block should be at.
 	// Note: do not keep the difficulty_iter in scope (it has an active batch).
-	let difficulty = consensus::next_difficulty(head.height + 1, chain.difficulty_iter());
+	let difficulty = consensus::next_difficulty(head.height + 1, chain.difficulty_iter()?);
 
 	// Extract current "mineable" transactions from the pool.
 	// If this fails for *any* reason then fallback to an empty vec of txs.
@@ -212,7 +212,7 @@ fn build_block(
 ///
 fn burn_reward(block_fees: BlockFees) -> Result<(core::Output, core::TxKernel, BlockFees), Error> {
 	warn!("Burning block fees: {:?}", block_fees);
-	let keychain = ExtKeychain::from_random_seed(global::is_floonet()).unwrap();
+	let keychain = ExtKeychain::from_random_seed(global::is_floonet())?;
 	let key_id = ExtKeychain::derive_key_id(1, 1, 0, 0, 0);
 	let (out, kernel) =
 		crate::core::libtx::reward::output(&keychain, &key_id, block_fees.fees, false).unwrap();