Fast sync

client/api/src/backend.rs

@@ -41,6 +41,7 @@ use sp_consensus::BlockOrigin;
 use parking_lot::RwLock;
 
 pub use sp_state_machine::Backend as StateBackend;
+pub use sp_consensus::ImportedState;
 use std::marker::PhantomData;
 
 /// Extracts the state backend type for the given backend.
@@ -162,7 +163,7 @@ pub trait BlockImportOperation<Block: BlockT> {
 	) -> sp_blockchain::Result<()>;
 
 	/// Inject storage data into the database replacing any existing data.
-	fn reset_storage(&mut self, storage: Storage) -> sp_blockchain::Result<Block::Hash>;
+	fn reset_storage(&mut self, storage: Storage, commit: bool) -> sp_blockchain::Result<Block::Hash>;
 
 	/// Set storage changes.
 	fn update_storage(

client/api/src/in_mem.rs

@@ -347,6 +347,11 @@ impl<Block: BlockT> HeaderBackend<Block> for Blockchain<Block> {
 			genesis_hash: storage.genesis_hash,
 			finalized_hash: storage.finalized_hash,
 			finalized_number: storage.finalized_number,
+			finalized_state: if storage.finalized_hash != Default::default() {
+				Some((storage.finalized_hash.clone(), storage.finalized_number))
+			} else {
+				None
+			},
 			number_leaves: storage.leaves.count()
 		}
 	}
@@ -562,7 +567,7 @@ impl<Block: BlockT> backend::BlockImportOperation<Block> for BlockImportOperatio
 		Ok(())
 	}
 
-	fn reset_storage(&mut self, storage: Storage) -> sp_blockchain::Result<Block::Hash> {
+	fn reset_storage(&mut self, storage: Storage, commit: bool) -> sp_blockchain::Result<Block::Hash> {
 		check_genesis_storage(&storage)?;
 
 		let child_delta = storage.children_default.iter()
@@ -578,7 +583,9 @@ impl<Block: BlockT> backend::BlockImportOperation<Block> for BlockImportOperatio
 			child_delta,
 		);
 
-		self.new_state = Some(transaction);
+		if commit {
+			self.new_state = Some(transaction);
+		}
 		Ok(root)
 	}
 

client/api/src/lib.rs

@@ -40,6 +40,7 @@ pub use notifications::*;
 pub use proof_provider::*;
 
 pub use sp_state_machine::{StorageProof, ExecutionStrategy};
+pub use sp_storage::{StorageData, StorageKey, PrefixedStorageKey, ChildInfo};
 
 /// Usage Information Provider interface
 ///

client/api/src/proof_provider.rs

@@ -17,6 +17,7 @@
 // along with this program. If not, see <https://www.gnu.org/licenses/>.
 
 //! Proof utilities
+use std::collections::HashMap;
 use sp_runtime::{
 	generic::BlockId,
 	traits::{Block as BlockT},
@@ -70,4 +71,30 @@ pub trait ProofProvider<Block: BlockT> {
 		storage_key: Option<&PrefixedStorageKey>,
 		key: &StorageKey,
 	) -> sp_blockchain::Result<ChangesProof<Block::Header>>;
+
+	/// Given a `BlockId` iterate over all storage values starting at `start_key`,
+	/// building proofs until size limit is reached. Returns collected keys and a combined proof.
+	fn read_proof_collection(
+		&self,
+		id: &BlockId<Block>,
+		start_key: &StorageKey,
+		size_limit: usize,
+	) -> sp_blockchain::Result<(Vec<Vec<u8>>, StorageProof)>;
+
+	/// Given a `BlockId` iterate over all storage values starting at `start_key`.
+	/// Returns collected keys and values.
+	fn storage_collection(
+		&self,
+		id: &BlockId<Block>,
+		start_key: &StorageKey,
+		size_limit: usize,
+	) -> sp_blockchain::Result<Vec<(Vec<u8>, Vec<u8>)>>;
+
+	/// Verify read storage proof for a set of keys.
+	fn verify_read_proof(
+		&self,
+		keys: &[Vec<u8>],
+		root: Block::Hash,
+		proof: StorageProof,
+	) -> sp_blockchain::Result<HashMap<Vec<u8>, Option<Vec<u8>>>>;
 }

client/authority-discovery/src/worker/tests.rs

@@ -69,6 +69,7 @@ impl<Block: BlockT> HeaderBackend<Block> for TestApi {
 			finalized_number: Zero::zero(),
 			genesis_hash: Default::default(),
 			number_leaves: Default::default(),
+			finalized_state: None,
 		}
 	}
 

client/cli/src/arg_enums.rs

@@ -232,6 +232,27 @@ arg_enum! {
 	}
 }
 
+arg_enum! {
+	/// Syncing mode.
+	#[allow(missing_docs)]
+	#[derive(Debug, Clone, Copy)]
+	pub enum SyncMode {
+		Full,
+		Fast,
+		FastUnsafe,
+	}
+}
+
+impl Into<sc_network::config::SyncMode> for SyncMode {
+	fn into(self) -> sc_network::config::SyncMode {
+		match self {
+			SyncMode::Full => sc_network::config::SyncMode::Full,
+			SyncMode::Fast => sc_network::config::SyncMode::Fast { skip_proofs: false },
+			SyncMode::FastUnsafe => sc_network::config::SyncMode::Fast { skip_proofs: true },
+		}
+	}
+}
+
 /// Default value for the `--execution-syncing` parameter.
 pub const DEFAULT_EXECUTION_SYNCING: ExecutionStrategy = ExecutionStrategy::NativeElseWasm;
 /// Default value for the `--execution-import-block` parameter.

client/cli/src/params/network_params.rs

@@ -17,6 +17,7 @@
 // along with this program. If not, see <https://www.gnu.org/licenses/>.
 
 use crate::params::node_key_params::NodeKeyParams;
+use crate::arg_enums::SyncMode;
 use sc_network::{
 	config::{NetworkConfiguration, NodeKeyConfig, NonReservedPeerMode, SetConfig, TransportConfig},
 	multiaddr::Protocol,
@@ -125,6 +126,10 @@ pub struct NetworkParams {
 	/// Join the IPFS network and serve transactions over bitswap protocol.
 	#[structopt(long)]
 	pub ipfs_server: bool,
+
+	/// Blockchain syncing mode.
+	#[structopt(long, default_value = "Full")]
+	pub sync: SyncMode,
 }
 
 impl NetworkParams {
@@ -218,6 +223,7 @@ impl NetworkParams {
 			kademlia_disjoint_query_paths: self.kademlia_disjoint_query_paths,
 			yamux_window_size: None,
 			ipfs_server: self.ipfs_server,
+			sync_mode: self.sync.into(),
 		}
 	}
 }

client/consensus/aura/src/lib.rs

@@ -392,7 +392,7 @@ where
 			let mut import_block = BlockImportParams::new(BlockOrigin::Own, header);
 			import_block.post_digests.push(signature_digest_item);
 			import_block.body = Some(body);
-			import_block.storage_changes = Some(storage_changes);
+			import_block.storage_changes = Some(sp_consensus::StorageChanges::Raw(storage_changes));
 			import_block.fork_choice = Some(ForkChoiceStrategy::LongestChain);
 
 			Ok(import_block)

client/consensus/babe/src/lib.rs

@@ -763,7 +763,7 @@ where
 			let mut import_block = BlockImportParams::new(BlockOrigin::Own, header);
 			import_block.post_digests.push(digest_item);
 			import_block.body = Some(body);
-			import_block.storage_changes = Some(storage_changes);
+			import_block.storage_changes = Some(sp_consensus::StorageChanges::Raw(storage_changes));
 			import_block.intermediates.insert(
 				Cow::from(INTERMEDIATE_KEY),
 				Box::new(BabeIntermediate::<B> { epoch_descriptor }) as Box<_>,
@@ -1275,7 +1275,12 @@ impl<Block, Client, Inner> BlockImport<Block> for BabeBlockImport<Block, Client,
 		// early exit if block already in chain, otherwise the check for
 		// epoch changes will error when trying to re-import an epoch change
 		match self.client.status(BlockId::Hash(hash)) {
-			Ok(sp_blockchain::BlockStatus::InChain) => return Ok(ImportResult::AlreadyInChain),
+			Ok(sp_blockchain::BlockStatus::InChain) => {
+				// When re-importing existing block strip away finality information.
+				let _ = block.take_intermediate::<BabeIntermediate<Block>>(INTERMEDIATE_KEY)?;
+				block.fork_choice = Some(ForkChoiceStrategy::Custom(false));
+				return self.inner.import_block(block, new_cache).await.map_err(Into::into)
+			}
 			Ok(sp_blockchain::BlockStatus::Unknown) => {},
 			Err(e) => return Err(ConsensusError::ClientImport(e.to_string())),
 		}

client/consensus/manual-seal/src/seal_block.rs

@@ -146,7 +146,7 @@ pub async fn seal_block<B, BI, SC, C, E, P, CIDP>(
 		params.body = Some(body);
 		params.finalized = finalize;
 		params.fork_choice = Some(ForkChoiceStrategy::LongestChain);
-		params.storage_changes = Some(proposal.storage_changes);
+		params.storage_changes = Some(sp_consensus::StorageChanges::Raw(proposal.storage_changes));
 
 		if let Some(digest_provider) = digest_provider {
 			digest_provider.append_block_import(&parent, &mut params, &inherent_data)?;

client/consensus/pow/src/worker.rs

@@ -19,7 +19,7 @@
 use std::{pin::Pin, time::Duration, collections::HashMap, borrow::Cow};
 use sc_client_api::ImportNotifications;
 use sp_runtime::{DigestItem, traits::Block as BlockT, generic::BlockId};
-use sp_consensus::{Proposal, BlockOrigin, BlockImportParams, import_queue::BoxBlockImport};
+use sp_consensus::{Proposal, BlockOrigin, BlockImportParams, StorageChanges, import_queue::BoxBlockImport};
 use futures::{prelude::*, task::{Context, Poll}};
 use futures_timer::Delay;
 use log::*;
@@ -128,7 +128,7 @@ impl<Block, Algorithm, C, Proof> MiningWorker<Block, Algorithm, C, Proof> where
 			let mut import_block = BlockImportParams::new(BlockOrigin::Own, header);
 			import_block.post_digests.push(seal);
 			import_block.body = Some(body);
-			import_block.storage_changes = Some(build.proposal.storage_changes);
+			import_block.storage_changes = Some(StorageChanges::Raw(build.proposal.storage_changes));
 
 			let intermediate = PowIntermediate::<Algorithm::Difficulty> {
 				difficulty: Some(build.metadata.difficulty),