chore: rename sp-core-hashing to sp-crypto-hashing (#1490)

* rename sp-core-hashing to sp-crypto-hashing

* fmt

subxt/src/config/substrate.rs

@@ -42,7 +42,7 @@ pub struct BlakeTwo256;
 impl Hasher for BlakeTwo256 {
     type Output = H256;
     fn hash(s: &[u8]) -> Self::Output {
-        sp_core_hashing::blake2_256(s).into()
+        sp_crypto_hashing::blake2_256(s).into()
     }
 }
 

subxt/src/events/events_client.rs

@@ -76,8 +76,8 @@ where
 
 // The storage key needed to access events.
 fn system_events_key() -> [u8; 32] {
-    let a = sp_core_hashing::twox_128(b"System");
-    let b = sp_core_hashing::twox_128(b"Events");
+    let a = sp_crypto_hashing::twox_128(b"System");
+    let b = sp_crypto_hashing::twox_128(b"Events");
     let mut res = [0; 32];
     res[0..16].clone_from_slice(&a);
     res[16..32].clone_from_slice(&b);

subxt/src/storage/storage_type.rs

@@ -287,8 +287,10 @@ where
         // construct the storage key. This is done similarly in `frame_support::traits::metadata::StorageVersion::storage_key()`.
         pub const STORAGE_VERSION_STORAGE_KEY_POSTFIX: &[u8] = b":__STORAGE_VERSION__:";
         let mut key_bytes: Vec<u8> = vec![];
-        key_bytes.extend(&sp_core_hashing::twox_128(pallet_name.as_ref().as_bytes()));
-        key_bytes.extend(&sp_core_hashing::twox_128(
+        key_bytes.extend(&sp_crypto_hashing::twox_128(
+            pallet_name.as_ref().as_bytes(),
+        ));
+        key_bytes.extend(&sp_crypto_hashing::twox_128(
             STORAGE_VERSION_STORAGE_KEY_POSTFIX,
         ));
 

subxt/src/storage/utils.rs

@@ -17,8 +17,8 @@ pub fn write_storage_address_root_bytes<Address: StorageAddress>(
     addr: &Address,
     out: &mut Vec<u8>,
 ) {
-    out.extend(sp_core_hashing::twox_128(addr.pallet_name().as_bytes()));
-    out.extend(sp_core_hashing::twox_128(addr.entry_name().as_bytes()));
+    out.extend(sp_crypto_hashing::twox_128(addr.pallet_name().as_bytes()));
+    out.extend(sp_crypto_hashing::twox_128(addr.entry_name().as_bytes()));
 }
 
 /// Outputs the [`storage_address_root_bytes`] as well as any additional bytes that represent
@@ -44,16 +44,16 @@ pub fn storage_address_root_bytes<Address: StorageAddress>(addr: &Address) -> Ve
 pub fn hash_bytes(input: &[u8], hasher: StorageHasher, bytes: &mut Vec<u8>) {
     match hasher {
         StorageHasher::Identity => bytes.extend(input),
-        StorageHasher::Blake2_128 => bytes.extend(sp_core_hashing::blake2_128(input)),
+        StorageHasher::Blake2_128 => bytes.extend(sp_crypto_hashing::blake2_128(input)),
         StorageHasher::Blake2_128Concat => {
-            bytes.extend(sp_core_hashing::blake2_128(input));
+            bytes.extend(sp_crypto_hashing::blake2_128(input));
             bytes.extend(input);
         }
-        StorageHasher::Blake2_256 => bytes.extend(sp_core_hashing::blake2_256(input)),
-        StorageHasher::Twox128 => bytes.extend(sp_core_hashing::twox_128(input)),
-        StorageHasher::Twox256 => bytes.extend(sp_core_hashing::twox_256(input)),
+        StorageHasher::Blake2_256 => bytes.extend(sp_crypto_hashing::blake2_256(input)),
+        StorageHasher::Twox128 => bytes.extend(sp_crypto_hashing::twox_128(input)),
+        StorageHasher::Twox256 => bytes.extend(sp_crypto_hashing::twox_256(input)),
         StorageHasher::Twox64Concat => {
-            bytes.extend(sp_core_hashing::twox_64(input));
+            bytes.extend(sp_crypto_hashing::twox_64(input));
             bytes.extend(input);
         }
     }

subxt/src/tx/tx_client.rs

@@ -17,7 +17,7 @@ use crate::{
 };
 use codec::{Compact, Decode, Encode};
 use derivative::Derivative;
-use sp_core_hashing::blake2_256;
+use sp_crypto_hashing::blake2_256;
 
 /// A client for working with transactions.
 #[derive(Derivative)]