Rework Subxt API to support offline and dynamic transactions

CHANGELOG.md

@@ -92,7 +92,7 @@ parameters (such as mortality and tip payment) to be customized. See `examples/b
 small usage example.
 
 If you're targeting a node which involves custom additional and extra transaction data, you'll need to implement the
-trait `subxt::extrinsic::ExtrinsicParams`, which determines the parameters that can be provided to `sign_and_submit`, as
+trait `subxt::tx::ExtrinsicParams`, which determines the parameters that can be provided to `sign_and_submit`, as
 well as how to encode these into the "additional" and "extra" data needed for a transaction. Have a look at
 `subxt/src/extrinsic/params.rs` for the trait definition and Substrate/Polkadot implementations. The aim with this change
 is to make it easier to customise this for your own chains, and provide a simple way to provide values at runtime.

codegen/src/api/calls.rs

@@ -22,31 +22,8 @@ use quote::{
 };
 use scale_info::form::PortableForm;
 
-/// Generate calls from the provided pallet's metadata.
-///
-/// The function creates a new module named `calls` under the pallet's module.
-/// ```ignore
-/// pub mod PalletName {
-///     pub mod calls {
-///     ...
-///     }
-/// }
-/// ```
-///
-/// The function generates the calls as rust structs that implement the `subxt::Call` trait
-/// to uniquely identify the call's identity when creating the extrinsic.
-///
-/// ```ignore
-/// pub struct CallName {
-///      pub call_param: type,
-/// }
-/// impl ::subxt::Call for CallName {
-/// ...
-/// }
-/// ```
-///
-/// Calls are extracted from the API and wrapped into the generated `TransactionApi` of
-/// each module.
+/// Generate calls from the provided pallet's metadata. Each call returns a `StaticTxPayload`
+/// that can be passed to the subxt client to submit/sign/encode.
 ///
 /// # Arguments
 ///
@@ -76,35 +53,42 @@ pub fn generate_calls(
     let (call_structs, call_fns): (Vec<_>, Vec<_>) = struct_defs
         .iter_mut()
         .map(|(variant_name, struct_def)| {
-            let (call_fn_args, call_args): (Vec<_>, Vec<_>) =
-                match struct_def.fields {
-                    CompositeDefFields::Named(ref named_fields) => {
-                        named_fields
-                            .iter()
-                            .map(|(name, field)| {
-                                let fn_arg_type = &field.type_path;
-                                let call_arg = if field.is_boxed() {
-                                    quote! { #name: ::std::boxed::Box::new(#name) }
-                                } else {
-                                    quote! { #name }
-                                };
-                                (quote!( #name: #fn_arg_type ), call_arg)
-                            })
-                            .unzip()
-                    }
-                    CompositeDefFields::NoFields => Default::default(),
-                    CompositeDefFields::Unnamed(_) =>
-                        abort_call_site!(
-                            "Call variant for type {} must have all named fields",
-                            call.ty.id()
-                        )
-                };
+            let (call_fn_args, call_args): (Vec<_>, Vec<_>) = match struct_def.fields {
+                CompositeDefFields::Named(ref named_fields) => {
+                    named_fields
+                        .iter()
+                        .map(|(name, field)| {
+                            let fn_arg_type = &field.type_path;
+                            let call_arg = if field.is_boxed() {
+                                quote! { #name: ::std::boxed::Box::new(#name) }
+                            } else {
+                                quote! { #name }
+                            };
+                            (quote!( #name: #fn_arg_type ), call_arg)
+                        })
+                        .unzip()
+                }
+                CompositeDefFields::NoFields => Default::default(),
+                CompositeDefFields::Unnamed(_) => {
+                    abort_call_site!(
+                        "Call variant for type {} must have all named fields",
+                        call.ty.id()
+                    )
+                }
+            };
 
             let pallet_name = &pallet.name;
             let call_name = &variant_name;
             let struct_name = &struct_def.name;
-            let call_hash = subxt_metadata::get_call_hash(metadata, pallet_name, call_name)
-                .unwrap_or_else(|_| abort_call_site!("Metadata information for the call {}_{} could not be found", pallet_name, call_name));
+            let call_hash =
+                subxt_metadata::get_call_hash(metadata, pallet_name, call_name)
+                    .unwrap_or_else(|_| {
+                        abort_call_site!(
+                            "Metadata information for the call {}_{} could not be found",
+                            pallet_name,
+                            call_name
+                        )
+                    });
 
             let fn_name = format_ident!("{}", variant_name.to_snake_case());
             // Propagate the documentation just to `TransactionApi` methods, while
@@ -113,29 +97,19 @@ pub fn generate_calls(
             // The call structure's documentation was stripped above.
             let call_struct = quote! {
                 #struct_def
-
-                impl ::subxt::Call for #struct_name {
-                    const PALLET: &'static str = #pallet_name;
-                    const FUNCTION: &'static str = #call_name;
-                }
             };
             let client_fn = quote! {
                 #docs
                 pub fn #fn_name(
                     &self,
                     #( #call_fn_args, )*
-                ) -> Result<::subxt::SubmittableExtrinsic<'a, T, X, #struct_name, DispatchError, root_mod::Event>, ::subxt::BasicError> {
-                    let runtime_call_hash = {
-                        let locked_metadata = self.client.metadata();
-                        let metadata = locked_metadata.read();
-                        metadata.call_hash::<#struct_name>()?
-                    };
-                    if runtime_call_hash == [#(#call_hash,)*] {
-                        let call = #struct_name { #( #call_args, )* };
-                        Ok(::subxt::SubmittableExtrinsic::new(self.client, call))
-                    } else {
-                        Err(::subxt::MetadataError::IncompatibleMetadata.into())
-                    }
+                ) -> ::subxt::tx::StaticTxPayload<#struct_name> {
+                    ::subxt::tx::StaticTxPayload::new(
+                        #pallet_name,
+                        #call_name,
+                        #struct_name { #( #call_args, )* },
+                        [#(#call_hash,)*]
+                    )
                 }
             };
             (call_struct, client_fn)
@@ -155,20 +129,9 @@ pub fn generate_calls(
 
             #( #call_structs )*
 
-            pub struct TransactionApi<'a, T: ::subxt::Config, X> {
-                client: &'a ::subxt::Client<T>,
-                marker: ::core::marker::PhantomData<X>,
-            }
-
-            impl<'a, T, X> TransactionApi<'a, T, X>
-            where
-                T: ::subxt::Config,
-                X: ::subxt::extrinsic::ExtrinsicParams<T>,
-            {
-                pub fn new(client: &'a ::subxt::Client<T>) -> Self {
-                    Self { client, marker: ::core::marker::PhantomData }
-                }
+            pub struct TransactionApi;
 
+            impl TransactionApi {
                 #( #call_fns )*
             }
         }

codegen/src/api/constants.rs

@@ -63,17 +63,12 @@ pub fn generate_constants(
 
         quote! {
             #( #[doc = #docs ] )*
-            pub fn #fn_name(&self) -> ::core::result::Result<#return_ty, ::subxt::BasicError> {
-                let locked_metadata = self.client.metadata();
-                let metadata = locked_metadata.read();
-                if metadata.constant_hash(#pallet_name, #constant_name)? == [#(#constant_hash,)*] {
-                    let pallet = metadata.pallet(#pallet_name)?;
-                    let constant = pallet.constant(#constant_name)?;
-                    let value = ::subxt::codec::Decode::decode(&mut &constant.value[..])?;
-                    Ok(value)
-                } else {
-                    Err(::subxt::MetadataError::IncompatibleMetadata.into())
-                }
+            pub fn #fn_name(&self) -> ::subxt::constants::StaticConstantAddress<::subxt::metadata::DecodeStaticType<#return_ty>> {
+                ::subxt::constants::StaticConstantAddress::new(
+                    #pallet_name,
+                    #constant_name,
+                    [#(#constant_hash,)*]
+                )
             }
         }
     });
@@ -82,15 +77,9 @@ pub fn generate_constants(
         pub mod constants {
             use super::#types_mod_ident;
 
-            pub struct ConstantsApi<'a, T: ::subxt::Config> {
-                client: &'a ::subxt::Client<T>,
-            }
-
-            impl<'a, T: ::subxt::Config> ConstantsApi<'a, T> {
-                pub fn new(client: &'a ::subxt::Client<T>) -> Self {
-                    Self { client }
-                }
+            pub struct ConstantsApi;
 
+            impl ConstantsApi {
                 #(#constant_fns)*
             }
         }