Add a LightSyncState field to the chain spec

bin/node-template/node/src/service.rs

@@ -87,6 +87,7 @@ pub fn new_full(config: Configuration) -> Result<TaskManager, ServiceError> {
 		sc_service::build_network(sc_service::BuildNetworkParams {
 			config: &config,
 			client: client.clone(),
+			backend: backend.clone(),		
 			transaction_pool: transaction_pool.clone(),
 			spawn_handle: task_manager.spawn_handle(),
 			import_queue,
@@ -258,6 +259,7 @@ pub fn new_light(config: Configuration) -> Result<TaskManager, ServiceError> {
 		sc_service::build_network(sc_service::BuildNetworkParams {
 			config: &config,
 			client: client.clone(),
+			backend: backend.clone(),		
 			transaction_pool: transaction_pool.clone(),
 			spawn_handle: task_manager.spawn_handle(),
 			import_queue,

bin/node/cli/src/service.rs

@@ -175,6 +175,7 @@ pub fn new_full_base(
 		sc_service::build_network(sc_service::BuildNetworkParams {
 			config: &config,
 			client: client.clone(),
+			backend: backend.clone(),
 			transaction_pool: transaction_pool.clone(),
 			spawn_handle: task_manager.spawn_handle(),
 			import_queue,
@@ -394,6 +395,7 @@ pub fn new_light_base(config: Configuration) -> Result<(
 		sc_service::build_network(sc_service::BuildNetworkParams {
 			config: &config,
 			client: client.clone(),
+			backend: backend.clone(),
 			transaction_pool: transaction_pool.clone(),
 			spawn_handle: task_manager.spawn_handle(),
 			import_queue,

client/api/src/in_mem.rs

@@ -447,6 +447,16 @@ impl<Block: BlockT> light::Storage<Block> for Blockchain<Block>
 		Blockchain::finalize_header(self, id, None)
 	}
 
+	fn cache(&self) -> Option<Arc<dyn blockchain::Cache<Block>>> {
+		None
+	}
+
+	fn usage_info(&self) -> Option<UsageInfo> {
+		None
+	}
+}
+
+impl<Block: BlockT> light::ChtRootStorage<Block> for Blockchain<Block> {
 	fn header_cht_root(
 		&self,
 		_cht_size: NumberFor<Block>,
@@ -466,14 +476,6 @@ impl<Block: BlockT> light::Storage<Block> for Blockchain<Block>
 			.ok_or_else(|| sp_blockchain::Error::Backend(format!("Changes trie CHT for block {} not exists", block)))
 			.map(Some)
 	}
-
-	fn cache(&self) -> Option<Arc<dyn blockchain::Cache<Block>>> {
-		None
-	}
-
-	fn usage_info(&self) -> Option<UsageInfo> {
-		None
-	}
 }
 
 /// In-memory operation.

client/api/src/light.rs

@@ -232,7 +232,9 @@ pub trait FetchChecker<Block: BlockT>: Send + Sync {
 
 
 /// Light client blockchain storage.
-pub trait Storage<Block: BlockT>: AuxStore + HeaderBackend<Block> + HeaderMetadata<Block, Error=ClientError> {
+pub trait Storage<Block: BlockT>: AuxStore + HeaderBackend<Block>
+	+ HeaderMetadata<Block, Error=ClientError> + ChtRootStorage<Block>
+{
 	/// Store new header. Should refuse to revert any finalized blocks.
 	///
 	/// Takes new authorities, the leaf state of the new block, and
@@ -254,6 +256,15 @@ pub trait Storage<Block: BlockT>: AuxStore + HeaderBackend<Block> + HeaderMetada
 	/// Get last finalized header.
 	fn last_finalized(&self) -> ClientResult<Block::Hash>;
 
+	/// Get storage cache.
+	fn cache(&self) -> Option<Arc<dyn BlockchainCache<Block>>>;
+
+	/// Get storage usage statistics.
+	fn usage_info(&self) -> Option<UsageInfo>;
+}
+
+/// Light client CHT root storage.
+pub trait ChtRootStorage<Block: BlockT> {
 	/// Get headers CHT root for given block. Returns None if the block is not pruned (not a part of any CHT).
 	fn header_cht_root(
 		&self,
@@ -267,12 +278,6 @@ pub trait Storage<Block: BlockT>: AuxStore + HeaderBackend<Block> + HeaderMetada
 		cht_size: NumberFor<Block>,
 		block: NumberFor<Block>,
 	) -> ClientResult<Option<Block::Hash>>;
-
-	/// Get storage cache.
-	fn cache(&self) -> Option<Arc<dyn BlockchainCache<Block>>>;
-
-	/// Get storage usage statistics.
-	fn usage_info(&self) -> Option<UsageInfo>;
 }
 
 /// Remote header.

client/chain-spec/Cargo.toml

@@ -21,3 +21,4 @@ serde_json = "1.0.41"
 sp-runtime = { version = "2.0.0-rc5", path = "../../primitives/runtime" }
 sp-chain-spec = { version = "2.0.0-rc5", path = "../../primitives/chain-spec" }
 sc-telemetry = { version = "2.0.0-rc5", path = "../telemetry" }
+codec = { package = "parity-scale-codec", version = "1.3.4" }

client/chain-spec/src/chain_spec.rs

@@ -17,6 +17,7 @@
 // along with this program. If not, see <https://www.gnu.org/licenses/>.
 
 //! Substrate chain configurations.
+#![warn(missing_docs)]
 
 use std::{borrow::Cow, fs::File, path::PathBuf, sync::Arc, collections::HashMap};
 use serde::{Serialize, Deserialize};
@@ -26,6 +27,7 @@ use serde_json as json;
 use crate::{RuntimeGenesis, ChainType, extension::GetExtension, Properties};
 use sc_network::config::MultiaddrWithPeerId;
 use sc_telemetry::TelemetryEndpoints;
+use sp_runtime::traits::Block as BlockT;
 
 enum GenesisSource<G> {
 	File(PathBuf),
@@ -157,6 +159,7 @@ struct ClientSpec<E> {
 	consensus_engine: (),
 	#[serde(skip_serializing)]
 	genesis: serde::de::IgnoredAny,
+	hardcoded_sync: Option<SerializableHardcodedSync>,
 }
 
 /// A type denoting empty extensions.
@@ -245,6 +248,7 @@ impl<G, E> ChainSpec<G, E> {
 			extensions,
 			consensus_engine: (),
 			genesis: Default::default(),
+			hardcoded_sync: None,
 		};
 
 		ChainSpec {
@@ -257,6 +261,11 @@ impl<G, E> ChainSpec<G, E> {
 	fn chain_type(&self) -> ChainType {
 		self.client_spec.chain_type.clone()
 	}
+
+	/// Hardcode infomation to allow light clients to sync quickly into the chain spec.
+	fn set_hardcoded_sync(&mut self, hardcoded_sync: SerializableHardcodedSync) {
+		self.client_spec.hardcoded_sync = Some(hardcoded_sync);	
+	}
 }
 
 impl<G, E: serde::de::DeserializeOwned> ChainSpec<G, E> {
@@ -284,16 +293,15 @@ impl<G, E: serde::de::DeserializeOwned> ChainSpec<G, E> {
 	}
 }
 
-impl<G: RuntimeGenesis, E: serde::Serialize + Clone + 'static> ChainSpec<G, E> {
-	/// Dump to json string.
-	pub fn as_json(&self, raw: bool) -> Result<String, String> {
-		#[derive(Serialize, Deserialize)]
-		struct Container<G, E> {
-			#[serde(flatten)]
-			client_spec: ClientSpec<E>,
-			genesis: Genesis<G>,
+#[derive(Serialize, Deserialize)]
+struct JsonContainer<G, E> {
+	#[serde(flatten)]
+	client_spec: ClientSpec<E>,
+	genesis: Genesis<G>,
+}
 
-		};
+impl<G: RuntimeGenesis, E: serde::Serialize + Clone + 'static> ChainSpec<G, E> {
+	fn json_container(&self, raw: bool) -> Result<JsonContainer<G, E>, String> {
 		let genesis = match (raw, self.genesis.resolve()?) {
 			(true, Genesis::Runtime(g)) => {
 				let storage = g.build_storage()?;
@@ -313,13 +321,25 @@ impl<G: RuntimeGenesis, E: serde::Serialize + Clone + 'static> ChainSpec<G, E> {
 			},
 			(_, genesis) => genesis,
 		};
-		let container = Container {
+		Ok(JsonContainer {
 			client_spec: self.client_spec.clone(),
 			genesis,
-		};
+		})
+	}
+
+	/// Dump to json string.
+	pub fn as_json(&self, raw: bool) -> Result<String, String> {
+		let container = self.json_container(raw)?;
 		json::to_string_pretty(&container)
 			.map_err(|e| format!("Error generating spec json: {}", e))
 	}
+
+	/// Dump to json value
+	pub fn as_json_value(&self, raw: bool) -> Result<json::Value, String> {
+		let container = self.json_container(raw)?;
+		json::to_value(container)
+			.map_err(|e| format!("Error generating spec json: {}", e))
+	}
 }
 
 impl<G, E> crate::ChainSpec for ChainSpec<G, E>
@@ -367,6 +387,10 @@ where
 		ChainSpec::as_json(self, raw)
 	}
 
+	fn as_json_value(&self, raw: bool) -> Result<serde_json::Value, String> {
+		ChainSpec::as_json_value(self, raw)
+	}
+
 	fn as_storage_builder(&self) -> &dyn BuildStorage {
 		self
 	}
@@ -378,6 +402,49 @@ where
 	fn set_storage(&mut self, storage: Storage) {
 		self.genesis = GenesisSource::Storage(storage);
 	}
+
+	fn set_hardcoded_sync(&mut self, hardcoded_sync: SerializableHardcodedSync) {
+		ChainSpec::set_hardcoded_sync(self, hardcoded_sync)
+	}
+}
+
+/// Hardcoded infomation that allows light clients to sync quickly.
+pub struct HardcodedSync<Block: BlockT> {
+	/// The header of the best finalized block.
+	pub header: <Block as BlockT>::Header,
+	/// A list of all CHTs in the chain.
+	pub chts: Vec<<Block as BlockT>::Hash>,
+}
+
+impl<Block: BlockT> HardcodedSync<Block> {
+	/// Convert into a `SerializableHardcodecSync`.
+	pub fn to_serializable(&self) -> SerializableHardcodedSync {
+		use codec::Encode;
+
+		SerializableHardcodedSync {
+			header: StorageData(self.header.encode()),
+			chts: self.chts.iter().map(|hash| StorageData(hash.encode())).collect(),
+		}
+	}
+
+	/// Convert from a `SerializableHardcodecSync`.
+	pub fn from_serializable(serialized: &SerializableHardcodedSync) -> Result<Self, codec::Error> {
+		Ok(Self {
+			header: codec::Decode::decode(&mut &serialized.header.0[..])?,
+			chts: serialized.chts.iter()
+				.map(|cht| codec::Decode::decode(&mut &cht.0[..]))
+				.collect::<Result<_, _>>()?,
+		})
+	}
+}
+
+#[derive(Serialize, Deserialize, Clone, Debug)]
+#[serde(rename_all = "camelCase")]
+#[serde(deny_unknown_fields)]
+/// The serializable form of `HardcodedSync`. Created using `HardcodedSync::serialize`.
+pub struct SerializableHardcodedSync {
+	header: StorageData,
+	chts: Vec<StorageData>,
 }
 
 #[cfg(test)]

client/chain-spec/src/lib.rs

@@ -108,7 +108,9 @@
 mod chain_spec;
 mod extension;
 
-pub use chain_spec::{ChainSpec as GenericChainSpec, NoExtension};
+pub use chain_spec::{
+	ChainSpec as GenericChainSpec, NoExtension, HardcodedSync, SerializableHardcodedSync,
+};
 pub use extension::{Group, Fork, Forks, Extension, GetExtension, get_extension};
 pub use sc_chain_spec_derive::{ChainSpecExtension, ChainSpecGroup};
 pub use sp_chain_spec::{Properties, ChainType};
@@ -147,6 +149,8 @@ pub trait ChainSpec: BuildStorage + Send {
 	fn add_boot_node(&mut self, addr: MultiaddrWithPeerId);
 	/// Return spec as JSON.
 	fn as_json(&self, raw: bool) -> Result<String, String>;
+	/// Return spec as JSON value.
+	fn as_json_value(&self, raw: bool) -> Result<serde_json::Value, String>;
 	/// Return StorageBuilder for this spec.
 	fn as_storage_builder(&self) -> &dyn BuildStorage;
 	/// Returns a cloned `Box<dyn ChainSpec>`.
@@ -155,6 +159,8 @@ pub trait ChainSpec: BuildStorage + Send {
 	///
 	/// This will be used as storage at genesis.
 	fn set_storage(&mut self, storage: Storage);
+	/// Hardcode infomation to allow light clients to sync quickly into the chain spec.
+	fn set_hardcoded_sync(&mut self, hardcoded_sync: SerializableHardcodedSync);
 }
 
 impl std::fmt::Debug for dyn ChainSpec {

client/db/src/light.rs

@@ -27,7 +27,7 @@ use sc_client_api::{
 	blockchain::{
 		BlockStatus, Cache as BlockchainCache, Info as BlockchainInfo,
 	},
-	Storage
+	Storage, ChtRootStorage,
 };
 use sp_blockchain::{
 	CachedHeaderMetadata, HeaderMetadata, HeaderMetadataCache,
@@ -523,22 +523,6 @@ impl<Block> Storage<Block> for LightStorage<Block>
 		}
 	}
 
-	fn header_cht_root(
-		&self,
-		cht_size: NumberFor<Block>,
-		block: NumberFor<Block>,
-	) -> ClientResult<Option<Block::Hash>> {
-		self.read_cht_root(HEADER_CHT_PREFIX, cht_size, block)
-	}
-
-	fn changes_trie_cht_root(
-		&self,
-		cht_size: NumberFor<Block>,
-		block: NumberFor<Block>,
-	) -> ClientResult<Option<Block::Hash>> {
-		self.read_cht_root(CHANGES_TRIE_CHT_PREFIX, cht_size, block)
-	}
-
 	fn finalize_header(&self, id: BlockId<Block>) -> ClientResult<()> {
 		if let Some(header) = self.header(id)? {
 			let mut transaction = Transaction::new();
@@ -612,6 +596,48 @@ impl<Block> Storage<Block> for LightStorage<Block>
 	}
 }
 
+impl<Block> ChtRootStorage<Block> for LightStorage<Block>
+	where Block: BlockT,
+{
+	fn header_cht_root(
+		&self,
+		cht_size: NumberFor<Block>,
+		block: NumberFor<Block>,
+	) -> ClientResult<Option<Block::Hash>> {
+		self.read_cht_root(HEADER_CHT_PREFIX, cht_size, block)
+	}
+
+	fn changes_trie_cht_root(
+		&self,
+		cht_size: NumberFor<Block>,
+		block: NumberFor<Block>,
+	) -> ClientResult<Option<Block::Hash>> {
+		self.read_cht_root(CHANGES_TRIE_CHT_PREFIX, cht_size, block)
+	}
+}
+
+
+impl<'a, Block> ChtRootStorage<Block> for &'a LightStorage<Block>
+	where Block: BlockT,
+{
+	fn header_cht_root(
+		&self,
+		cht_size: NumberFor<Block>,
+		block: NumberFor<Block>,
+	) -> ClientResult<Option<Block::Hash>> {
+		self.read_cht_root(HEADER_CHT_PREFIX, cht_size, block)
+	}
+
+	fn changes_trie_cht_root(
+		&self,
+		cht_size: NumberFor<Block>,
+		block: NumberFor<Block>,
+	) -> ClientResult<Option<Block::Hash>> {
+		self.read_cht_root(CHANGES_TRIE_CHT_PREFIX, cht_size, block)
+	}
+}
+
+
 /// Build the key for inserting header-CHT at given block.
 fn cht_key<N: TryInto<u32>>(cht_type: u8, block: N) -> ClientResult<[u8; 5]> {
 	let mut key = [cht_type; 5];

client/rpc-api/Cargo.toml

@@ -29,3 +29,4 @@ serde = { version = "1.0.101", features = ["derive"] }
 serde_json = "1.0.41"
 sp-transaction-pool = { version = "2.0.0-rc5", path = "../../primitives/transaction-pool" }
 sp-rpc = { version = "2.0.0-rc5", path = "../../primitives/rpc" }
+sp-blockchain = { version = "2.0.0-rc5", path = "../../primitives/blockchain" }