Metadata V16: Be more dynamic over which hasher is used. (#1974)

* Use DynamicHasher256 to support Blake2 or Keccack depending on chain

* remove Config::Hash associated type, replace with HashFor<Config> alias

* Fix doc links

* fix wasm tests

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

* Tweak comment

* fmt

* fix merge

* Fix typo

subxt/src/tx/tx_client.rs

@@ -5,7 +5,7 @@
 use crate::{
     backend::{BackendExt, BlockRef, TransactionStatus},
     client::{OfflineClientT, OnlineClientT},
-    config::{Config, ExtrinsicParams, Header},
+    config::{Config, ExtrinsicParams, HashFor, Header},
     error::{BlockError, Error},
     tx::{Payload, Signer as SignerT, TxProgress},
     utils::PhantomDataSendSync,
@@ -321,7 +321,7 @@ where
         &mut self,
         call: &Call,
         signer: &Signer,
-    ) -> Result<T::Hash, Error>
+    ) -> Result<HashFor<T>, Error>
     where
         Call: Payload,
         Signer: SignerT<T>,
@@ -344,7 +344,7 @@ where
         call: &Call,
         signer: &Signer,
         params: <T::ExtrinsicParams as ExtrinsicParams<T>>::Params,
-    ) -> Result<T::Hash, Error>
+    ) -> Result<HashFor<T>, Error>
     where
         Call: Payload,
         Signer: SignerT<T>,
@@ -459,8 +459,8 @@ where
     }
 
     /// Calculate and return the hash of the transaction, based on the configured hasher.
-    pub fn hash(&self) -> T::Hash {
-        self.inner.hash()
+    pub fn hash(&self) -> HashFor<T> {
+        self.inner.hash_with(self.client.hasher())
     }
 
     /// Returns the SCALE encoded transaction bytes.
@@ -503,7 +503,7 @@ where
     /// It's usually better to call `submit_and_watch` to get an idea of the progress of the
     /// submission and whether it's eventually successful or not. This call does not guarantee
     /// success, and is just sending the transaction to the chain.
-    pub async fn submit(&self) -> Result<T::Hash, Error> {
+    pub async fn submit(&self) -> Result<HashFor<T>, Error> {
         let ext_hash = self.hash();
         let mut sub = self
             .client
@@ -551,7 +551,7 @@ where
     /// Returns `Ok` with a [`ValidationResult`], which is the result of attempting to dry run the transaction.
     pub async fn validate_at(
         &self,
-        at: impl Into<BlockRef<T::Hash>>,
+        at: impl Into<BlockRef<HashFor<T>>>,
     ) -> Result<ValidationResult, Error> {
         let block_hash = at.into().hash();
 
@@ -614,7 +614,7 @@ async fn inject_account_nonce_and_block<T: Config, Client: OnlineClientT<T>>(
         crate::blocks::get_account_nonce(client, account_id, block_ref.hash()).await?;
 
     params.inject_account_nonce(account_nonce);
-    params.inject_block(block_header.number().into(), block_header.hash());
+    params.inject_block(block_header.number().into(), block_ref.hash());
 
     Ok(())
 }

subxt/src/tx/tx_progress.rs

@@ -9,18 +9,18 @@ use std::task::Poll;
 use crate::{
     backend::{BlockRef, StreamOfResults, TransactionStatus as BackendTxStatus},
     client::OnlineClientT,
+    config::{Config, HashFor},
     error::{DispatchError, Error, RpcError, TransactionError},
     events::EventsClient,
     utils::strip_compact_prefix,
-    Config,
 };
 use derive_where::derive_where;
 use futures::{Stream, StreamExt};
 
 /// This struct represents a subscription to the progress of some transaction.
 pub struct TxProgress<T: Config, C> {
-    sub: Option<StreamOfResults<BackendTxStatus<T::Hash>>>,
-    ext_hash: T::Hash,
+    sub: Option<StreamOfResults<BackendTxStatus<HashFor<T>>>>,
+    ext_hash: HashFor<T>,
     client: C,
 }
 
@@ -42,9 +42,9 @@ impl<T: Config, C> Unpin for TxProgress<T, C> {}
 impl<T: Config, C> TxProgress<T, C> {
     /// Instantiate a new [`TxProgress`] from a custom subscription.
     pub fn new(
-        sub: StreamOfResults<BackendTxStatus<T::Hash>>,
+        sub: StreamOfResults<BackendTxStatus<HashFor<T>>>,
         client: C,
-        ext_hash: T::Hash,
+        ext_hash: HashFor<T>,
     ) -> Self {
         Self {
             sub: Some(sub),
@@ -54,7 +54,7 @@ impl<T: Config, C> TxProgress<T, C> {
     }
 
     /// Return the hash of the extrinsic.
-    pub fn extrinsic_hash(&self) -> T::Hash {
+    pub fn extrinsic_hash(&self) -> HashFor<T> {
         self.ext_hash
     }
 }
@@ -219,13 +219,13 @@ impl<T: Config, C> TxStatus<T, C> {
 /// This struct represents a transaction that has made it into a block.
 #[derive_where(Debug; C)]
 pub struct TxInBlock<T: Config, C> {
-    block_ref: BlockRef<T::Hash>,
-    ext_hash: T::Hash,
+    block_ref: BlockRef<HashFor<T>>,
+    ext_hash: HashFor<T>,
     client: C,
 }
 
 impl<T: Config, C> TxInBlock<T, C> {
-    pub(crate) fn new(block_ref: BlockRef<T::Hash>, ext_hash: T::Hash, client: C) -> Self {
+    pub(crate) fn new(block_ref: BlockRef<HashFor<T>>, ext_hash: HashFor<T>, client: C) -> Self {
         Self {
             block_ref,
             ext_hash,
@@ -234,12 +234,12 @@ impl<T: Config, C> TxInBlock<T, C> {
     }
 
     /// Return the hash of the block that the transaction has made it into.
-    pub fn block_hash(&self) -> T::Hash {
+    pub fn block_hash(&self) -> HashFor<T> {
         self.block_ref.hash()
     }
 
     /// Return the hash of the extrinsic that was submitted.
-    pub fn extrinsic_hash(&self) -> T::Hash {
+    pub fn extrinsic_hash(&self) -> HashFor<T> {
         self.ext_hash
     }
 }
@@ -281,6 +281,8 @@ impl<T: Config, C: OnlineClientT<T>> TxInBlock<T, C> {
     /// **Note:** This has to download block details from the node and decode events
     /// from them.
     pub async fn fetch_events(&self) -> Result<crate::blocks::ExtrinsicEvents<T>, Error> {
+        let hasher = self.client.hasher();
+
         let block_body = self
             .client
             .backend()
@@ -295,7 +297,7 @@ impl<T: Config, C: OnlineClientT<T>> TxInBlock<T, C> {
                 let Ok((_, stripped)) = strip_compact_prefix(ext) else {
                     return false;
                 };
-                let hash = T::Hasher::hash_of(&stripped);
+                let hash = hasher.hash_of(&stripped);
                 hash == self.ext_hash
             })
             // If we successfully obtain the block hash we think contains our
@@ -321,12 +323,13 @@ mod test {
     use crate::{
         backend::{StreamOfResults, TransactionStatus},
         client::{OfflineClientT, OnlineClientT},
+        config::{Config, HashFor},
         tx::TxProgress,
-        Config, Error, SubstrateConfig,
+        Error, SubstrateConfig,
     };
 
     type MockTxProgress = TxProgress<SubstrateConfig, MockClient>;
-    type MockHash = <SubstrateConfig as Config>::Hash;
+    type MockHash = HashFor<SubstrateConfig>;
     type MockSubstrateTxStatus = TransactionStatus<MockHash>;
 
     /// a mock client to satisfy trait bounds in tests
@@ -346,6 +349,10 @@ mod test {
             unimplemented!("just a mock impl to satisfy trait bounds")
         }
 
+        fn hasher(&self) -> <SubstrateConfig as Config>::Hasher {
+            unimplemented!("just a mock impl to satisfy trait bounds")
+        }
+
         fn client_state(&self) -> subxt_core::client::ClientState<SubstrateConfig> {
             unimplemented!("just a mock impl to satisfy trait bounds")
         }