Extrinsic Params Refinement (#1439)

* refinement based approach to params

* doc and test fixes

* bundle refine data into struct

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