Don't strip system pallet associated types. check System.Hashing, not Hash. Rename BlockHash trait to Hash

Author: jsdw

core/src/config/mod.rs

@@ -63,7 +63,7 @@ pub type HashFor<T> = <<T as Config>::Hasher as Hasher>::Output;
 pub type ParamsFor<T> = <<T as Config>::ExtrinsicParams as ExtrinsicParams<T>>::Params;
 
 /// Block hashes must conform to a bunch of things to be used in Subxt.
-pub trait BlockHash:
+pub trait Hash:
     Debug
     + Copy
     + Send
@@ -78,7 +78,7 @@ pub trait BlockHash:
     + core::hash::Hash
 {
 }
-impl<T> BlockHash for T where
+impl<T> Hash for T where
     T: Debug
         + Copy
         + Send
@@ -98,7 +98,7 @@ impl<T> BlockHash for T where
 /// and extrinsics.
 pub trait Hasher {
     /// The type given back from the hash operation
-    type Output: BlockHash;
+    type Output: Hash;
 
     /// Construct a new hasher.
     fn new(metadata: &Metadata) -> Self;

core/src/config/substrate.rs

@@ -62,8 +62,11 @@ pub struct DynamicHasher256(HashType);
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 enum HashType {
+    // Most chains use this:
     BlakeTwo256,
+    // Chains like Hyperbridge use this (tends to be eth compatible chains)
     Keccak256,
+    // If we don't have V16 metadata, we'll emit this and default to BlakeTwo256.
     Unknown,
 }
 
@@ -75,18 +78,18 @@ impl Hasher for DynamicHasher256 {
         let Some(system_pallet) = metadata.pallet_by_name("System") else {
             return Self(HashType::Unknown);
         };
-        let Some(hash_ty_id) = system_pallet.associated_type_id("Hash") else {
+        let Some(hash_ty_id) = system_pallet.associated_type_id("Hashing") else {
             return Self(HashType::Unknown);
         };
 
         let ty = metadata
             .types()
             .resolve(hash_ty_id)
-            .expect("Type information for 'Hash' associated tyoe should be in metadata");
+            .expect("Type information for 'Hashing' associated tyoe should be in metadata");
 
         let hash_type = match ty.path.ident().as_deref().unwrap_or("") {
             "BlakeTwo256" => HashType::BlakeTwo256,
-            "Keccak" => HashType::Keccak256,
+            "Keccak256" => HashType::Keccak256,
             _ => HashType::Unknown,
         };
 
@@ -131,6 +134,7 @@ where
 {
     type Number = N;
     type Hasher = H;
+
     fn number(&self) -> Self::Number {
         self.number
     }

rpcs/src/lib.rs

@@ -45,7 +45,7 @@ pub trait RpcConfig {
     /// The block header type.
     type Header: Header;
     /// The block hash type.
-    type Hash: BlockHash;
+    type Hash: Hash;
     /// The Account ID type.
     type AccountId: AccountId;
 }
@@ -55,8 +55,8 @@ pub trait Header: std::fmt::Debug + codec::Decode + serde::de::DeserializeOwned
 impl<T> Header for T where T: std::fmt::Debug + codec::Decode + serde::de::DeserializeOwned {}
 
 /// A trait which is applied to any type that is a valid block hash.
-pub trait BlockHash: serde::de::DeserializeOwned + serde::Serialize {}
-impl<T> BlockHash for T where T: serde::de::DeserializeOwned + serde::Serialize {}
+pub trait Hash: serde::de::DeserializeOwned + serde::Serialize {}
+impl<T> Hash for T where T: serde::de::DeserializeOwned + serde::Serialize {}
 
 /// A trait which is applied to any type that is a valid Account ID.
 pub trait AccountId: serde::Serialize {}

rpcs/src/methods/chain_head.rs

@@ -7,7 +7,7 @@
 //! methods exposed here.
 
 use crate::client::{rpc_params, RpcClient, RpcSubscription};
-use crate::BlockHash;
+use crate::Hash;
 use crate::{Error, RpcConfig};
 use derive_where::derive_where;
 use futures::{Stream, StreamExt};
@@ -749,7 +749,7 @@ pub struct FollowSubscription<Hash> {
     done: bool,
 }
 
-impl<Hash: BlockHash> FollowSubscription<Hash> {
+impl<H: Hash> FollowSubscription<H> {
     /// Fetch the next item in the stream.
     pub async fn next(&mut self) -> Option<<Self as Stream>::Item> {
         <Self as StreamExt>::next(self).await
@@ -760,8 +760,8 @@ impl<Hash: BlockHash> FollowSubscription<Hash> {
     }
 }
 
-impl<Hash: BlockHash> Stream for FollowSubscription<Hash> {
-    type Item = <RpcSubscription<FollowEvent<Hash>> as Stream>::Item;
+impl<H: Hash> Stream for FollowSubscription<H> {
+    type Item = <RpcSubscription<FollowEvent<H>> as Stream>::Item;
     fn poll_next(
         mut self: std::pin::Pin<&mut Self>,
         cx: &mut std::task::Context<'_>,
@@ -788,15 +788,15 @@ pub struct TransactionSubscription<Hash> {
     done: bool,
 }
 
-impl<Hash: BlockHash> TransactionSubscription<Hash> {
+impl<H: Hash> TransactionSubscription<H> {
     /// Fetch the next item in the stream.
     pub async fn next(&mut self) -> Option<<Self as Stream>::Item> {
         <Self as StreamExt>::next(self).await
     }
 }
 
-impl<Hash: BlockHash> Stream for TransactionSubscription<Hash> {
-    type Item = <RpcSubscription<TransactionStatus<Hash>> as Stream>::Item;
+impl<H: Hash> Stream for TransactionSubscription<H> {
+    type Item = <RpcSubscription<TransactionStatus<H>> as Stream>::Item;
     fn poll_next(
         mut self: std::pin::Pin<&mut Self>,
         cx: &mut std::task::Context<'_>,
@@ -909,7 +909,7 @@ pub struct ArchiveStorageSubscription<Hash> {
     done: bool,
 }
 
-impl<Hash: BlockHash> ArchiveStorageSubscription<Hash> {
+impl<H: Hash> ArchiveStorageSubscription<H> {
     /// Fetch the next item in the stream.
     pub async fn next(&mut self) -> Option<<Self as Stream>::Item> {
         <Self as StreamExt>::next(self).await
@@ -920,8 +920,8 @@ impl<Hash: BlockHash> ArchiveStorageSubscription<Hash> {
     }
 }
 
-impl<Hash: BlockHash> Stream for ArchiveStorageSubscription<Hash> {
-    type Item = <RpcSubscription<ArchiveStorageEvent<Hash>> as Stream>::Item;
+impl<H: Hash> Stream for ArchiveStorageSubscription<H> {
+    type Item = <RpcSubscription<ArchiveStorageEvent<H>> as Stream>::Item;
     fn poll_next(
         mut self: std::pin::Pin<&mut Self>,
         cx: &mut std::task::Context<'_>,