Split subxt (#102)

* Proc macro improvements.

* Use proc-macros.

* Update examples.

* Fix build.

* Run rustfmt.

* Fix total issuance test.

* Remove gas limit from put code call.

* Handle runtime errors.

* Fix tests.

* Make test more reliable.

* Revert "Handle runtime errors."

This reverts commit 26f30a9f4cfcfddfb3e49308cded46cfe6468697.

* Use expect instead of unwrap.

* Parse marker type.

* Fetch doesn't fail.

proc-macro/src/call.rs

@@ -28,9 +28,6 @@ use synstructure::Structure;
 
 pub fn call(s: Structure) -> TokenStream {
     let subxt = utils::use_crate("substrate-subxt");
-    let codec = utils::use_crate("parity-scale-codec");
-    let sp_core = utils::use_crate("sp-core");
-    let sp_runtime = utils::use_crate("sp-runtime");
     let ident = &s.ast().ident;
     let generics = &s.ast().generics;
     let params = utils::type_params(generics);
@@ -39,23 +36,35 @@ pub fn call(s: Structure) -> TokenStream {
         "with_{}",
         utils::path_to_ident(module).to_string().to_snake_case()
     );
-    let call_name = ident.to_string().trim_end_matches("Call").to_snake_case();
-    let call = format_ident!("{}", call_name);
-    let call_trait = format_ident!("{}CallExt", call_name.to_camel_case());
+    let call_name = utils::ident_to_name(ident, "Call").to_snake_case();
     let bindings = utils::bindings(&s);
-    let fields = bindings.iter().map(|bi| {
-        let ident = bi.ast().ident.as_ref().unwrap();
-        quote!(#ident,)
-    });
-    let args = bindings.iter().map(|bi| {
-        let ident = bi.ast().ident.as_ref().unwrap();
-        let ty = &bi.ast().ty;
-        quote!(#ident: #ty,)
-    });
-    let args = quote!(#(#args)*);
-    let ret = quote!(#subxt::ExtrinsicSuccess<T>);
+    let fields = utils::fields(&bindings);
+    let marker = utils::marker_field(&fields).unwrap_or_else(|| format_ident!("_"));
+    let filtered_fields = utils::filter_fields(&fields, &marker);
+    let args = utils::fields_to_args(&filtered_fields);
+    let build_struct = utils::build_struct(ident, &fields);
+    let xt_builder = generate_trait(
+        &module,
+        &call_name,
+        "XtBuilder",
+        quote!(&'a self),
+        quote!(T::Hash),
+        &args,
+        &build_struct,
+        &marker,
+    );
+    let events_subscriber = generate_trait(
+        &module,
+        &call_name,
+        "EventsSubscriber",
+        quote!(self),
+        quote!(#subxt::ExtrinsicSuccess<T>),
+        &args,
+        &build_struct,
+        &marker,
+    );
 
-    let expanded = quote! {
+    quote! {
         impl#generics #subxt::Call<T> for #ident<#(#params),*> {
             const MODULE: &'static str = MODULE;
             const FUNCTION: &'static str = #call_name;
@@ -67,32 +76,55 @@ pub fn call(s: Structure) -> TokenStream {
             }
         }
 
+        #xt_builder
+
+        #events_subscriber
+    }
+}
+
+pub fn generate_trait(
+    module: &syn::Path,
+    call: &str,
+    ty: &str,
+    me: TokenStream,
+    ret: TokenStream,
+    args: &TokenStream,
+    build_struct: &TokenStream,
+    marker: &syn::Ident,
+) -> TokenStream {
+    let subxt = utils::use_crate("substrate-subxt");
+    let codec = utils::use_crate("parity-scale-codec");
+    let call_trait = format_ident!("{}Call{}", call.to_camel_case(), ty);
+    let call = format_ident!("{}", call);
+    let ty = format_ident!("{}", ty);
+    quote! {
+        /// Call extension trait.
         pub trait #call_trait<T: #module> {
+            /// Create and submit the extrinsic.
             fn #call<'a>(
-                self,
+                #me,
                 #args
             ) -> core::pin::Pin<Box<dyn core::future::Future<Output = Result<#ret, #subxt::Error>> + Send + 'a>>;
         }
 
-        impl<T, P, S, E> #call_trait<T> for #subxt::EventsSubscriber<T, P, S, E>
+        impl<T, P, S, E> #call_trait<T> for #subxt::#ty<T, P, S, E>
         where
-            T: #module + #subxt::system::System + Send + Sync,
-            P: #sp_core::Pair,
-            S: #sp_runtime::traits::Verify + #codec::Codec + From<P::Signature> + Send + 'static,
-            S::Signer: From<P::Public> + #sp_runtime::traits::IdentifyAccount<AccountId = T::AccountId>,
+            T: #module + #subxt::system::System + Send + Sync + 'static,
+            P: #subxt::sp_core::Pair,
+            S: #subxt::sp_runtime::traits::Verify + #codec::Codec + From<P::Signature> + Send + 'static,
+            S::Signer: From<P::Public> + #subxt::sp_runtime::traits::IdentifyAccount<AccountId = T::AccountId>,
             T::Address: From<T::AccountId>,
-            E: #subxt::SignedExtra<T> + #sp_runtime::traits::SignedExtension + 'static,
+            E: #subxt::SignedExtra<T> + #subxt::sp_runtime::traits::SignedExtension + 'static,
         {
             fn #call<'a>(
-                self,
+                #me,
                 #args
             ) -> core::pin::Pin<Box<dyn core::future::Future<Output = Result<#ret, #subxt::Error>> + Send + 'a>> {
-                Box::pin(self.submit(#ident { #(#fields)* }))
+                let #marker = core::marker::PhantomData::<T>;
+                Box::pin(self.submit(#build_struct))
             }
         }
-    };
-
-    TokenStream::from(expanded)
+    }
 }
 
 #[cfg(test)]
@@ -121,7 +153,39 @@ mod tests {
                 }
             }
 
-            pub trait TransferCallExt<T: Balances> {
+            /// Call extension trait.
+            pub trait TransferCallXtBuilder<T: Balances> {
+                /// Create and submit the extrinsic.
+                fn transfer<'a>(
+                    &'a self,
+                    to: &'a <T as System>::Address,
+                    amount: T::Balance,
+                ) -> core::pin::Pin<Box<dyn core::future::Future<Output = Result<T::Hash, substrate_subxt::Error>> + Send + 'a>>;
+            }
+
+            impl<T, P, S, E> TransferCallXtBuilder<T> for substrate_subxt::XtBuilder<T, P, S, E>
+            where
+                T: Balances + substrate_subxt::system::System + Send + Sync + 'static,
+                P: substrate_subxt::sp_core::Pair,
+                S: substrate_subxt::sp_runtime::traits::Verify + codec::Codec + From<P::Signature> + Send + 'static,
+                S::Signer: From<P::Public> + substrate_subxt::sp_runtime::traits::IdentifyAccount<
+                    AccountId = T::AccountId>,
+                T::Address: From<T::AccountId>,
+                E: substrate_subxt::SignedExtra<T> + substrate_subxt::sp_runtime::traits::SignedExtension + 'static,
+            {
+                fn transfer<'a>(
+                    &'a self,
+                    to: &'a <T as System>::Address,
+                    amount: T::Balance,
+                ) -> core::pin::Pin<Box<dyn core::future::Future<Output = Result<T::Hash, substrate_subxt::Error>> + Send + 'a>> {
+                    let _ = core::marker::PhantomData::<T>;
+                    Box::pin(self.submit(TransferCall { to, amount, }))
+                }
+            }
+
+            /// Call extension trait.
+            pub trait TransferCallEventsSubscriber<T: Balances> {
+                /// Create and submit the extrinsic.
                 fn transfer<'a>(
                     self,
                     to: &'a <T as System>::Address,
@@ -129,21 +193,22 @@ mod tests {
                 ) -> core::pin::Pin<Box<dyn core::future::Future<Output = Result<substrate_subxt::ExtrinsicSuccess<T>, substrate_subxt::Error>> + Send + 'a>>;
             }
 
-            impl<T, P, S, E> TransferCallExt<T> for substrate_subxt::EventsSubscriber<T, P, S, E>
+            impl<T, P, S, E> TransferCallEventsSubscriber<T> for substrate_subxt::EventsSubscriber<T, P, S, E>
             where
-                T: Balances + substrate_subxt::system::System + Send + Sync,
-                P: sp_core::Pair,
-                S: sp_runtime::traits::Verify + codec::Codec + From<P::Signature> + Send + 'static,
-                S::Signer: From<P::Public> + sp_runtime::traits::IdentifyAccount<
+                T: Balances + substrate_subxt::system::System + Send + Sync + 'static,
+                P: substrate_subxt::sp_core::Pair,
+                S: substrate_subxt::sp_runtime::traits::Verify + codec::Codec + From<P::Signature> + Send + 'static,
+                S::Signer: From<P::Public> + substrate_subxt::sp_runtime::traits::IdentifyAccount<
                     AccountId = T::AccountId>,
                 T::Address: From<T::AccountId>,
-                E: substrate_subxt::SignedExtra<T> + sp_runtime::traits::SignedExtension + 'static,
+                E: substrate_subxt::SignedExtra<T> + substrate_subxt::sp_runtime::traits::SignedExtension + 'static,
             {
                 fn transfer<'a>(
                     self,
                     to: &'a <T as System>::Address,
                     amount: T::Balance,
                 ) -> core::pin::Pin<Box<dyn core::future::Future<Output = Result<substrate_subxt::ExtrinsicSuccess<T>, substrate_subxt::Error>> + Send + 'a>> {
+                    let _ = core::marker::PhantomData::<T>;
                     Box::pin(self.submit(TransferCall { to, amount, }))
                 }
             }

proc-macro/src/event.rs

@@ -32,7 +32,7 @@ pub fn event(s: Structure) -> TokenStream {
     let ident = &s.ast().ident;
     let generics = &s.ast().generics;
     let module = utils::module_name(generics);
-    let event_name = ident.to_string().trim_end_matches("Event").to_camel_case();
+    let event_name = utils::ident_to_name(ident, "Event").to_camel_case();
     let event = format_ident!("{}", event_name.to_snake_case());
     let event_trait = format_ident!("{}EventExt", event_name);
 
@@ -42,7 +42,9 @@ pub fn event(s: Structure) -> TokenStream {
             const EVENT: &'static str = #event_name;
         }
 
+        /// Event extension trait.
         pub trait #event_trait<T: #module> {
+            /// Retrieves the event.
             fn #event(&self) -> Result<Option<#ident<T>>, #codec::Error>;
         }
 
@@ -76,7 +78,9 @@ mod tests {
                 const EVENT: &'static str = "Transfer";
             }
 
+            /// Event extension trait.
             pub trait TransferEventExt<T: Balances> {
+                /// Retrieves the event.
                 fn transfer(&self) -> Result<Option<TransferEvent<T>>, codec::Error>;
             }
 

proc-macro/src/module.rs

@@ -21,6 +21,43 @@ use quote::{
     format_ident,
     quote,
 };
+use syn::parse::{
+    Parse,
+    ParseStream,
+};
+
+mod kw {
+    use syn::custom_keyword;
+
+    custom_keyword!(ignore);
+}
+
+#[derive(Debug)]
+enum ModuleAttr {
+    Ignore(kw::ignore),
+}
+
+impl Parse for ModuleAttr {
+    fn parse(input: ParseStream) -> syn::Result<Self> {
+        Ok(Self::Ignore(input.parse()?))
+    }
+}
+
+type ModuleAttrs = utils::Attrs<ModuleAttr>;
+
+fn ignore(attrs: &[syn::Attribute]) -> bool {
+    for attr in attrs {
+        if let Some(ident) = attr.path.get_ident() {
+            if ident.to_string() == "module" {
+                let attrs: ModuleAttrs = syn::parse2(attr.tokens.clone()).unwrap();
+                if !attrs.attrs.is_empty() {
+                    return true
+                }
+            }
+        }
+    }
+    false
+}
 
 fn events_decoder_trait_name(module: &syn::Ident) -> syn::Ident {
     format_ident!("{}EventsDecoder", module.to_string())
@@ -30,8 +67,12 @@ fn with_module_ident(module: &syn::Ident) -> syn::Ident {
     format_ident!("with_{}", module.to_string().to_snake_case())
 }
 
-pub fn module(_args: TokenStream, input: TokenStream) -> TokenStream {
-    let input: syn::ItemTrait = syn::parse2(input).unwrap();
+pub fn module(_args: TokenStream, tokens: TokenStream) -> TokenStream {
+    let input: Result<syn::ItemTrait, _> = syn::parse2(tokens.clone());
+    if input.is_err() {
+        return tokens
+    }
+    let input = input.unwrap();
 
     let subxt = utils::use_crate("substrate-subxt");
     let module = &input.ident;
@@ -52,6 +93,9 @@ pub fn module(_args: TokenStream, input: TokenStream) -> TokenStream {
     });
     let types = input.items.iter().filter_map(|item| {
         if let syn::TraitItem::Type(ty) = item {
+            if ignore(&ty.attrs) {
+                return None
+            }
             let ident = &ty.ident;
             let ident_str = ident.to_string();
             Some(quote! {
@@ -67,7 +111,9 @@ pub fn module(_args: TokenStream, input: TokenStream) -> TokenStream {
 
         const MODULE: &str = #module_name;
 
+        /// `EventsDecoder` extension trait.
         pub trait #module_events_decoder {
+            /// Registers this modules types.
             fn #with_module(&mut self) -> Result<(), #subxt::EventsError>;
         }
 
@@ -118,7 +164,9 @@ mod tests {
 
             const MODULE: &str = "Balances";
 
+            /// `EventsDecoder` extension trait.
             pub trait BalancesEventsDecoder {
+                /// Registers this modules types.
                 fn with_balances(&mut self) -> Result<(), substrate_subxt::EventsError>;
             }
 

proc-macro/src/store.rs

@@ -15,75 +15,63 @@
 // along with substrate-subxt.  If not, see <http://www.gnu.org/licenses/>.
 
 use crate::utils;
-use heck::SnakeCase;
-use proc_macro2::{
-    TokenStream,
-    TokenTree,
+use heck::{
+    CamelCase,
+    SnakeCase,
 };
+use proc_macro2::TokenStream;
 use quote::{
     format_ident,
     quote,
 };
-use syn::{
-    parse::{
-        Parse,
-        ParseStream,
-    },
-    Token,
+use syn::parse::{
+    Parse,
+    ParseStream,
 };
 use synstructure::Structure;
 
-struct Returns {
-    returns: syn::Ident,
-    _eq: Token![=],
-    ty: syn::Type,
+mod kw {
+    use syn::custom_keyword;
+
+    custom_keyword!(returns);
 }
 
-impl Parse for Returns {
+#[derive(Debug)]
+enum StoreAttr {
+    Returns(utils::Attr<kw::returns, syn::Type>),
+}
+
+impl Parse for StoreAttr {
     fn parse(input: ParseStream) -> syn::Result<Self> {
-        Ok(Returns {
-            returns: input.parse()?,
-            _eq: input.parse()?,
-            ty: input.parse()?,
-        })
+        Ok(Self::Returns(input.parse()?))
     }
 }
 
+type StoreAttrs = utils::Attrs<StoreAttr>;
+
 fn parse_returns_attr(attr: &syn::Attribute) -> Option<syn::Type> {
-    if let TokenTree::Group(group) = attr.tokens.clone().into_iter().next().unwrap() {
-        if let Ok(Returns { returns, ty, .. }) = syn::parse2(group.stream()) {
-            if returns.to_string() == "returns" {
-                return Some(ty)
-            }
-        }
-    }
-    None
+    let attrs: StoreAttrs = syn::parse2(attr.tokens.clone()).unwrap();
+    attrs.attrs.into_iter().next().map(|attr| {
+        let StoreAttr::Returns(attr) = attr;
+        attr.value
+    })
 }
 
 pub fn store(s: Structure) -> TokenStream {
     let subxt = utils::use_crate("substrate-subxt");
-    let sp_core = utils::use_crate("sp-core");
     let ident = &s.ast().ident;
     let generics = &s.ast().generics;
     let params = utils::type_params(generics);
     let module = utils::module_name(generics);
-    let store_name = ident.to_string().trim_end_matches("Store").to_string();
+    let store_name = utils::ident_to_name(ident, "Store").to_camel_case();
     let store = format_ident!("{}", store_name.to_snake_case());
     let store_trait = format_ident!("{}StoreExt", store_name);
     let bindings = utils::bindings(&s);
-    let fields = bindings
-        .iter()
-        .enumerate()
-        .map(|(i, bi)| {
-            (
-                bi.ast()
-                    .ident
-                    .clone()
-                    .unwrap_or_else(|| format_ident!("key{}", i)),
-                bi.ast().ty.clone(),
-            )
-        })
-        .collect::<Vec<_>>();
+    let fields = utils::fields(&bindings);
+    let marker = utils::marker_field(&fields).unwrap_or_else(|| format_ident!("_"));
+    let filtered_fields = utils::filter_fields(&fields, &marker);
+    let args = utils::fields_to_args(&filtered_fields);
+    let build_struct = utils::build_struct(ident, &fields);
     let ret = bindings
         .iter()
         .filter_map(|bi| bi.ast().attrs.iter().filter_map(parse_returns_attr).next())
@@ -91,19 +79,16 @@ pub fn store(s: Structure) -> TokenStream {
         .expect("#[store(returns = ..)] needs to be specified.");
     let store_ty = format_ident!(
         "{}",
-        match fields.len() {
+        match filtered_fields.len() {
             0 => "plain",
             1 => "map",
             2 => "double_map",
             _ => panic!("invalid number of arguments"),
         }
     );
-    let args = fields.iter().map(|(field, ty)| quote!(#field: #ty,));
-    let args = quote!(#(#args)*);
-    let keys = fields.iter().map(|(field, _)| quote!(&self.#field,));
-    let keys = quote!(#(#keys)*);
-    let fields = fields.iter().map(|(field, _)| quote!(#field,));
-    let fields = quote!(#(#fields)*);
+    let keys = filtered_fields
+        .iter()
+        .map(|(field, _)| quote!(&self.#field));
 
     quote! {
         impl#generics #subxt::Store<T> for #ident<#(#params),*> {
@@ -113,20 +98,22 @@ pub fn store(s: Structure) -> TokenStream {
             fn key(
                 &self,
                 metadata: &#subxt::Metadata,
-            ) -> Result<#sp_core::storage::StorageKey, #subxt::MetadataError> {
+            ) -> Result<#subxt::sp_core::storage::StorageKey, #subxt::MetadataError> {
                 Ok(metadata
                     .module(Self::MODULE)?
                     .storage(Self::FIELD)?
                     .#store_ty()?
-                    .key(#keys))
+                    .key(#(#keys,)*))
             }
         }
 
+        /// Store extension trait.
         pub trait #store_trait<T: #module> {
+            /// Retrive the store element.
             fn #store<'a>(
                 &'a self,
                 #args
-            ) -> core::pin::Pin<Box<dyn core::future::Future<Output = Result<Option<#ret>, #subxt::Error>> + Send + 'a>>;
+            ) -> core::pin::Pin<Box<dyn core::future::Future<Output = Result<#ret, #subxt::Error>> + Send + 'a>>;
         }
 
         impl<T, S, E> #store_trait<T> for #subxt::Client<T, S, E>
@@ -138,8 +125,9 @@ pub fn store(s: Structure) -> TokenStream {
             fn #store<'a>(
                 &'a self,
                 #args
-            ) -> core::pin::Pin<Box<dyn core::future::Future<Output = Result<Option<#ret>, #subxt::Error>> + Send + 'a>> {
-                Box::pin(self.fetch(#ident { #fields }, None))
+            ) -> core::pin::Pin<Box<dyn core::future::Future<Output = Result<#ret, #subxt::Error>> + Send + 'a>> {
+                let #marker = core::marker::PhantomData::<T>;
+                Box::pin(self.fetch(#build_struct, None))
             }
         }
     }
@@ -166,7 +154,7 @@ mod tests {
                 fn key(
                     &self,
                     metadata: &substrate_subxt::Metadata,
-                ) -> Result<sp_core::storage::StorageKey, substrate_subxt::MetadataError> {
+                ) -> Result<substrate_subxt::sp_core::storage::StorageKey, substrate_subxt::MetadataError> {
                     Ok(metadata
                         .module(Self::MODULE)?
                         .storage(Self::FIELD)?
@@ -175,11 +163,13 @@ mod tests {
                 }
             }
 
+            /// Store extension trait.
             pub trait AccountStoreExt<T: Balances> {
+                /// Retrive the store element.
                 fn account<'a>(
                     &'a self,
                     account_id: &'a <T as System>::AccountId,
-                ) -> core::pin::Pin<Box<dyn core::future::Future<Output = Result<Option<AccountData<T::Balance> >, substrate_subxt::Error>> + Send + 'a>>;
+                ) -> core::pin::Pin<Box<dyn core::future::Future<Output = Result<AccountData<T::Balance>, substrate_subxt::Error>> + Send + 'a>>;
             }
 
             impl<T, S, E> AccountStoreExt<T> for substrate_subxt::Client<T, S, E>
@@ -191,8 +181,9 @@ mod tests {
                 fn account<'a>(
                     &'a self,
                     account_id: &'a <T as System>::AccountId,
-                ) -> core::pin::Pin<Box<dyn core::future::Future<Output = Result<Option<AccountData<T::Balance> >, substrate_subxt::Error>> + Send + 'a>>
+                ) -> core::pin::Pin<Box<dyn core::future::Future<Output = Result<AccountData<T::Balance>, substrate_subxt::Error>> + Send + 'a>>
                 {
+                    let _ = core::marker::PhantomData::<T>;
                     Box::pin(self.fetch(AccountStore { account_id, }, None))
                 }
             }

proc-macro/src/test.rs

@@ -36,6 +36,7 @@ mod kw {
     custom_keyword!(account);
     custom_keyword!(signature);
     custom_keyword!(extra);
+    custom_keyword!(prelude);
     custom_keyword!(step);
     custom_keyword!(state);
     custom_keyword!(call);
@@ -86,6 +87,7 @@ enum TestItem {
     Signature(Item<kw::signature, syn::Type>),
     Extra(Item<kw::extra, syn::Type>),
     State(Item<kw::state, ItemState>),
+    Prelude(Item<kw::prelude, syn::Block>),
     Step(Item<kw::step, ItemStep>),
 }
 
@@ -103,6 +105,8 @@ impl Parse for TestItem {
             Ok(TestItem::Extra(input.parse()?))
         } else if input.peek(kw::state) {
             Ok(TestItem::State(input.parse()?))
+        } else if input.peek(kw::prelude) {
+            Ok(TestItem::Prelude(input.parse()?))
         } else {
             Ok(TestItem::Step(input.parse()?))
         }
@@ -116,7 +120,7 @@ enum StepItem {
     State(Item<kw::state, ItemState>),
     Call(Item<kw::call, syn::Expr>),
     Event(Item<kw::event, syn::Expr>),
-    Assert(Item<kw::assert, syn::Expr>),
+    Assert(Item<kw::assert, syn::Block>),
 }
 
 impl Parse for StepItem {
@@ -143,6 +147,7 @@ struct Test {
     signature: syn::Type,
     extra: syn::Type,
     state: Option<State>,
+    prelude: Option<syn::Block>,
     steps: Vec<Step>,
 }
 
@@ -154,6 +159,7 @@ impl From<ItemTest> for Test {
         let mut signature = None;
         let mut extra = None;
         let mut state = None;
+        let mut prelude = None;
         let mut steps = vec![];
         for test_item in test.items {
             match test_item {
@@ -175,28 +181,29 @@ impl From<ItemTest> for Test {
                 TestItem::State(item) => {
                     state = Some(item.value.into());
                 }
+                TestItem::Prelude(item) => {
+                    prelude = Some(item.value);
+                }
                 TestItem::Step(item) => {
                     steps.push(item.value.into());
                 }
             }
         }
-        let runtime = runtime.unwrap_or_else(|| {
-            let subxt = utils::use_crate("substrate-subxt");
-            syn::parse2(quote!(#subxt::DefaultNodeRuntime)).unwrap()
-        });
+        let subxt = utils::use_crate("substrate-subxt");
+        let runtime = runtime
+            .unwrap_or_else(|| syn::parse2(quote!(#subxt::DefaultNodeRuntime)).unwrap());
         Self {
             name: name.expect("No name specified"),
             account: account.unwrap_or_else(|| format_ident!("Alice")),
             signature: signature.unwrap_or_else(|| {
-                let sp_runtime = utils::use_crate("sp-runtime");
-                syn::parse2(quote!(#sp_runtime::MultiSignature)).unwrap()
+                syn::parse2(quote!(#subxt::sp_runtime::MultiSignature)).unwrap()
             }),
             extra: extra.unwrap_or_else(|| {
-                let subxt = utils::use_crate("substrate-subxt");
                 syn::parse2(quote!(#subxt::DefaultExtra<#runtime>)).unwrap()
             }),
             runtime,
             state,
+            prelude,
             steps,
         }
     }
@@ -204,9 +211,10 @@ impl From<ItemTest> for Test {
 
 impl Test {
     fn into_tokens(self) -> TokenStream {
-        let env_logger = utils::use_crate("env_logger");
-        let sp_keyring = utils::use_crate("sp-keyring");
         let subxt = utils::use_crate("substrate-subxt");
+        let sp_keyring = utils::use_crate("sp-keyring");
+        let env_logger = utils::opt_crate("env_logger")
+            .map(|env_logger| quote!(#env_logger::try_init().ok();));
         let Test {
             name,
             runtime,
@@ -214,8 +222,10 @@ impl Test {
             signature,
             extra,
             state,
+            prelude,
             steps,
         } = self;
+        let prelude = prelude.map(|block| block.stmts).unwrap_or_default();
         let step = steps
             .into_iter()
             .map(|step| step.into_tokens(&account, state.as_ref()));
@@ -223,7 +233,7 @@ impl Test {
             #[async_std::test]
             #[ignore]
             async fn #name() {
-                #env_logger::try_init().ok();
+                #env_logger
                 let client = #subxt::ClientBuilder::<#runtime, #signature, #extra>::new()
                     .build().await.unwrap();
                 #[allow(unused)]
@@ -239,6 +249,8 @@ impl Test {
                 #[allow(unused)]
                 let ferdie = #sp_keyring::AccountKeyring::Ferdie.to_account_id();
 
+                #(#prelude)*
+
                 #({
                     #step
                 })*
@@ -252,7 +264,7 @@ struct Step {
     call: syn::Expr,
     event_name: Vec<syn::Path>,
     event: Vec<syn::Expr>,
-    assert: syn::Expr,
+    assert: Option<syn::Block>,
 }
 
 impl From<ItemStep> for Step {
@@ -286,7 +298,7 @@ impl From<ItemStep> for Step {
             call: call.expect("Step requires a call."),
             event_name,
             event,
-            assert: assert.expect("Step requires assert."),
+            assert,
         }
     }
 }
@@ -305,27 +317,51 @@ impl Step {
             event,
             assert,
         } = self;
-        let state = state
+        let (pre, post) = state
             .as_ref()
-            .unwrap_or_else(|| test_state.expect("No state for step"));
-        let State {
-            state_name,
-            state,
-            state_param,
-        } = state;
+            .or(test_state)
+            .map(|state| {
+                let State {
+                    state_name,
+                    state,
+                    state_param,
+                } = state;
+                let state_struct = quote! {
+                    struct State<#(#state_param),*> {
+                        #(#state_name: #state_param,)*
+                    }
+                };
+                let build_struct = quote! {
+                    #(
+                        let #state_name = client.fetch(#state, None).await.unwrap();
+                    )*
+                    State { #(#state_name),* }
+                };
+                let pre = quote! {
+                    #state_struct
+                    let pre = {
+                        #build_struct
+                    };
+                };
+                let post = quote! {
+                    let post = {
+                        #build_struct
+                    };
+                };
+                (pre, post)
+            })
+            .unwrap_or_default();
+        let expect_event = event_name.iter().map(|event| {
+            format!(
+                "failed to find event {}",
+                utils::path_to_ident(event).to_string()
+            )
+        });
+        let assert = assert.map(|block| block.stmts).unwrap_or_default();
         quote! {
             let xt = client.xt(#sp_keyring::AccountKeyring::#account.pair(), None).await.unwrap();
 
-            struct State<#(#state_param),*> {
-                #(#state_name: #state_param,)*
-            }
-
-            let pre = {
-                #(
-                    let #state_name = client.fetch(#state, None).await.unwrap().unwrap();
-                )*
-                State { #(#state_name),* }
-            };
+            #pre
 
             #[allow(unused)]
             let result = xt
@@ -335,20 +371,13 @@ impl Step {
                 .unwrap();
 
             #(
-                assert_eq!(
-                    result.find_event::<#event_name<_>>().unwrap(),
-                    Some(#event)
-                );
+                let event = result.find_event::<#event_name<_>>().unwrap().expect(#expect_event);
+                assert_eq!(event, #event);
             )*
 
-            let post = {
-                #(
-                    let #state_name = client.fetch(#state, None).await.unwrap().unwrap();
-                )*
-                State { #(#state_name),* }
-            };
+            #post
 
-            #assert
+            #(#assert)*
         }
     }
 }
@@ -429,7 +458,7 @@ mod tests {
                 env_logger::try_init().ok();
                 let client = substrate_subxt::ClientBuilder::<
                     KusamaRuntime,
-                    sp_runtime::MultiSignature,
+                    substrate_subxt::sp_runtime::MultiSignature,
                     substrate_subxt::DefaultExtra<KusamaRuntime>
                 >::new().build().await.unwrap();
                 #[allow(unused)]
@@ -457,12 +486,10 @@ mod tests {
                         let alice = client
                             .fetch(AccountStore { account_id: &alice }, None)
                             .await
-                            .unwrap()
                             .unwrap();
                         let bob = client
                             .fetch(AccountStore { account_id: &bob }, None)
                             .await
-                            .unwrap()
                             .unwrap();
                         State { alice, bob }
                     };
@@ -477,33 +504,32 @@ mod tests {
                         .await
                         .unwrap();
 
+                    let event = result.find_event::<TransferEvent<_>>()
+                        .unwrap()
+                        .expect("failed to find event TransferEvent");
                     assert_eq!(
-                        result.find_event::<TransferEvent<_>>().unwrap(),
-                        Some(TransferEvent {
+                        event,
+                        TransferEvent {
                             from: alice.clone(),
                             to: bob.clone(),
                             amount: 10_000,
-                        })
+                        }
                     );
 
                     let post = {
                         let alice = client
                             .fetch(AccountStore { account_id: &alice }, None)
                             .await
-                            .unwrap()
                             .unwrap();
                         let bob = client
                             .fetch(AccountStore { account_id: &bob }, None)
                             .await
-                            .unwrap()
                             .unwrap();
                         State { alice, bob }
                     };
 
-                    {
-                        assert_eq!(pre.alice.free, post.alice.free - 10_000);
-                        assert_eq!(pre.bob.free, post.bob.free + 10_000);
-                    }
+                    assert_eq!(pre.alice.free, post.alice.free - 10_000);
+                    assert_eq!(pre.bob.free, post.bob.free + 10_000);
                 }
             }
         };

proc-macro/src/utils.rs

@@ -18,15 +18,30 @@ use proc_macro2::{
     Span,
     TokenStream,
 };
-use quote::quote;
+use quote::{
+    format_ident,
+    quote,
+};
+use syn::{
+    parse::{
+        Parse,
+        ParseStream,
+    },
+    punctuated::Punctuated,
+};
 use synstructure::{
     BindingInfo,
     Structure,
 };
 
 pub fn use_crate(name: &str) -> syn::Ident {
-    let krate = proc_macro_crate::crate_name(name).unwrap();
-    syn::Ident::new(&krate, Span::call_site())
+    opt_crate(name).unwrap_or_else(|| syn::Ident::new("crate", Span::call_site()))
+}
+
+pub fn opt_crate(name: &str) -> Option<syn::Ident> {
+    proc_macro_crate::crate_name(name)
+        .ok()
+        .map(|krate| syn::Ident::new(&krate, Span::call_site()))
 }
 
 pub fn bindings<'a>(s: &'a Structure) -> Vec<&'a BindingInfo<'a>> {
@@ -39,6 +54,71 @@ pub fn bindings<'a>(s: &'a Structure) -> Vec<&'a BindingInfo<'a>> {
     bindings
 }
 
+type Field = (syn::Ident, syn::Type);
+
+pub fn fields<'a>(bindings: &'a [&'a BindingInfo<'a>]) -> Vec<Field> {
+    bindings
+        .iter()
+        .enumerate()
+        .map(|(i, bi)| {
+            (
+                bi.ast()
+                    .ident
+                    .clone()
+                    .unwrap_or_else(|| format_ident!("key{}", i)),
+                bi.ast().ty.clone(),
+            )
+        })
+        .collect()
+}
+
+pub fn marker_field<'a>(fields: &'a [Field]) -> Option<syn::Ident> {
+    fields
+        .iter()
+        .filter_map(|(field, ty)| {
+            if quote!(#ty).to_string() == quote!(PhantomData<T>).to_string() {
+                Some(field)
+            } else {
+                None
+            }
+        })
+        .next()
+        .cloned()
+}
+
+pub fn filter_fields<'a>(fields: &'a [Field], field: &'a syn::Ident) -> Vec<Field> {
+    fields
+        .iter()
+        .filter_map(|(field2, ty)| {
+            if field2 != field {
+                Some((field2.clone(), ty.clone()))
+            } else {
+                None
+            }
+        })
+        .collect()
+}
+
+pub fn fields_to_args<'a>(fields: &'a [Field]) -> TokenStream {
+    let args = fields.iter().map(|(field, ty)| quote!(#field: #ty,));
+    quote!(#(#args)*)
+}
+
+pub fn build_struct<'a>(ident: &'a syn::Ident, fields: &'a [Field]) -> TokenStream {
+    let fields = fields.iter().map(|(field, _)| field);
+    quote!(#ident { #(#fields,)* })
+}
+
+pub fn ident_to_name(ident: &syn::Ident, ty: &str) -> String {
+    let name = ident.to_string();
+    let name = name.trim_end_matches(ty);
+    if name.is_empty() {
+        ty.to_string()
+    } else {
+        name.to_string()
+    }
+}
+
 pub fn module_name(generics: &syn::Generics) -> &syn::Path {
     generics
         .params
@@ -87,6 +167,39 @@ pub fn type_params(generics: &syn::Generics) -> Vec<TokenStream> {
         .collect()
 }
 
+#[derive(Debug)]
+pub struct Attrs<A> {
+    pub paren: syn::token::Paren,
+    pub attrs: Punctuated<A, syn::token::Comma>,
+}
+
+impl<A: Parse> Parse for Attrs<A> {
+    fn parse(input: ParseStream) -> syn::Result<Self> {
+        let content;
+        Ok(Self {
+            paren: syn::parenthesized!(content in input),
+            attrs: content.parse_terminated(A::parse)?,
+        })
+    }
+}
+
+#[derive(Debug)]
+pub struct Attr<K, V> {
+    pub key: K,
+    pub eq: syn::token::Eq,
+    pub value: V,
+}
+
+impl<K: Parse, V: Parse> Parse for Attr<K, V> {
+    fn parse(input: ParseStream) -> syn::Result<Self> {
+        Ok(Self {
+            key: input.parse()?,
+            eq: input.parse()?,
+            value: input.parse()?,
+        })
+    }
+}
+
 #[cfg(test)]
 pub(crate) fn assert_proc_macro(
     result: proc_macro2::TokenStream,