Fast sync (#8884)

* State sync * Importing state fixes * Bugfixes * Sync with proof * Status reporting * Unsafe sync mode * Sync test * Cleanup * Apply suggestions from code review Co-authored-by: cheme <emericchevalier.pro@gmail.com> Co-authored-by: Pierre Krieger <pierre.krieger1708@gmail.com> * set_genesis_storage * Extract keys from range proof * Detect iter completion * Download and import bodies with fast sync * Replaced meta updates tuple with a struct * Fixed reverting finalized state * Reverted timeout * Typo * Doc * Doc * Fixed light client test * Fixed error handling * Tweaks * More UpdateMeta changes * Rename convert_transaction * Apply suggestions from code review Co-authored-by: Bastian Köcher <bkchr@users.noreply.github.com> * Apply suggestions from code review Co-authored-by: Bastian Köcher <bkchr@users.noreply.github.com> * Code review suggestions * Fixed count handling Co-authored-by: cheme <emericchevalier.pro@gmail.com> Co-authored-by: Pierre Krieger <pierre.krieger1708@gmail.com> Co-authored-by: Bastian Köcher <bkchr@users.noreply.github.com>
2026-04-28 05:07:55 +00:00 · 2021-06-22 11:32:43 +02:00
parent 5899eedc8c
commit 77a4b980ae
54 changed files with 2128 additions and 379 deletions
@@ -726,6 +726,50 @@ mod execution {
 		prove_read_on_trie_backend(trie_backend, keys)
 	}

+	/// Generate range storage read proof.
+	pub fn prove_range_read_with_size<B, H>(
+		mut backend: B,
+		child_info: Option<&ChildInfo>,
+		prefix: Option<&[u8]>,
+		size_limit: usize,
+		start_at: Option<&[u8]>,
+	) -> Result<(StorageProof, u32), Box<dyn Error>>
+	where
+		B: Backend<H>,
+		H: Hasher,
+		H::Out: Ord + Codec,
+	{
+		let trie_backend = backend.as_trie_backend()
+			.ok_or_else(|| Box::new(ExecutionError::UnableToGenerateProof) as Box<dyn Error>)?;
+		prove_range_read_with_size_on_trie_backend(trie_backend, child_info, prefix, size_limit, start_at)
+	}
+
+	/// Generate range storage read proof on an existing trie backend.
+	pub fn prove_range_read_with_size_on_trie_backend<S, H>(
+		trie_backend: &TrieBackend<S, H>,
+		child_info: Option<&ChildInfo>,
+		prefix: Option<&[u8]>,
+		size_limit: usize,
+		start_at: Option<&[u8]>,
+	) -> Result<(StorageProof, u32), Box<dyn Error>>
+	where
+		S: trie_backend_essence::TrieBackendStorage<H>,
+		H: Hasher,
+		H::Out: Ord + Codec,
+	{
+		let proving_backend = proving_backend::ProvingBackend::<S, H>::new(trie_backend);
+		let mut count = 0;
+		proving_backend.apply_to_key_values_while(child_info, prefix, start_at, |_key, _value| {
+			if count == 0 || proving_backend.estimate_encoded_size() <= size_limit {
+				count += 1;
+				true
+			} else {
+				false
+			}
+		}, false).map_err(|e| Box::new(e) as Box<dyn Error>)?;
+		Ok((proving_backend.extract_proof(), count))
+	}
+
 	/// Generate child storage read proof.
 	pub fn prove_child_read<B, H, I>(
 		mut backend: B,
@@ -808,6 +852,29 @@ mod execution {
 		Ok(result)
 	}

+	/// Check child storage range proof, generated by `prove_range_read` call.
+	pub fn read_range_proof_check<H>(
+		root: H::Out,
+		proof: StorageProof,
+		child_info: Option<&ChildInfo>,
+		prefix: Option<&[u8]>,
+		count: Option<u32>,
+		start_at: Option<&[u8]>,
+	) -> Result<(Vec<(Vec<u8>, Vec<u8>)>, bool), Box<dyn Error>>
+	where
+		H: Hasher,
+		H::Out: Ord + Codec,
+	{
+		let proving_backend = create_proof_check_backend::<H>(root, proof)?;
+		read_range_proof_check_on_proving_backend(
+			&proving_backend,
+			child_info,
+			prefix,
+			count,
+			start_at,
+		)
+	}
+
 	/// Check child storage read proof, generated by `prove_child_read` call.
 	pub fn read_child_proof_check<H, I>(
 		root: H::Out,
@@ -859,6 +926,32 @@ mod execution {
 		proving_backend.child_storage(child_info, key)
 			.map_err(|e| Box::new(e) as Box<dyn Error>)
 	}
+
+	/// Check storage range proof on pre-created proving backend.
+	///
+	/// Returns a vector with the read `key => value` pairs and a `bool` that is set to `true` when
+	/// all `key => value` pairs could be read and no more are left.
+	pub fn read_range_proof_check_on_proving_backend<H>(
+		proving_backend: &TrieBackend<MemoryDB<H>, H>,
+		child_info: Option<&ChildInfo>,
+		prefix: Option<&[u8]>,
+		count: Option<u32>,
+		start_at: Option<&[u8]>,
+	) -> Result<(Vec<(Vec<u8>, Vec<u8>)>, bool), Box<dyn Error>>
+	where
+		H: Hasher,
+		H::Out: Ord + Codec,
+	{
+		let mut values = Vec::new();
+		let result = proving_backend.apply_to_key_values_while(child_info, prefix, start_at, |key, value| {
+			values.push((key.to_vec(), value.to_vec()));
+			count.as_ref().map_or(true, |c| (values.len() as u32) < *c)
+		}, true);
+		match result {
+			Ok(completed) => Ok((values, completed)),
+			Err(e) => Err(Box::new(e) as Box<dyn Error>),
+		}
+	}
 }

 #[cfg(test)]
@@ -1457,7 +1550,7 @@ mod tests {
 			remote_proof.clone(),
 			&[&[0xff]],
 		).is_ok();
- 		// check that results are correct
+		// check that results are correct
 		assert_eq!(
 			local_result1.into_iter().collect::<Vec<_>>(),
 			vec![(b"value2".to_vec(), Some(vec![24]))],
@@ -1494,6 +1587,57 @@ mod tests {
 		);
 	}

+	#[test]
+	fn prove_read_with_size_limit_works() {
+		let remote_backend = trie_backend::tests::test_trie();
+		let remote_root = remote_backend.storage_root(::std::iter::empty()).0;
+		let (proof, count) = prove_range_read_with_size(remote_backend, None, None, 0, None).unwrap();
+		// Alwasys contains at least some nodes.
+		assert_eq!(proof.into_memory_db::<BlakeTwo256>().drain().len(), 3);
+		assert_eq!(count, 1);
+
+		let remote_backend = trie_backend::tests::test_trie();
+		let (proof, count) = prove_range_read_with_size(remote_backend, None, None, 800, Some(&[])).unwrap();
+		assert_eq!(proof.clone().into_memory_db::<BlakeTwo256>().drain().len(), 9);
+		assert_eq!(count, 85);
+		let (results, completed) = read_range_proof_check::<BlakeTwo256>(
+			remote_root,
+			proof.clone(),
+			None,
+			None,
+			Some(count),
+			None,
+		).unwrap();
+		assert_eq!(results.len() as u32, count);
+		assert_eq!(completed, false);
+		// When checking without count limit, proof may actually contain extra values.
+		let (results, completed) = read_range_proof_check::<BlakeTwo256>(
+			remote_root,
+			proof,
+			None,
+			None,
+			None,
+			None,
+		).unwrap();
+		assert_eq!(results.len() as u32, 101);
+		assert_eq!(completed, false);
+
+		let remote_backend = trie_backend::tests::test_trie();
+		let (proof, count) = prove_range_read_with_size(remote_backend, None, None, 50000, Some(&[])).unwrap();
+		assert_eq!(proof.clone().into_memory_db::<BlakeTwo256>().drain().len(), 11);
+		assert_eq!(count, 132);
+		let (results, completed) = read_range_proof_check::<BlakeTwo256>(
+			remote_root,
+			proof.clone(),
+			None,
+			None,
+			None,
+			None,
+		).unwrap();
+		assert_eq!(results.len() as u32, count);
+		assert_eq!(completed, true);
+	}
+
 	#[test]
 	fn compact_multiple_child_trie() {
 		// this root will be queried