Extrinsic Params Refinement (#1439)

* refinement based approach to params

* doc and test fixes

* bundle refine data into struct

subxt/examples/rpc_legacy.rs

@@ -40,7 +40,10 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
             .await?;
         let current_header = rpc.chain_get_header(None).await?.unwrap();
 
-        let ext_params = Params::new().mortal(&current_header, 8).build();
+        let ext_params = Params::new()
+            .mortal(&current_header, 8)
+            .nonce(current_nonce)
+            .build();
 
         let balance_transfer = polkadot::tx()
             .balances()
@@ -48,7 +51,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
 
         let ext_hash = api
             .tx()
-            .create_signed_with_nonce(&balance_transfer, &alice, current_nonce, ext_params)?
+            .create_signed_offline(&balance_transfer, &alice, ext_params)?
             .submit()
             .await?;
 

subxt/examples/setup_config_custom.rs

@@ -1,7 +1,9 @@
 #![allow(missing_docs)]
 use codec::Encode;
 use subxt::client::OfflineClientT;
-use subxt::config::{Config, ExtrinsicParams, ExtrinsicParamsEncoder, ExtrinsicParamsError};
+use subxt::config::{
+    Config, ExtrinsicParams, ExtrinsicParamsEncoder, ExtrinsicParamsError, RefineParams,
+};
 use subxt_signer::sr25519::dev;
 
 #[subxt::subxt(runtime_metadata_path = "../artifacts/polkadot_metadata_full.scale")]
@@ -51,24 +53,27 @@ impl CustomExtrinsicParamsBuilder {
     }
 }
 
+impl<T: Config> RefineParams<T> for CustomExtrinsicParamsBuilder {}
+
 // Describe how to fetch and then encode the params:
 impl<T: Config> ExtrinsicParams<T> for CustomExtrinsicParams<T> {
-    type OtherParams = CustomExtrinsicParamsBuilder;
+    type Params = CustomExtrinsicParamsBuilder;
 
     // Gather together all of the params we will need to encode:
     fn new<Client: OfflineClientT<T>>(
-        _nonce: u64,
         client: Client,
-        other_params: Self::OtherParams,
+        params: Self::Params,
     ) -> Result<Self, ExtrinsicParamsError> {
         Ok(Self {
             genesis_hash: client.genesis_hash(),
-            tip: other_params.tip,
-            foo: other_params.foo,
+            tip: params.tip,
+            foo: params.foo,
         })
     }
 }
 
+impl<T: Config> RefineParams<T> for CustomExtrinsicParams<T> {}
+
 // Encode the relevant params when asked:
 impl<T: Config> ExtrinsicParamsEncoder for CustomExtrinsicParams<T> {
     fn encode_extra_to(&self, v: &mut Vec<u8>) {
@@ -86,7 +91,7 @@ async fn main() {
 
     let tx_payload = runtime::tx().system().remark(b"Hello".to_vec());
 
-    // Build your custom "OtherParams":
+    // Build your custom "Params":
     let tx_config = CustomExtrinsicParamsBuilder::new().tip(1234).enable_foo();
 
     // And provide them when submitting a transaction:

subxt/examples/setup_config_signed_extension.rs

@@ -58,12 +58,11 @@ impl<T: Config> signed_extensions::SignedExtension<T> for CustomSignedExtension
 
 // Gather together any params we need for our signed extension, here none.
 impl<T: Config> ExtrinsicParams<T> for CustomSignedExtension {
-    type OtherParams = ();
+    type Params = ();
 
     fn new<Client: OfflineClientT<T>>(
-        _nonce: u64,
         _client: Client,
-        _other_params: Self::OtherParams,
+        _params: Self::Params,
     ) -> Result<Self, ExtrinsicParamsError> {
         Ok(CustomSignedExtension)
     }
@@ -80,13 +79,13 @@ impl ExtrinsicParamsEncoder for CustomSignedExtension {
 }
 
 // When composing a tuple of signed extensions, the user parameters we need must
-// be able to convert `Into` a tuple of corresponding `OtherParams`. Here, we just
-// "hijack" the default param builder, but add the `OtherParams` (`()`) for our
+// be able to convert `Into` a tuple of corresponding `Params`. Here, we just
+// "hijack" the default param builder, but add the `Params` (`()`) for our
 // new signed extension at the end, to make the types line up. IN reality you may wish
-// to construct an entirely new interface to provide the relevant `OtherParams`.
+// to construct an entirely new interface to provide the relevant `Params`.
 pub fn custom(
     params: DefaultExtrinsicParamsBuilder<CustomConfig>,
-) -> <<CustomConfig as Config>::ExtrinsicParams as ExtrinsicParams<CustomConfig>>::OtherParams {
+) -> <<CustomConfig as Config>::ExtrinsicParams as ExtrinsicParams<CustomConfig>>::Params {
     let (a, b, c, d, e, f, g) = params.build();
     (a, b, c, d, e, f, g, ())
 }