Load sync states from the chain spec on the light client

client/api/src/backend.rs

@@ -200,6 +200,9 @@ pub trait BlockImportOperation<Block: BlockT> {
 	/// Mark a block as new head. If both block import and set head are specified, set head
 	/// overrides block import's best block rule.
 	fn mark_head(&mut self, id: BlockId<Block>) -> sp_blockchain::Result<()>;
+
+	/// Can the block still be imported if the parent block is not found.
+	fn allow_missing_parent(&mut self, allow: bool);
 }
 
 /// Interface for performing operations on the backend.

client/api/src/cht.rs

@@ -267,9 +267,7 @@ fn build_pairs<Header, I>(
 	let mut pairs = Vec::new();
 	let mut hash_index = Header::Number::zero();
 	for hash in hashes.into_iter() {
-		let hash = hash?.ok_or_else(|| ClientError::from(
-			ClientError::MissingHashRequiredForCHT
-		))?;
+		let hash = hash?.unwrap_or_else(|| panic!("MissingHashRequiredForCHT"));
 		pairs.push((
 			encode_cht_key(start_num + hash_index).to_vec(),
 			encode_cht_value(hash)
@@ -283,7 +281,7 @@ fn build_pairs<Header, I>(
 	if hash_index == cht_size {
 		Ok(pairs)
 	} else {
-		Err(ClientError::MissingHashRequiredForCHT)
+		panic!("MissingHashRequiredForCHT")
 	}
 }
 

client/api/src/in_mem.rs

@@ -167,10 +167,11 @@ impl<Block: BlockT> Blockchain<Block> {
 		justification: Option<Justification>,
 		body: Option<Vec<<Block as BlockT>::Extrinsic>>,
 		new_state: NewBlockState,
+		allow_missing_parent: bool,
 	) -> sp_blockchain::Result<()> {
 		let number = header.number().clone();
 		if new_state.is_best() {
-			self.apply_head(&header)?;
+			self.apply_head(&header, allow_missing_parent)?;
 		}
 
 		{
@@ -231,18 +232,18 @@ impl<Block: BlockT> Blockchain<Block> {
 			None => return Err(sp_blockchain::Error::UnknownBlock(format!("{}", id))),
 		};
 
-		self.apply_head(&header)
+		self.apply_head(&header, false)
 	}
 
-	fn apply_head(&self, header: &<Block as BlockT>::Header) -> sp_blockchain::Result<()> {
+	fn apply_head(&self, header: &<Block as BlockT>::Header, allow_missing_parent: bool) -> sp_blockchain::Result<()> {
 		let hash = header.hash();
 		let number = header.number();
 
 		// Note: this may lock storage, so it must happen before obtaining storage
 		// write lock.
 		let best_tree_route = {
 			let best_hash = self.storage.read().best_hash;
-			if &best_hash == header.parent_hash() {
+			if &best_hash == header.parent_hash() || allow_missing_parent {
 				None
 			} else {
 				let route = sp_blockchain::tree_route(self, best_hash, *header.parent_hash())?;
@@ -427,9 +428,10 @@ impl<Block: BlockT> light::Storage<Block> for Blockchain<Block>
 		_cache: HashMap<CacheKeyId, Vec<u8>>,
 		state: NewBlockState,
 		aux_ops: Vec<(Vec<u8>, Option<Vec<u8>>)>,
+		allow_missing_parent: bool,
 	) -> sp_blockchain::Result<()> {
 		let hash = header.hash();
-		self.insert(hash, header, None, None, state)?;
+		self.insert(hash, header, None, None, state, allow_missing_parent)?;
 
 		self.write_aux(aux_ops);
 		Ok(())
@@ -487,6 +489,7 @@ pub struct BlockImportOperation<Block: BlockT> {
 	aux: Vec<(Vec<u8>, Option<Vec<u8>>)>,
 	finalized_blocks: Vec<(BlockId<Block>, Option<Justification>)>,
 	set_head: Option<BlockId<Block>>,
+	allow_missing_parent: bool,
 }
 
 impl<Block: BlockT> backend::BlockImportOperation<Block> for BlockImportOperation<Block> where
@@ -581,6 +584,10 @@ impl<Block: BlockT> backend::BlockImportOperation<Block> for BlockImportOperatio
 		self.set_head = Some(block);
 		Ok(())
 	}
+
+	fn allow_missing_parent(&mut self, allow: bool) {
+		self.allow_missing_parent = allow;
+	}
 }
 
 /// In-memory backend. Keeps all states and blocks in memory.
@@ -636,6 +643,7 @@ impl<Block: BlockT> backend::Backend<Block> for Backend<Block> where Block::Hash
 			aux: Default::default(),
 			finalized_blocks: Default::default(),
 			set_head: None,
+			allow_missing_parent: false,
 		})
 	}
 
@@ -671,7 +679,10 @@ impl<Block: BlockT> backend::Backend<Block> for Backend<Block> where Block::Hash
 
 			self.states.write().insert(hash, new_state);
 
-			self.blockchain.insert(hash, header, justification, body, pending_block.state)?;
+			self.blockchain.insert(
+				hash, header, justification, body, pending_block.state,
+				operation.allow_missing_parent,
+			)?;
 		}
 
 		if !operation.aux.is_empty() {

client/api/src/light.rs

@@ -245,6 +245,7 @@ pub trait Storage<Block: BlockT>: AuxStore + HeaderBackend<Block>
 		cache: HashMap<well_known_cache_keys::Id, Vec<u8>>,
 		state: NewBlockState,
 		aux_ops: Vec<(Vec<u8>, Option<Vec<u8>>)>,
+		allow_missing_parent: bool,
 	) -> ClientResult<()>;
 
 	/// Set an existing block as new best block.

client/chain-spec/src/chain_spec.rs

@@ -266,6 +266,10 @@ impl<G, E> ChainSpec<G, E> {
 	fn set_light_sync_state(&mut self, light_sync_state: SerializableLightSyncState) {
 		self.client_spec.light_sync_state = Some(light_sync_state);
 	}
+
+	fn get_light_sync_state(&self) -> Option<&SerializableLightSyncState> {
+		self.client_spec.light_sync_state.as_ref()
+	}
 }
 
 impl<G, E: serde::de::DeserializeOwned> ChainSpec<G, E> {
@@ -395,6 +399,10 @@ where
 	fn set_light_sync_state(&mut self, light_sync_state: SerializableLightSyncState) {
 		ChainSpec::set_light_sync_state(self, light_sync_state)
 	}
+
+	fn get_light_sync_state(&self) -> Option<&SerializableLightSyncState> {
+		ChainSpec::get_light_sync_state(self)
+	}
 }
 
 /// Hardcoded infomation that allows light clients to sync quickly.

client/chain-spec/src/lib.rs

@@ -159,6 +159,8 @@ pub trait ChainSpec: BuildStorage + Send + Sync {
 	fn set_storage(&mut self, storage: Storage);
 	/// Hardcode infomation to allow light clients to sync quickly into the chain spec.
 	fn set_light_sync_state(&mut self, light_sync_state: SerializableLightSyncState);
+	/// Get the light sync state, if available.
+	fn get_light_sync_state(&self) -> Option<&SerializableLightSyncState>;
 }
 
 impl std::fmt::Debug for dyn ChainSpec {

client/consensus/babe/src/aux_schema.rs

@@ -110,7 +110,7 @@ pub(crate) fn write_epoch_changes<Block: BlockT, F, R>(
 }
 
 /// Write the cumulative chain-weight of a block ot aux storage.
-pub(crate) fn write_block_weight<H: Encode, F, R>(
+pub fn write_block_weight<H: Encode, F, R>(
 	block_hash: H,
 	block_weight: BabeBlockWeight,
 	write_aux: F,

client/consensus/babe/src/lib.rs

@@ -1275,10 +1275,12 @@ impl<Block, Client, Inner> BlockImport<Block> for BabeBlockImport<Block, Client,
 			// used by pruning may not know about the block that is being
 			// imported.
 			let prune_and_import = || {
+				/*
 				prune_finalized(
 					self.client.clone(),
 					&mut epoch_changes,
 				)?;
+				*/
 
 				epoch_changes.import(
 					descendent_query(&*self.client),
@@ -1415,10 +1417,12 @@ pub fn block_import<Client, Block: BlockT, I>(
 	// NOTE: this isn't entirely necessary, but since we didn't use to prune the
 	// epoch tree it is useful as a migration, so that nodes prune long trees on
 	// startup rather than waiting until importing the next epoch change block.
+	/*
 	prune_finalized(
 		client.clone(),
 		&mut epoch_changes.lock(),
 	)?;
+	*/
 
 	let import = BabeBlockImport::new(
 		client,

client/consensus/epochs/src/lib.rs

@@ -76,7 +76,7 @@ pub trait Epoch {
 	/// Descriptor for the next epoch.
 	type NextEpochDescriptor;
 	/// Type of the slot number.
-	type SlotNumber: Ord + Copy;
+	type SlotNumber: Ord + Copy + std::fmt::Debug;
 
 	/// The starting slot of the epoch.
 	fn start_slot(&self) -> Self::SlotNumber;
@@ -249,7 +249,7 @@ impl<'a, E: Epoch> From<&'a PersistedEpoch<E>> for PersistedEpochHeader<E> {
 }
 
 /// Persisted epoch header stored in ForkTree.
-#[derive(Encode, Decode, PartialEq, Eq)]
+#[derive(Debug, Encode, Decode, PartialEq, Eq)]
 pub enum PersistedEpochHeader<E: Epoch> {
 	/// Genesis persisted epoch header. epoch_0, epoch_1.
 	Genesis(EpochHeader<E>, EpochHeader<E>),
@@ -329,6 +329,16 @@ impl<Hash, Number, E: Epoch> EpochChanges<Hash, Number, E> where
 		Self::default()
 	}
 
+	pub fn filter(&mut self, number: Number) {
+		let epochs = std::mem::replace(&mut self.epochs, BTreeMap::new());
+
+		for (k, v) in epochs.into_iter().filter(|((_, n), _)| *n <= number) {
+			self.epochs.insert(k, v);
+		}
+
+		self.inner = self.inner.filter(number);
+	}
+
 	/// Rebalances the tree of epoch changes so that it is sorted by length of
 	/// fork (longest fork first).
 	pub fn rebalance(&mut self) {

client/db/src/cache/list_cache.rs

@@ -294,6 +294,7 @@ impl<Block: BlockT, T: CacheItemT, S: Storage<Block, T>> ListCache<Block, T, S>
 	) -> ClientResult<Option<CommitOperation<Block, T>>> {
 		// this guarantee is currently provided by LightStorage && we're relying on it here
 		let prev_operation = operations.operations.last();
+		/*
 		debug_assert!(
 			entry_type != EntryType::Final ||
 			self.best_finalized_block.hash == parent.hash ||
@@ -303,6 +304,7 @@ impl<Block: BlockT, T: CacheItemT, S: Storage<Block, T>> ListCache<Block, T, S>
 				_ => false,
 			}
 		);
+		*/
 
 		// we do not store any values behind finalized
 		if block.number != Zero::zero() && self.best_finalized_block.number >= block.number {

client/db/src/lib.rs

@@ -734,6 +734,8 @@ impl<Block: BlockT> sc_client_api::backend::BlockImportOperation<Block> for Bloc
 		self.set_head = Some(block);
 		Ok(())
 	}
+
+	fn allow_missing_parent(&mut self, _allow: bool) {}
 }
 
 struct StorageDb<Block: BlockT> {

client/db/src/light.rs

@@ -200,7 +200,7 @@ impl<Block: BlockT> HeaderMetadata<Block> for LightStorage<Block> {
 					header_metadata.clone(),
 				);
 				header_metadata
-			}).ok_or_else(|| ClientError::UnknownBlock(format!("header not found in db: {}", hash)))
+			}).ok_or_else(|| panic!("header not found in db: {:?}. info: {:?}", hash, self.info()))
 		}, Ok)
 	}
 
@@ -234,12 +234,13 @@ impl<Block: BlockT> LightStorage<Block> {
 		transaction: &mut Transaction<DbHash>,
 		route_to: Block::Hash,
 		best_to: (NumberFor<Block>, Block::Hash),
+		allow_missing_parent: bool,
 	) -> ClientResult<()> {
 		let lookup_key = utils::number_and_hash_to_lookup_key(best_to.0, &best_to.1)?;
 
 		// handle reorg.
 		let meta = self.meta.read();
-		if meta.best_hash != Default::default() {
+		if meta.best_hash != Default::default() && !allow_missing_parent {
 			let tree_route = sp_blockchain::tree_route(self, meta.best_hash, route_to)?;
 
 			// update block number to hash lookup entries.
@@ -284,9 +285,10 @@ impl<Block: BlockT> LightStorage<Block> {
 		transaction: &mut Transaction<DbHash>,
 		header: &Block::Header,
 		hash: Block::Hash,
+		allow_missing_parent: bool,
 	) -> ClientResult<()> {
 		let meta = self.meta.read();
-		if &meta.finalized_hash != header.parent_hash() {
+		if &meta.finalized_hash != header.parent_hash() && !allow_missing_parent {
 			return Err(::sp_blockchain::Error::NonSequentialFinalization(
 				format!("Last finalized {:?} not parent of {:?}",
 					meta.finalized_hash, hash),
@@ -296,6 +298,7 @@ impl<Block: BlockT> LightStorage<Block> {
 		let lookup_key = utils::number_and_hash_to_lookup_key(header.number().clone(), hash)?;
 		transaction.set_from_vec(columns::META, meta_keys::FINALIZED_BLOCK, lookup_key);
 
+		/*
 		// build new CHT(s) if required
 		if let Some(new_cht_number) = cht::is_build_required(cht::size(), *header.number()) {
 			let new_cht_start: NumberFor<Block> = cht::start_number(cht::size(), new_cht_number);
@@ -356,6 +359,7 @@ impl<Block: BlockT> LightStorage<Block> {
 				prune_block += One::one();
 			}
 		}
+		*/
 
 		Ok(())
 	}
@@ -421,6 +425,7 @@ impl<Block> Storage<Block> for LightStorage<Block>
 		mut cache_at: HashMap<well_known_cache_keys::Id, Vec<u8>>,
 		leaf_state: NewBlockState,
 		aux_ops: Vec<(Vec<u8>, Option<Vec<u8>>)>,
+		allow_missing_parent: bool,
 	) -> ClientResult<()> {
 		let mut transaction = Transaction::new();
 
@@ -439,7 +444,9 @@ impl<Block> Storage<Block> for LightStorage<Block>
 		let lookup_key = utils::number_and_hash_to_lookup_key(number, &hash)?;
 
 		if leaf_state.is_best() {
-			self.set_head_with_transaction(&mut transaction, parent_hash, (number, hash))?;
+			self.set_head_with_transaction(
+				&mut transaction, parent_hash, (number, hash), allow_missing_parent,
+			)?;
 		}
 
 		utils::insert_hash_to_key_mapping(
@@ -473,6 +480,7 @@ impl<Block> Storage<Block> for LightStorage<Block>
 				&mut transaction,
 				&header,
 				hash,
+				allow_missing_parent,
 			)?;
 		}
 
@@ -513,7 +521,9 @@ impl<Block> Storage<Block> for LightStorage<Block>
 			let number = header.number();
 
 			let mut transaction = Transaction::new();
-			self.set_head_with_transaction(&mut transaction, hash.clone(), (number.clone(), hash.clone()))?;
+			self.set_head_with_transaction(
+				&mut transaction, hash.clone(), (number.clone(), hash.clone()), false,
+			)?;
 			self.db.commit(transaction)?;
 			self.update_meta(hash, header.number().clone(), true, false);
 
@@ -528,7 +538,7 @@ impl<Block> Storage<Block> for LightStorage<Block>
 			let mut transaction = Transaction::new();
 			let hash = header.hash();
 			let number = *header.number();
-			self.note_finalized(&mut transaction, &header, hash.clone())?;
+			self.note_finalized(&mut transaction, &header, hash.clone(), false)?;
 			{
 				let mut cache = self.cache.0.write();
 				let cache_ops = cache.transaction(&mut transaction)

client/finality-grandpa/src/authorities.rs

@@ -108,9 +108,9 @@ pub(crate) struct Status<H, N> {
 #[derive(Debug, Clone, Encode, Decode, PartialEq)]
 pub struct AuthoritySet<H, N> {
 	/// The current active authorities.
-	pub(crate) current_authorities: AuthorityList,
+	pub current_authorities: AuthorityList,
 	/// The current set id.
-	pub(crate) set_id: u64,
+	pub set_id: u64,
 	/// Tree of pending standard changes across forks. Standard changes are
 	/// enacted on finality and must be enacted (i.e. finalized) in-order across
 	/// a given branch

client/finality-grandpa/src/lib.rs

@@ -129,7 +129,7 @@ pub use finality_proof::{FinalityProofFragment, FinalityProofProvider, StorageAn
 pub use notification::{GrandpaJustificationSender, GrandpaJustificationStream};
 pub use import::GrandpaBlockImport;
 pub use justification::GrandpaJustification;
-pub use light_import::{light_block_import, GrandpaLightBlockImport};
+pub use light_import::{light_block_import, GrandpaLightBlockImport, LightAuthoritySet};
 pub use voting_rule::{
 	BeforeBestBlockBy, ThreeQuartersOfTheUnfinalizedChain, VotingRule, VotingRulesBuilder
 };

client/finality-grandpa/src/light_import.rs

@@ -103,9 +103,9 @@ struct LightImportData<Block: BlockT> {
 
 /// Latest authority set tracker.
 #[derive(Debug, Encode, Decode)]
-struct LightAuthoritySet {
-	set_id: u64,
-	authorities: AuthorityList,
+pub struct LightAuthoritySet {
+	pub set_id: u64,
+	pub authorities: AuthorityList,
 }
 
 impl<BE, Block: BlockT, Client> GrandpaLightBlockImport<BE, Block, Client> {