Extrinsic Params Refinement (#1439)

* refinement based approach to params

* doc and test fixes

* bundle refine data into struct

subxt/src/book/setup/config.rs

@@ -71,7 +71,7 @@
 //!
 //! The `ExtrinsicParams` config type expects to be given an implementation of the [`crate::config::ExtrinsicParams`] trait.
 //! Implementations of the [`crate::config::ExtrinsicParams`] trait are handed some parameters from Subxt itself, and can
-//! accept arbitrary `OtherParams` from users, and are then expected to provide this "extra" and "additional" data when asked
+//! accept arbitrary other `Params` from users, and are then expected to provide this "extra" and "additional" data when asked
 //! via the required [`crate::config::ExtrinsicParamsEncoder`] impl.
 //!
 //! **In most cases, the default [crate::config::DefaultExtrinsicParams] type will work**: it understands the "standard"

subxt/src/book/usage/transactions.rs

@@ -137,11 +137,10 @@
 //!     Value::from_bytes("Hello there")
 //! ]);
 //!
-//! // Construct the tx but don't sign it. You need to provide the nonce
-//! // here, or can use `create_partial_signed` to fetch the correct nonce.
-//! let partial_tx = client.tx().create_partial_signed_with_nonce(
+//! // Construct the tx but don't sign it. The account nonce here defaults to 0.
+//! // You can use `create_partial_signed` to fetch the correct nonce.
+//! let partial_tx = client.tx().create_partial_signed_offline(
 //!     &payload,
-//!     0u64,
 //!     Default::default()
 //! )?;
 //!

subxt/src/config/default_extrinsic_params.rs

@@ -2,6 +2,7 @@
 // This file is dual-licensed as Apache-2.0 or GPL-3.0.
 // see LICENSE for license details.
 
+use super::signed_extensions::CheckNonceParams;
 use super::{signed_extensions, ExtrinsicParams};
 use super::{Config, Header};
 
@@ -20,12 +21,14 @@ pub type DefaultExtrinsicParams<T> = signed_extensions::AnyOf<
     ),
 >;
 
-/// A builder that outputs the set of [`super::ExtrinsicParams::OtherParams`] required for
+/// A builder that outputs the set of [`super::ExtrinsicParams::Params`] required for
 /// [`DefaultExtrinsicParams`]. This may expose methods that aren't applicable to the current
 /// chain; such values will simply be ignored if so.
 pub struct DefaultExtrinsicParamsBuilder<T: Config> {
     /// `None` means the tx will be immortal.
     mortality: Option<Mortality<T::Hash>>,
+    /// `None` means the nonce will be automatically set.
+    nonce: Option<u64>,
     /// `None` means we'll use the native token.
     tip_of_asset_id: Option<T::AssetId>,
     tip: u128,
@@ -49,6 +52,7 @@ impl<T: Config> Default for DefaultExtrinsicParamsBuilder<T> {
             tip: 0,
             tip_of: 0,
             tip_of_asset_id: None,
+            nonce: None,
         }
     }
 }
@@ -72,6 +76,12 @@ impl<T: Config> DefaultExtrinsicParamsBuilder<T> {
         self
     }
 
+    /// Provide a specific nonce for the submitter of the extrinsic
+    pub fn nonce(mut self, nonce: u64) -> Self {
+        self.nonce = Some(nonce);
+        self
+    }
+
     /// Make the transaction mortal, given a block number and block hash (which must both point to
     /// the same block) that it should be mortal from, and the number of blocks (roughly; it'll be
     /// rounded to a power of two) that it will be mortal for.
@@ -111,7 +121,7 @@ impl<T: Config> DefaultExtrinsicParamsBuilder<T> {
     }
 
     /// Build the extrinsic parameters.
-    pub fn build(self) -> <DefaultExtrinsicParams<T> as ExtrinsicParams<T>>::OtherParams {
+    pub fn build(self) -> <DefaultExtrinsicParams<T> as ExtrinsicParams<T>>::Params {
         let check_mortality_params = if let Some(mortality) = self.mortality {
             signed_extensions::CheckMortalityParams::mortal(
                 mortality.period,
@@ -131,10 +141,12 @@ impl<T: Config> DefaultExtrinsicParamsBuilder<T> {
         let charge_transaction_params =
             signed_extensions::ChargeTransactionPaymentParams::tip(self.tip);
 
+        let check_nonce_params = CheckNonceParams(self.nonce);
+
         (
             (),
             (),
-            (),
+            check_nonce_params,
             (),
             check_mortality_params,
             charge_asset_tx_params,

subxt/src/config/extrinsic_params.rs

@@ -10,6 +10,8 @@
 use crate::{client::OfflineClientT, Config};
 use core::fmt::Debug;
 
+use super::refine_params::RefineParams;
+
 /// An error that can be emitted when trying to construct an instance of [`ExtrinsicParams`],
 /// encode data from the instance, or match on signed extensions.
 #[derive(thiserror::Error, Debug)]
@@ -53,13 +55,12 @@ pub trait ExtrinsicParams<T: Config>: ExtrinsicParamsEncoder + Sized + 'static {
     /// These parameters can be provided to the constructor along with
     /// some default parameters that `subxt` understands, in order to
     /// help construct your [`ExtrinsicParams`] object.
-    type OtherParams;
+    type Params: RefineParams<T>;
 
     /// Construct a new instance of our [`ExtrinsicParams`].
     fn new<Client: OfflineClientT<T>>(
-        nonce: u64,
         client: Client,
-        other_params: Self::OtherParams,
+        params: Self::Params,
     ) -> Result<Self, ExtrinsicParamsError>;
 }
 

subxt/src/config/mod.rs

@@ -10,6 +10,7 @@
 
 mod default_extrinsic_params;
 mod extrinsic_params;
+mod refine_params;
 
 pub mod polkadot;
 pub mod signed_extensions;
@@ -25,6 +26,7 @@ use serde::{de::DeserializeOwned, Serialize};
 pub use default_extrinsic_params::{DefaultExtrinsicParams, DefaultExtrinsicParamsBuilder};
 pub use extrinsic_params::{ExtrinsicParams, ExtrinsicParamsEncoder, ExtrinsicParamsError};
 pub use polkadot::{PolkadotConfig, PolkadotExtrinsicParams, PolkadotExtrinsicParamsBuilder};
+pub use refine_params::{RefineParams, RefineParamsData};
 pub use signed_extensions::SignedExtension;
 pub use substrate::{SubstrateConfig, SubstrateExtrinsicParams, SubstrateExtrinsicParamsBuilder};
 
@@ -60,7 +62,7 @@ pub trait Config: Sized + Send + Sync + 'static {
 }
 
 /// given some [`Config`], this return the other params needed for its `ExtrinsicParams`.
-pub type OtherParamsFor<T> = <<T as Config>::ExtrinsicParams as ExtrinsicParams<T>>::OtherParams;
+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:

subxt/src/config/refine_params.rs

@@ -0,0 +1,85 @@
+// Copyright 2019-2023 Parity Technologies (UK) Ltd.
+// This file is dual-licensed as Apache-2.0 or GPL-3.0.
+// see LICENSE for license details.
+
+//! Refining params with values fetched from the chain
+
+use crate::Config;
+
+/// Data that can be used to refine the params of signed extensions.
+pub struct RefineParamsData<T: Config> {
+    account_nonce: u64,
+    block_number: u64,
+    block_hash: T::Hash,
+}
+
+impl<T: Config> RefineParamsData<T> {
+    pub(crate) fn new(account_nonce: u64, block_number: u64, block_hash: T::Hash) -> Self {
+        RefineParamsData {
+            account_nonce,
+            block_number,
+            block_hash,
+        }
+    }
+
+    /// account nonce for extrinsic author
+    pub fn account_nonce(&self) -> u64 {
+        self.account_nonce
+    }
+
+    /// latest finalized block number
+    pub fn block_number(&self) -> u64 {
+        self.block_number
+    }
+
+    /// latest finalized block hash
+    pub fn block_hash(&self) -> T::Hash {
+        self.block_hash
+    }
+}
+
+/// Types implementing [`RefineParams`] can be modified to reflect live information from the chain.
+pub trait RefineParams<T: Config> {
+    /// Refine params to an extrinsic. There is usually some notion of 'the param is already set/unset' in types implementing this trait.
+    /// The refinement should most likely not affect cases where a param is in a 'is already set by the user' state.
+    fn refine(&mut self, _data: &RefineParamsData<T>) {}
+}
+
+impl<T: Config> RefineParams<T> for () {}
+
+macro_rules! impl_tuples {
+    ($($ident:ident $index:tt),+) => {
+
+        impl <T: Config, $($ident : RefineParams<T>),+> RefineParams<T> for ($($ident,)+){
+            fn refine(&mut self, data: &RefineParamsData<T>) {
+                $(self.$index.refine(data);)+
+            }
+
+        }
+    }
+}
+
+#[rustfmt::skip]
+const _: () = {
+    impl_tuples!(A 0);
+    impl_tuples!(A 0, B 1);
+    impl_tuples!(A 0, B 1, C 2);
+    impl_tuples!(A 0, B 1, C 2, D 3);
+    impl_tuples!(A 0, B 1, C 2, D 3, E 4);
+    impl_tuples!(A 0, B 1, C 2, D 3, E 4, F 5);
+    impl_tuples!(A 0, B 1, C 2, D 3, E 4, F 5, G 6);
+    impl_tuples!(A 0, B 1, C 2, D 3, E 4, F 5, G 6, H 7);
+    impl_tuples!(A 0, B 1, C 2, D 3, E 4, F 5, G 6, H 7, I 8);
+    impl_tuples!(A 0, B 1, C 2, D 3, E 4, F 5, G 6, H 7, I 8, J 9);
+    impl_tuples!(A 0, B 1, C 2, D 3, E 4, F 5, G 6, H 7, I 8, J 9, K 10);
+    impl_tuples!(A 0, B 1, C 2, D 3, E 4, F 5, G 6, H 7, I 8, J 9, K 10, L 11);
+    impl_tuples!(A 0, B 1, C 2, D 3, E 4, F 5, G 6, H 7, I 8, J 9, K 10, L 11, M 12);
+    impl_tuples!(A 0, B 1, C 2, D 3, E 4, F 5, G 6, H 7, I 8, J 9, K 10, L 11, M 12, N 13);
+    impl_tuples!(A 0, B 1, C 2, D 3, E 4, F 5, G 6, H 7, I 8, J 9, K 10, L 11, M 12, N 13, O 14);
+    impl_tuples!(A 0, B 1, C 2, D 3, E 4, F 5, G 6, H 7, I 8, J 9, K 10, L 11, M 12, N 13, O 14, P 15);
+    impl_tuples!(A 0, B 1, C 2, D 3, E 4, F 5, G 6, H 7, I 8, J 9, K 10, L 11, M 12, N 13, O 14, P 15, Q 16);
+    impl_tuples!(A 0, B 1, C 2, D 3, E 4, F 5, G 6, H 7, I 8, J 9, K 10, L 11, M 12, N 13, O 14, P 15, Q 16, R 17);
+    impl_tuples!(A 0, B 1, C 2, D 3, E 4, F 5, G 6, H 7, I 8, J 9, K 10, L 11, M 12, N 13, O 14, P 15, Q 16, R 17, S 18);
+    impl_tuples!(A 0, B 1, C 2, D 3, E 4, F 5, G 6, H 7, I 8, J 9, K 10, L 11, M 12, N 13, O 14, P 15, Q 16, R 17, S 18, U 19);
+    impl_tuples!(A 0, B 1, C 2, D 3, E 4, F 5, G 6, H 7, I 8, J 9, K 10, L 11, M 12, N 13, O 14, P 15, Q 16, R 17, S 18, U 19, V 20);
+};

subxt/src/config/signed_extensions.rs

@@ -8,6 +8,8 @@
 //! when interacting with a chain.
 
 use super::extrinsic_params::{ExtrinsicParams, ExtrinsicParamsEncoder, ExtrinsicParamsError};
+use super::refine_params::RefineParamsData;
+use super::RefineParams;
 use crate::utils::Era;
 use crate::{client::OfflineClientT, Config};
 use codec::{Compact, Encode};
@@ -37,12 +39,11 @@ pub trait SignedExtension<T: Config>: ExtrinsicParams<T> {
 pub struct CheckSpecVersion(u32);
 
 impl<T: Config> ExtrinsicParams<T> for CheckSpecVersion {
-    type OtherParams = ();
+    type Params = ();
 
     fn new<Client: OfflineClientT<T>>(
-        _nonce: u64,
         client: Client,
-        _other_params: Self::OtherParams,
+        _params: Self::Params,
     ) -> Result<Self, ExtrinsicParamsError> {
         Ok(CheckSpecVersion(client.runtime_version().spec_version))
     }
@@ -65,13 +66,14 @@ impl<T: Config> SignedExtension<T> for CheckSpecVersion {
 pub struct CheckNonce(Compact<u64>);
 
 impl<T: Config> ExtrinsicParams<T> for CheckNonce {
-    type OtherParams = ();
+    type Params = CheckNonceParams;
 
     fn new<Client: OfflineClientT<T>>(
-        nonce: u64,
         _client: Client,
-        _other_params: Self::OtherParams,
+        params: Self::Params,
     ) -> Result<Self, ExtrinsicParamsError> {
+        // If no nonce is set (nor by user nor refinement), use a nonce of 0.
+        let nonce = params.0.unwrap_or(0);
         Ok(CheckNonce(Compact(nonce)))
     }
 }
@@ -89,16 +91,27 @@ impl<T: Config> SignedExtension<T> for CheckNonce {
     }
 }
 
+/// Params for [`CheckNonce`]
+#[derive(Debug, Clone, Default)]
+pub struct CheckNonceParams(pub Option<u64>);
+
+impl<T: Config> RefineParams<T> for CheckNonceParams {
+    fn refine(&mut self, data: &RefineParamsData<T>) {
+        if self.0.is_none() {
+            self.0 = Some(data.account_nonce());
+        }
+    }
+}
+
 /// The [`CheckTxVersion`] signed extension.
 pub struct CheckTxVersion(u32);
 
 impl<T: Config> ExtrinsicParams<T> for CheckTxVersion {
-    type OtherParams = ();
+    type Params = ();
 
     fn new<Client: OfflineClientT<T>>(
-        _nonce: u64,
         client: Client,
-        _other_params: Self::OtherParams,
+        _params: Self::Params,
     ) -> Result<Self, ExtrinsicParamsError> {
         Ok(CheckTxVersion(client.runtime_version().transaction_version))
     }
@@ -121,12 +134,11 @@ impl<T: Config> SignedExtension<T> for CheckTxVersion {
 pub struct CheckGenesis<T: Config>(T::Hash);
 
 impl<T: Config> ExtrinsicParams<T> for CheckGenesis<T> {
-    type OtherParams = ();
+    type Params = ();
 
     fn new<Client: OfflineClientT<T>>(
-        _nonce: u64,
         client: Client,
-        _other_params: Self::OtherParams,
+        _params: Self::Params,
     ) -> Result<Self, ExtrinsicParamsError> {
         Ok(CheckGenesis(client.genesis_hash()))
     }
@@ -152,16 +164,25 @@ pub struct CheckMortality<T: Config> {
 }
 
 /// Parameters to configure the [`CheckMortality`] signed extension.
-pub struct CheckMortalityParams<T: Config> {
+pub struct CheckMortalityParams<T: Config>(Option<CheckMortalityParamsInner<T>>);
+struct CheckMortalityParamsInner<T: Config> {
     era: Era,
     checkpoint: Option<T::Hash>,
 }
 
 impl<T: Config> Default for CheckMortalityParams<T> {
     fn default() -> Self {
-        Self {
-            era: Default::default(),
-            checkpoint: Default::default(),
+        CheckMortalityParams(None)
+    }
+}
+
+impl<T: Config> RefineParams<T> for CheckMortalityParams<T> {
+    fn refine(&mut self, data: &RefineParamsData<T>) {
+        if self.0.is_none() {
+            // By default we refine the params to have a mortal transaction valid for 32 blocks.
+            const TX_VALID_FOR: u64 = 32;
+            *self =
+                CheckMortalityParams::mortal(TX_VALID_FOR, data.block_number(), data.block_hash());
         }
     }
 }
@@ -172,32 +193,39 @@ impl<T: Config> CheckMortalityParams<T> {
     /// `block_hash` should both point to the same block, and are the block that
     /// the transaction is mortal from.
     pub fn mortal(period: u64, block_number: u64, block_hash: T::Hash) -> Self {
-        CheckMortalityParams {
+        Self(Some(CheckMortalityParamsInner {
             era: Era::mortal(period, block_number),
             checkpoint: Some(block_hash),
-        }
+        }))
     }
     /// An immortal transaction.
     pub fn immortal() -> Self {
-        CheckMortalityParams {
+        Self(Some(CheckMortalityParamsInner {
             era: Era::Immortal,
             checkpoint: None,
-        }
+        }))
     }
 }
 
 impl<T: Config> ExtrinsicParams<T> for CheckMortality<T> {
-    type OtherParams = CheckMortalityParams<T>;
+    type Params = CheckMortalityParams<T>;
 
     fn new<Client: OfflineClientT<T>>(
-        _nonce: u64,
         client: Client,
-        other_params: Self::OtherParams,
+        params: Self::Params,
     ) -> Result<Self, ExtrinsicParamsError> {
-        Ok(CheckMortality {
-            era: other_params.era,
-            checkpoint: other_params.checkpoint.unwrap_or(client.genesis_hash()),
-        })
+        let check_mortality = if let Some(params) = params.0 {
+            CheckMortality {
+                era: params.era,
+                checkpoint: params.checkpoint.unwrap_or(client.genesis_hash()),
+            }
+        } else {
+            CheckMortality {
+                era: Era::Immortal,
+                checkpoint: client.genesis_hash(),
+            }
+        };
+        Ok(check_mortality)
     }
 }
 
@@ -278,20 +306,21 @@ impl<T: Config> ChargeAssetTxPaymentParams<T> {
 }
 
 impl<T: Config> ExtrinsicParams<T> for ChargeAssetTxPayment<T> {
-    type OtherParams = ChargeAssetTxPaymentParams<T>;
+    type Params = ChargeAssetTxPaymentParams<T>;
 
     fn new<Client: OfflineClientT<T>>(
-        _nonce: u64,
         _client: Client,
-        other_params: Self::OtherParams,
+        params: Self::Params,
     ) -> Result<Self, ExtrinsicParamsError> {
         Ok(ChargeAssetTxPayment {
-            tip: Compact(other_params.tip),
-            asset_id: other_params.asset_id,
+            tip: Compact(params.tip),
+            asset_id: params.asset_id,
         })
     }
 }
 
+impl<T: Config> RefineParams<T> for ChargeAssetTxPaymentParams<T> {}
+
 impl<T: Config> ExtrinsicParamsEncoder for ChargeAssetTxPayment<T> {
     fn encode_extra_to(&self, v: &mut Vec<u8>) {
         (self.tip, &self.asset_id).encode_to(v);
@@ -336,19 +365,20 @@ impl ChargeTransactionPaymentParams {
 }
 
 impl<T: Config> ExtrinsicParams<T> for ChargeTransactionPayment {
-    type OtherParams = ChargeTransactionPaymentParams;
+    type Params = ChargeTransactionPaymentParams;
 
     fn new<Client: OfflineClientT<T>>(
-        _nonce: u64,
         _client: Client,
-        other_params: Self::OtherParams,
+        params: Self::Params,
     ) -> Result<Self, ExtrinsicParamsError> {
         Ok(ChargeTransactionPayment {
-            tip: Compact(other_params.tip),
+            tip: Compact(params.tip),
         })
     }
 }
 
+impl<T: Config> RefineParams<T> for ChargeTransactionPaymentParams {}
+
 impl ExtrinsicParamsEncoder for ChargeTransactionPayment {
     fn encode_extra_to(&self, v: &mut Vec<u8>) {
         self.tip.encode_to(v);
@@ -380,12 +410,11 @@ macro_rules! impl_tuples {
             T: Config,
             $($ident: SignedExtension<T>,)+
         {
-            type OtherParams = ($($ident::OtherParams,)+);
+            type Params = ($($ident::Params,)+);
 
             fn new<Client: OfflineClientT<T>>(
-                nonce: u64,
                 client: Client,
-                other_params: Self::OtherParams,
+                params: Self::Params,
             ) -> Result<Self, ExtrinsicParamsError> {
                 let metadata = client.metadata();
                 let types = metadata.types();
@@ -401,7 +430,7 @@ macro_rules! impl_tuples {
                         }
                         // Break and record as soon as we find a match:
                         if $ident::matches(e.identifier(), e.extra_ty(), types) {
-                            let ext = $ident::new(nonce, client.clone(), other_params.$index)?;
+                            let ext = $ident::new(client.clone(), params.$index)?;
                             let boxed_ext: Box<dyn ExtrinsicParamsEncoder> = Box::new(ext);
                             exts_by_index.insert(idx, boxed_ext);
                             break

subxt/src/tx/tx_client.rs

@@ -7,8 +7,11 @@ use std::borrow::Cow;
 use crate::{
     backend::{BackendExt, BlockRef, TransactionStatus},
     client::{OfflineClientT, OnlineClientT},
-    config::{Config, ExtrinsicParams, ExtrinsicParamsEncoder, Hasher},
-    error::{Error, MetadataError},
+    config::{
+        Config, ExtrinsicParams, ExtrinsicParamsEncoder, Hasher, Header, RefineParams,
+        RefineParamsData,
+    },
+    error::{BlockError, Error, MetadataError},
     tx::{Signer as SignerT, TxPayload, TxProgress},
     utils::{Encoded, PhantomDataSendSync},
 };
@@ -103,11 +106,13 @@ impl<T: Config, C: OfflineClientT<T>> TxClient<T, C> {
     }
 
     /// Create a partial extrinsic.
-    pub fn create_partial_signed_with_nonce<Call>(
+    ///
+    /// Note: if not provided, the default account nonce will be set to 0 and the default mortality will be _immortal_.
+    /// This is because this method runs offline, and so is unable to fetch the data needed for more appropriate values.
+    pub fn create_partial_signed_offline<Call>(
         &self,
         call: &Call,
-        account_nonce: u64,
-        other_params: <T::ExtrinsicParams as ExtrinsicParams<T>>::OtherParams,
+        params: <T::ExtrinsicParams as ExtrinsicParams<T>>::Params,
     ) -> Result<PartialExtrinsic<T, C>, Error>
     where
         Call: TxPayload,
@@ -120,11 +125,8 @@ impl<T: Config, C: OfflineClientT<T>> TxClient<T, C> {
         let call_data = self.call_data(call)?;
 
         // 3. Construct our custom additional/extra params.
-        let additional_and_extra_params = <T::ExtrinsicParams as ExtrinsicParams<T>>::new(
-            account_nonce,
-            self.client.clone(),
-            other_params,
-        )?;
+        let additional_and_extra_params =
+            <T::ExtrinsicParams as ExtrinsicParams<T>>::new(self.client.clone(), params)?;
 
         // Return these details, ready to construct a signed extrinsic from.
         Ok(PartialExtrinsic {
@@ -135,12 +137,14 @@ impl<T: Config, C: OfflineClientT<T>> TxClient<T, C> {
     }
 
     /// Creates a signed extrinsic without submitting it.
-    pub fn create_signed_with_nonce<Call, Signer>(
+    ///
+    /// Note: if not provided, the default account nonce will be set to 0 and the default mortality will be _immortal_.
+    /// This is because this method runs offline, and so is unable to fetch the data needed for more appropriate values.
+    pub fn create_signed_offline<Call, Signer>(
         &self,
         call: &Call,
         signer: &Signer,
-        account_nonce: u64,
-        other_params: <T::ExtrinsicParams as ExtrinsicParams<T>>::OtherParams,
+        params: <T::ExtrinsicParams as ExtrinsicParams<T>>::Params,
     ) -> Result<SubmittableExtrinsic<T, C>, Error>
     where
         Call: TxPayload,
@@ -152,8 +156,7 @@ impl<T: Config, C: OfflineClientT<T>> TxClient<T, C> {
 
         // 2. Gather the "additional" and "extra" params along with the encoded call data,
         //    ready to be signed.
-        let partial_signed =
-            self.create_partial_signed_with_nonce(call, account_nonce, other_params)?;
+        let partial_signed = self.create_partial_signed_offline(call, params)?;
 
         // 3. Sign and construct an extrinsic from these details.
         Ok(partial_signed.sign(signer))
@@ -165,6 +168,30 @@ where
     T: Config,
     C: OnlineClientT<T>,
 {
+    /// Fetch the latest block header and account nonce from the backend and use them to refine [`ExtrinsicParams::Params`].
+    async fn refine_params(
+        &self,
+        account_id: &T::AccountId,
+        params: &mut <T::ExtrinsicParams as ExtrinsicParams<T>>::Params,
+    ) -> Result<(), Error> {
+        let block_ref = self.client.backend().latest_finalized_block_ref().await?;
+        let block_header = self
+            .client
+            .backend()
+            .block_header(block_ref.hash())
+            .await?
+            .ok_or_else(|| Error::Block(BlockError::not_found(block_ref.hash())))?;
+        let account_nonce =
+            crate::blocks::get_account_nonce(&self.client, account_id, block_ref.hash()).await?;
+
+        params.refine(&RefineParamsData::new(
+            account_nonce,
+            block_header.number().into(),
+            block_header.hash(),
+        ));
+        Ok(())
+    }
+
     /// Get the account nonce for a given account ID.
     pub async fn account_nonce(&self, account_id: &T::AccountId) -> Result<u64, Error> {
         let block_ref = self.client.backend().latest_finalized_block_ref().await?;
@@ -176,13 +203,15 @@ where
         &self,
         call: &Call,
         account_id: &T::AccountId,
-        other_params: <T::ExtrinsicParams as ExtrinsicParams<T>>::OtherParams,
+        mut params: <T::ExtrinsicParams as ExtrinsicParams<T>>::Params,
     ) -> Result<PartialExtrinsic<T, C>, Error>
     where
         Call: TxPayload,
     {
-        let account_nonce = self.account_nonce(account_id).await?;
-        self.create_partial_signed_with_nonce(call, account_nonce, other_params)
+        // Refine the params by adding account nonce and latest block information:
+        self.refine_params(account_id, &mut params).await?;
+        // Create the partial extrinsic with the refined params:
+        self.create_partial_signed_offline(call, params)
     }
 
     /// Creates a signed extrinsic, without submitting it.
@@ -190,14 +219,24 @@ where
         &self,
         call: &Call,
         signer: &Signer,
-        other_params: <T::ExtrinsicParams as ExtrinsicParams<T>>::OtherParams,
+        params: <T::ExtrinsicParams as ExtrinsicParams<T>>::Params,
     ) -> Result<SubmittableExtrinsic<T, C>, Error>
     where
         Call: TxPayload,
         Signer: SignerT<T>,
     {
-        let account_nonce = self.account_nonce(&signer.account_id()).await?;
-        self.create_signed_with_nonce(call, signer, account_nonce, other_params)
+        // 1. Validate this call against the current node metadata if the call comes
+        // with a hash allowing us to do so.
+        self.validate(call)?;
+
+        // 2. Gather the "additional" and "extra" params along with the encoded call data,
+        //    ready to be signed.
+        let partial_signed = self
+            .create_partial_signed(call, &signer.account_id(), params)
+            .await?;
+
+        // 3. Sign and construct an extrinsic from these details.
+        Ok(partial_signed.sign(signer))
     }
 
     /// Creates and signs an extrinsic and submits it to the chain. Passes default parameters
@@ -213,7 +252,7 @@ where
     where
         Call: TxPayload,
         Signer: SignerT<T>,
-        <T::ExtrinsicParams as ExtrinsicParams<T>>::OtherParams: Default,
+        <T::ExtrinsicParams as ExtrinsicParams<T>>::Params: Default,
     {
         self.sign_and_submit_then_watch(call, signer, Default::default())
             .await
@@ -227,13 +266,13 @@ where
         &self,
         call: &Call,
         signer: &Signer,
-        other_params: <T::ExtrinsicParams as ExtrinsicParams<T>>::OtherParams,
+        params: <T::ExtrinsicParams as ExtrinsicParams<T>>::Params,
     ) -> Result<TxProgress<T, C>, Error>
     where
         Call: TxPayload,
         Signer: SignerT<T>,
     {
-        self.create_signed(call, signer, other_params)
+        self.create_signed(call, signer, params)
             .await?
             .submit_and_watch()
             .await
@@ -257,7 +296,7 @@ where
     where
         Call: TxPayload,
         Signer: SignerT<T>,
-        <T::ExtrinsicParams as ExtrinsicParams<T>>::OtherParams: Default,
+        <T::ExtrinsicParams as ExtrinsicParams<T>>::Params: Default,
     {
         self.sign_and_submit(call, signer, Default::default()).await
     }
@@ -274,13 +313,13 @@ where
         &self,
         call: &Call,
         signer: &Signer,
-        other_params: <T::ExtrinsicParams as ExtrinsicParams<T>>::OtherParams,
+        params: <T::ExtrinsicParams as ExtrinsicParams<T>>::Params,
     ) -> Result<T::Hash, Error>
     where
         Call: TxPayload,
         Signer: SignerT<T>,
     {
-        self.create_signed(call, signer, other_params)
+        self.create_signed(call, signer, params)
             .await?
             .submit()
             .await