Reduce usage of Blake2Hasher (#5132)

This reduces the usage of `Blake2Hasher` in the code base and replaces
it with `BlakeTwo256`. The most important change is the removal of the
custom extern function for `Blake2Hasher`. The runtime `Hash` trait is
now also simplified and directly requires that the implementing type
implements `Hashable`.

substrate/primitives/state-machine/src/basic.rs

@@ -350,7 +350,7 @@ mod tests {
 			top: Default::default(),
 			children: map![
 				child_storage.clone() => StorageChild {
-					data: map![	b"doe".to_vec() => b"reindeer".to_vec()	],
+					data: map![ b"doe".to_vec() => b"reindeer".to_vec() ],
 					child_info: CHILD_INFO_1.to_owned(),
 				}
 			]

substrate/primitives/state-machine/src/changes_trie/changes_iterator.rs

@@ -376,13 +376,13 @@ impl<'a, H, Number> Iterator for ProvingDrilldownIterator<'a, H, Number>
 #[cfg(test)]
 mod tests {
 	use std::iter::FromIterator;
-	use sp_core::Blake2Hasher;
 	use crate::changes_trie::Configuration;
 	use crate::changes_trie::input::InputPair;
 	use crate::changes_trie::storage::InMemoryStorage;
+	use sp_runtime::traits::BlakeTwo256;
 	use super::*;
 
-	fn prepare_for_drilldown() -> (Configuration, InMemoryStorage<Blake2Hasher, u64>) {
+	fn prepare_for_drilldown() -> (Configuration, InMemoryStorage<BlakeTwo256, u64>) {
 		let config = Configuration { digest_interval: 4, digest_levels: 2 };
 		let backend = InMemoryStorage::with_inputs(vec![
 			// digest: 1..4 => [(3, 0)]
@@ -447,7 +447,7 @@ mod tests {
 	#[test]
 	fn drilldown_iterator_works() {
 		let (config, storage) = prepare_for_drilldown();
-		let drilldown_result = key_changes::<Blake2Hasher, u64>(
+		let drilldown_result = key_changes::<BlakeTwo256, u64>(
 			configuration_range(&config, 0),
 			&storage,
 			1,
@@ -458,7 +458,7 @@ mod tests {
 		).and_then(Result::from_iter);
 		assert_eq!(drilldown_result, Ok(vec![(8, 2), (8, 1), (6, 3), (3, 0)]));
 
-		let drilldown_result = key_changes::<Blake2Hasher, u64>(
+		let drilldown_result = key_changes::<BlakeTwo256, u64>(
 			configuration_range(&config, 0),
 			&storage,
 			1,
@@ -469,7 +469,7 @@ mod tests {
 		).and_then(Result::from_iter);
 		assert_eq!(drilldown_result, Ok(vec![]));
 
-		let drilldown_result = key_changes::<Blake2Hasher, u64>(
+		let drilldown_result = key_changes::<BlakeTwo256, u64>(
 			configuration_range(&config, 0),
 			&storage,
 			1,
@@ -480,7 +480,7 @@ mod tests {
 		).and_then(Result::from_iter);
 		assert_eq!(drilldown_result, Ok(vec![(3, 0)]));
 
-		let drilldown_result = key_changes::<Blake2Hasher, u64>(
+		let drilldown_result = key_changes::<BlakeTwo256, u64>(
 			configuration_range(&config, 0),
 			&storage,
 			1,
@@ -491,7 +491,7 @@ mod tests {
 		).and_then(Result::from_iter);
 		assert_eq!(drilldown_result, Ok(vec![(6, 3), (3, 0)]));
 
-		let drilldown_result = key_changes::<Blake2Hasher, u64>(
+		let drilldown_result = key_changes::<BlakeTwo256, u64>(
 			configuration_range(&config, 0),
 			&storage,
 			7,
@@ -502,7 +502,7 @@ mod tests {
 		).and_then(Result::from_iter);
 		assert_eq!(drilldown_result, Ok(vec![(8, 2), (8, 1)]));
 
-		let drilldown_result = key_changes::<Blake2Hasher, u64>(
+		let drilldown_result = key_changes::<BlakeTwo256, u64>(
 			configuration_range(&config, 0),
 			&storage,
 			5,
@@ -519,7 +519,7 @@ mod tests {
 		let (config, storage) = prepare_for_drilldown();
 		storage.clear_storage();
 
-		assert!(key_changes::<Blake2Hasher, u64>(
+		assert!(key_changes::<BlakeTwo256, u64>(
 			configuration_range(&config, 0),
 			&storage,
 			1,
@@ -529,7 +529,7 @@ mod tests {
 			&[42],
 		).and_then(|i| i.collect::<Result<Vec<_>, _>>()).is_err());
 
-		assert!(key_changes::<Blake2Hasher, u64>(
+		assert!(key_changes::<BlakeTwo256, u64>(
 			configuration_range(&config, 0),
 			&storage,
 			1,
@@ -543,7 +543,7 @@ mod tests {
 	#[test]
 	fn drilldown_iterator_fails_when_range_is_invalid() {
 		let (config, storage) = prepare_for_drilldown();
-		assert!(key_changes::<Blake2Hasher, u64>(
+		assert!(key_changes::<BlakeTwo256, u64>(
 			configuration_range(&config, 0),
 			&storage,
 			1,
@@ -552,7 +552,7 @@ mod tests {
 			None,
 			&[42],
 		).is_err());
-		assert!(key_changes::<Blake2Hasher, u64>(
+		assert!(key_changes::<BlakeTwo256, u64>(
 			configuration_range(&config, 0),
 			&storage,
 			20,
@@ -570,12 +570,12 @@ mod tests {
 
 		// create drilldown iterator that records all trie nodes during drilldown
 		let (remote_config, remote_storage) = prepare_for_drilldown();
-		let remote_proof = key_changes_proof::<Blake2Hasher, u64>(
+		let remote_proof = key_changes_proof::<BlakeTwo256, u64>(
 			configuration_range(&remote_config, 0), &remote_storage, 1,
 			&AnchorBlockId { hash: Default::default(), number: 16 }, 16, None, &[42]).unwrap();
 
 		let (remote_config, remote_storage) = prepare_for_drilldown();
-		let remote_proof_child = key_changes_proof::<Blake2Hasher, u64>(
+		let remote_proof_child = key_changes_proof::<BlakeTwo256, u64>(
 			configuration_range(&remote_config, 0), &remote_storage, 1,
 			&AnchorBlockId { hash: Default::default(), number: 16 }, 16, Some(&b"1"[..]), &[42]).unwrap();
 
@@ -584,13 +584,13 @@ mod tests {
 		// create drilldown iterator that works the same, but only depends on trie
 		let (local_config, local_storage) = prepare_for_drilldown();
 		local_storage.clear_storage();
-		let local_result = key_changes_proof_check::<Blake2Hasher, u64>(
+		let local_result = key_changes_proof_check::<BlakeTwo256, u64>(
 			configuration_range(&local_config, 0), &local_storage, remote_proof, 1,
 			&AnchorBlockId { hash: Default::default(), number: 16 }, 16, None, &[42]);
 
 		let (local_config, local_storage) = prepare_for_drilldown();
 		local_storage.clear_storage();
-		let local_result_child = key_changes_proof_check::<Blake2Hasher, u64>(
+		let local_result_child = key_changes_proof_check::<BlakeTwo256, u64>(
 			configuration_range(&local_config, 0), &local_storage, remote_proof_child, 1,
 			&AnchorBlockId { hash: Default::default(), number: 16 }, 16, Some(&b"1"[..]), &[42]);
 
@@ -621,7 +621,7 @@ mod tests {
 		input[91 - 1].1.push(InputPair::DigestIndex(DigestIndex { block: 91, key: vec![42] }, vec![80]));
 		let storage = InMemoryStorage::with_inputs(input, vec![]);
 
-		let drilldown_result = key_changes::<Blake2Hasher, u64>(
+		let drilldown_result = key_changes::<BlakeTwo256, u64>(
 			config_range,
 			&storage,
 			1,

substrate/primitives/state-machine/src/changes_trie/prune.rs

@@ -114,14 +114,15 @@ fn prune_trie<H: Hasher, Number: BlockNumber, F: FnMut(H::Out)>(
 mod tests {
 	use std::collections::HashSet;
 	use sp_trie::MemoryDB;
-	use sp_core::{H256, Blake2Hasher};
+	use sp_core::H256;
 	use crate::backend::insert_into_memory_db;
 	use crate::changes_trie::storage::InMemoryStorage;
 	use codec::Encode;
+	use sp_runtime::traits::BlakeTwo256;
 	use super::*;
 
 	fn prune_by_collect(
-		storage: &dyn Storage<Blake2Hasher, u64>,
+		storage: &dyn Storage<BlakeTwo256, u64>,
 		first: u64,
 		last: u64,
 		current_block: u64,
@@ -135,27 +136,26 @@ mod tests {
 
 	#[test]
 	fn prune_works() {
-		fn prepare_storage() -> InMemoryStorage<Blake2Hasher, u64> {
-
+		fn prepare_storage() -> InMemoryStorage<BlakeTwo256, u64> {
 			let child_key = ChildIndex { block: 67u64, storage_key: b"1".to_vec() }.encode();
-			let mut mdb1 = MemoryDB::<Blake2Hasher>::default();
-			let root1 = insert_into_memory_db::<Blake2Hasher, _>(
+			let mut mdb1 = MemoryDB::<BlakeTwo256>::default();
+			let root1 = insert_into_memory_db::<BlakeTwo256, _>(
 				&mut mdb1, vec![(vec![10], vec![20])]).unwrap();
-			let mut mdb2 = MemoryDB::<Blake2Hasher>::default();
-			let root2 = insert_into_memory_db::<Blake2Hasher, _>(
+			let mut mdb2 = MemoryDB::<BlakeTwo256>::default();
+			let root2 = insert_into_memory_db::<BlakeTwo256, _>(
 				&mut mdb2,
 				vec![(vec![11], vec![21]), (vec![12], vec![22])],
 			).unwrap();
-			let mut mdb3 = MemoryDB::<Blake2Hasher>::default();
-			let ch_root3 = insert_into_memory_db::<Blake2Hasher, _>(
+			let mut mdb3 = MemoryDB::<BlakeTwo256>::default();
+			let ch_root3 = insert_into_memory_db::<BlakeTwo256, _>(
 				&mut mdb3, vec![(vec![110], vec![120])]).unwrap();
-			let root3 = insert_into_memory_db::<Blake2Hasher, _>(&mut mdb3, vec![
+			let root3 = insert_into_memory_db::<BlakeTwo256, _>(&mut mdb3, vec![
 				(vec![13], vec![23]),
 				(vec![14], vec![24]),
 				(child_key, ch_root3.as_ref().encode()),
 			]).unwrap();
-			let mut mdb4 = MemoryDB::<Blake2Hasher>::default();
-			let root4 = insert_into_memory_db::<Blake2Hasher, _>(
+			let mut mdb4 = MemoryDB::<BlakeTwo256>::default();
+			let root4 = insert_into_memory_db::<BlakeTwo256, _>(
 				&mut mdb4,
 				vec![(vec![15], vec![25])],
 			).unwrap();

substrate/primitives/state-machine/src/in_memory_backend.rs

@@ -362,11 +362,12 @@ impl<H: Hasher> Backend<H> for InMemory<H> where H::Out: Codec {
 #[cfg(test)]
 mod tests {
 	use super::*;
+	use sp_runtime::traits::BlakeTwo256;
 
 	/// Assert in memory backend with only child trie keys works as trie backend.
 	#[test]
 	fn in_memory_with_child_trie_only() {
-		let storage = InMemory::<sp_core::Blake2Hasher>::default();
+		let storage = InMemory::<BlakeTwo256>::default();
 		let child_info = OwnedChildInfo::new_default(b"unique_id_1".to_vec());
 		let mut storage = storage.update(
 			vec![(

substrate/primitives/state-machine/src/lib.rs

@@ -727,9 +727,8 @@ mod tests {
 	use super::*;
 	use super::ext::Ext;
 	use super::changes_trie::Configuration as ChangesTrieConfig;
-	use sp_core::{
-		Blake2Hasher, map, traits::{Externalities, RuntimeCode}, storage::ChildStorageKey,
-	};
+	use sp_core::{map, traits::{Externalities, RuntimeCode}, storage::ChildStorageKey};
+	use sp_runtime::traits::BlakeTwo256;
 
 	#[derive(Clone)]
 	struct DummyCodeExecutor {
@@ -912,7 +911,7 @@ mod tests {
 		).unwrap();
 
 		// check proof locally
-		let local_result = execution_proof_check::<Blake2Hasher, u64, _>(
+		let local_result = execution_proof_check::<BlakeTwo256, u64, _>(
 			remote_root,
 			remote_proof,
 			&mut Default::default(),
@@ -935,7 +934,7 @@ mod tests {
 			b"abc".to_vec() => b"2".to_vec(),
 			b"bbb".to_vec() => b"3".to_vec()
 		];
-		let mut state = InMemoryBackend::<Blake2Hasher>::from(initial);
+		let mut state = InMemoryBackend::<BlakeTwo256>::from(initial);
 		let backend = state.as_trie_backend().unwrap();
 		let mut overlay = OverlayedChanges {
 			committed: map![
@@ -978,7 +977,7 @@ mod tests {
 
 	#[test]
 	fn set_child_storage_works() {
-		let mut state = InMemoryBackend::<Blake2Hasher>::default();
+		let mut state = InMemoryBackend::<BlakeTwo256>::default();
 		let backend = state.as_trie_backend().unwrap();
 		let mut overlay = OverlayedChanges::default();
 		let mut cache = StorageTransactionCache::default();
@@ -1025,12 +1024,12 @@ mod tests {
 		let remote_root = remote_backend.storage_root(::std::iter::empty()).0;
 		let remote_proof = prove_read(remote_backend, &[b"value2"]).unwrap();
  		// check proof locally
-		let local_result1 = read_proof_check::<Blake2Hasher, _>(
+		let local_result1 = read_proof_check::<BlakeTwo256, _>(
 			remote_root,
 			remote_proof.clone(),
 			&[b"value2"],
 		).unwrap();
-		let local_result2 = read_proof_check::<Blake2Hasher, _>(
+		let local_result2 = read_proof_check::<BlakeTwo256, _>(
 			remote_root,
 			remote_proof.clone(),
 			&[&[0xff]],
@@ -1050,13 +1049,13 @@ mod tests {
 			CHILD_INFO_1,
 			&[b"value3"],
 		).unwrap();
-		let local_result1 = read_child_proof_check::<Blake2Hasher, _>(
+		let local_result1 = read_child_proof_check::<BlakeTwo256, _>(
 			remote_root,
 			remote_proof.clone(),
 			b":child_storage:default:sub1",
 			&[b"value3"],
 		).unwrap();
-		let local_result2 = read_child_proof_check::<Blake2Hasher, _>(
+		let local_result2 = read_child_proof_check::<BlakeTwo256, _>(
 			remote_root,
 			remote_proof.clone(),
 			b":child_storage:default:sub1",

substrate/primitives/state-machine/src/proving_backend.rs

@@ -308,16 +308,17 @@ mod tests {
 	use crate::InMemoryBackend;
 	use crate::trie_backend::tests::test_trie;
 	use super::*;
-	use sp_core::{Blake2Hasher, storage::ChildStorageKey};
+	use sp_core::storage::ChildStorageKey;
 	use crate::proving_backend::create_proof_check_backend;
 	use sp_trie::PrefixedMemoryDB;
+	use sp_runtime::traits::BlakeTwo256;
 
 	const CHILD_INFO_1: ChildInfo<'static> = ChildInfo::new_default(b"unique_id_1");
 	const CHILD_INFO_2: ChildInfo<'static> = ChildInfo::new_default(b"unique_id_2");
 
 	fn test_proving<'a>(
-		trie_backend: &'a TrieBackend<PrefixedMemoryDB<Blake2Hasher>,Blake2Hasher>,
-	) -> ProvingBackend<'a, PrefixedMemoryDB<Blake2Hasher>, Blake2Hasher> {
+		trie_backend: &'a TrieBackend<PrefixedMemoryDB<BlakeTwo256>,BlakeTwo256>,
+	) -> ProvingBackend<'a, PrefixedMemoryDB<BlakeTwo256>, BlakeTwo256> {
 		ProvingBackend::new(trie_backend)
 	}
 
@@ -338,7 +339,7 @@ mod tests {
 	#[test]
 	fn proof_is_invalid_when_does_not_contains_root() {
 		use sp_core::H256;
-		let result = create_proof_check_backend::<Blake2Hasher>(
+		let result = create_proof_check_backend::<BlakeTwo256>(
 			H256::from_low_u64_be(1),
 			StorageProof::empty()
 		);
@@ -361,7 +362,7 @@ mod tests {
 	#[test]
 	fn proof_recorded_and_checked() {
 		let contents = (0..64).map(|i| (vec![i], Some(vec![i]))).collect::<Vec<_>>();
-		let in_memory = InMemoryBackend::<Blake2Hasher>::default();
+		let in_memory = InMemoryBackend::<BlakeTwo256>::default();
 		let mut in_memory = in_memory.update(vec![(None, contents)]);
 		let in_memory_root = in_memory.storage_root(::std::iter::empty()).0;
 		(0..64).for_each(|i| assert_eq!(in_memory.storage(&[i]).unwrap().unwrap(), vec![i]));
@@ -376,7 +377,7 @@ mod tests {
 
 		let proof = proving.extract_proof();
 
-		let proof_check = create_proof_check_backend::<Blake2Hasher>(in_memory_root.into(), proof).unwrap();
+		let proof_check = create_proof_check_backend::<BlakeTwo256>(in_memory_root.into(), proof).unwrap();
 		assert_eq!(proof_check.storage(&[42]).unwrap().unwrap(), vec![42]);
 	}
 
@@ -393,7 +394,7 @@ mod tests {
 			(Some((own2.clone(), CHILD_INFO_2.to_owned())),
 				(10..15).map(|i| (vec![i], Some(vec![i]))).collect()),
 		];
-		let in_memory = InMemoryBackend::<Blake2Hasher>::default();
+		let in_memory = InMemoryBackend::<BlakeTwo256>::default();
 		let mut in_memory = in_memory.update(contents);
 		let in_memory_root = in_memory.full_storage_root::<_, Vec<_>, _>(
 			::std::iter::empty(),
@@ -425,7 +426,7 @@ mod tests {
 
 		let proof = proving.extract_proof();
 
-		let proof_check = create_proof_check_backend::<Blake2Hasher>(
+		let proof_check = create_proof_check_backend::<BlakeTwo256>(
 			in_memory_root.into(),
 			proof
 		).unwrap();
@@ -439,7 +440,7 @@ mod tests {
 		assert_eq!(proving.child_storage(&own1[..], CHILD_INFO_1, &[64]), Ok(Some(vec![64])));
 
 		let proof = proving.extract_proof();
-		let proof_check = create_proof_check_backend::<Blake2Hasher>(
+		let proof_check = create_proof_check_backend::<BlakeTwo256>(
 			in_memory_root.into(),
 			proof
 		).unwrap();

substrate/primitives/state-machine/src/testing.rs

@@ -34,13 +34,12 @@ use sp_core::{
 		well_known_keys::{CHANGES_TRIE_CONFIG, CODE, HEAP_PAGES, is_child_storage_key},
 		Storage,
 	},
-	Blake2Hasher,
 };
 use codec::Encode;
 use sp_externalities::{Extensions, Extension};
 
 /// Simple HashMap-based Externalities impl.
-pub struct TestExternalities<H: Hasher = Blake2Hasher, N: ChangesTrieBlockNumber = u64>
+pub struct TestExternalities<H: Hasher, N: ChangesTrieBlockNumber = u64>
 where
 	H::Out: codec::Codec,
 {
@@ -198,11 +197,12 @@ impl<H, N> sp_externalities::ExtensionStore for TestExternalities<H, N> where
 mod tests {
 	use super::*;
 	use sp_core::traits::Externalities;
+	use sp_runtime::traits::BlakeTwo256;
 	use hex_literal::hex;
 
 	#[test]
 	fn commit_should_work() {
-		let mut ext = TestExternalities::<Blake2Hasher, u64>::default();
+		let mut ext = TestExternalities::<BlakeTwo256, u64>::default();
 		let mut ext = ext.ext();
 		ext.set_storage(b"doe".to_vec(), b"reindeer".to_vec());
 		ext.set_storage(b"dog".to_vec(), b"puppy".to_vec());
@@ -213,7 +213,7 @@ mod tests {
 
 	#[test]
 	fn set_and_retrieve_code() {
-		let mut ext = TestExternalities::<Blake2Hasher, u64>::default();
+		let mut ext = TestExternalities::<BlakeTwo256, u64>::default();
 		let mut ext = ext.ext();
 
 		let code = vec![1, 2, 3];
@@ -225,6 +225,6 @@ mod tests {
 	#[test]
 	fn check_send() {
 		fn assert_send<T: Send>() {}
-		assert_send::<TestExternalities::<Blake2Hasher, u64>>();
+		assert_send::<TestExternalities::<BlakeTwo256, u64>>();
 	}
 }

substrate/primitives/state-machine/src/trie_backend.rs

@@ -245,9 +245,10 @@ impl<S: TrieBackendStorage<H>, H: Hasher> Backend<H> for TrieBackend<S, H> where
 #[cfg(test)]
 pub mod tests {
 	use std::collections::HashSet;
-	use sp_core::{Blake2Hasher, H256};
+	use sp_core::H256;
 	use codec::Encode;
 	use sp_trie::{TrieMut, PrefixedMemoryDB, trie_types::TrieDBMut, KeySpacedDBMut};
+	use sp_runtime::traits::BlakeTwo256;
 	use super::*;
 
 	const CHILD_KEY_1: &[u8] = b":child_storage:default:sub1";
@@ -255,9 +256,9 @@ pub mod tests {
 	const CHILD_UUID_1: &[u8] = b"unique_id_1";
 	const CHILD_INFO_1: ChildInfo<'static> = ChildInfo::new_default(CHILD_UUID_1);
 
-	fn test_db() -> (PrefixedMemoryDB<Blake2Hasher>, H256) {
+	fn test_db() -> (PrefixedMemoryDB<BlakeTwo256>, H256) {
 		let mut root = H256::default();
-		let mut mdb = PrefixedMemoryDB::<Blake2Hasher>::default();
+		let mut mdb = PrefixedMemoryDB::<BlakeTwo256>::default();
 		{
 			let mut mdb = KeySpacedDBMut::new(&mut mdb, CHILD_UUID_1);
 			let mut trie = TrieDBMut::new(&mut mdb, &mut root);
@@ -281,7 +282,7 @@ pub mod tests {
 		(mdb, root)
 	}
 
-	pub(crate) fn test_trie() -> TrieBackend<PrefixedMemoryDB<Blake2Hasher>, Blake2Hasher> {
+	pub(crate) fn test_trie() -> TrieBackend<PrefixedMemoryDB<BlakeTwo256>, BlakeTwo256> {
 		let (mdb, root) = test_db();
 		TrieBackend::new(mdb, root)
 	}
@@ -312,7 +313,7 @@ pub mod tests {
 
 	#[test]
 	fn pairs_are_empty_on_empty_storage() {
-		assert!(TrieBackend::<PrefixedMemoryDB<Blake2Hasher>, Blake2Hasher>::new(
+		assert!(TrieBackend::<PrefixedMemoryDB<BlakeTwo256>, BlakeTwo256>::new(
 			PrefixedMemoryDB::default(),
 			Default::default(),
 		).pairs().is_empty());