Double map and plain storage support, introduce macros (#93)

* Support custom clients.

* Simplify trait bounds.

* Plain and double map storage support.

* Simplify more trait bounds.

* Add proc macro.

* Add Call, Event and Store traits.

* Update proc-macros.

* Add with_system for proc-macro.

* proc-macro: test: support signature and extra fields.

* proc-macro: test: support sharing state accross steps.

* proc-macro: test: fetch state sequentially.

* Elide lifetimes.

* Add test for plain storage.

* Run rustfmt.

proc-macro/src/call.rs

@@ -0,0 +1,140 @@
+use crate::utils;
+use heck::{
+    CamelCase,
+    SnakeCase,
+};
+use proc_macro2::TokenStream;
+use quote::{
+    format_ident,
+    quote,
+};
+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);
+    let module = utils::module_name(generics);
+    let with_module = format_ident!(
+        "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 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 expanded = quote! {
+        impl#generics #subxt::Call<T> for #ident<#(#params),*> {
+            const MODULE: &'static str = MODULE;
+            const FUNCTION: &'static str = #call_name;
+            fn events_decoder(
+                decoder: &mut #subxt::EventsDecoder<T>,
+            ) -> Result<(), #subxt::EventsError> {
+                decoder.#with_module()?;
+                Ok(())
+            }
+        }
+
+        pub trait #call_trait<T: #module> {
+            fn #call<'a>(
+                self,
+                #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>
+        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::Address: From<T::AccountId>,
+            E: #subxt::SignedExtra<T> + #sp_runtime::traits::SignedExtension + 'static,
+        {
+            fn #call<'a>(
+                self,
+                #args
+            ) -> core::pin::Pin<Box<dyn core::future::Future<Output = Result<#ret, #subxt::Error>> + Send + 'a>> {
+                Box::pin(self.submit(#ident { #(#fields)* }))
+            }
+        }
+    };
+
+    TokenStream::from(expanded)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_transfer_call() {
+        let input = quote! {
+            #[derive(Call, Encode)]
+            pub struct TransferCall<'a, T: Balances> {
+                pub to: &'a <T as System>::Address,
+                #[codec(compact)]
+                pub amount: T::Balance,
+            }
+        };
+        let expected = quote! {
+            impl<'a, T: Balances> substrate_subxt::Call<T> for TransferCall<'a, T> {
+                const MODULE: &'static str = MODULE;
+                const FUNCTION: &'static str = "transfer";
+                fn events_decoder(
+                    decoder: &mut substrate_subxt::EventsDecoder<T>,
+                ) -> Result<(), substrate_subxt::EventsError> {
+                    decoder.with_balances()?;
+                    Ok(())
+                }
+            }
+
+            pub trait TransferCallExt<T: Balances> {
+                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>>;
+            }
+
+            impl<T, P, S, E> TransferCallExt<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<
+                    AccountId = T::AccountId>,
+                T::Address: From<T::AccountId>,
+                E: substrate_subxt::SignedExtra<T> + 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>> {
+                    Box::pin(self.submit(TransferCall { to, amount, }))
+                }
+            }
+        };
+        let derive_input = syn::parse2(input).unwrap();
+        let s = Structure::new(&derive_input);
+        let result = call(s);
+        utils::assert_proc_macro(result, expected);
+    }
+}

proc-macro/src/event.rs

@@ -0,0 +1,78 @@
+use crate::utils;
+use heck::{
+    CamelCase,
+    SnakeCase,
+};
+use proc_macro2::TokenStream;
+use quote::{
+    format_ident,
+    quote,
+};
+use synstructure::Structure;
+
+pub fn event(s: Structure) -> TokenStream {
+    let subxt = utils::use_crate("substrate-subxt");
+    let codec = utils::use_crate("parity-scale-codec");
+    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 = format_ident!("{}", event_name.to_snake_case());
+    let event_trait = format_ident!("{}EventExt", event_name);
+
+    let expanded = quote! {
+        impl<T: #module> #subxt::Event<T> for #ident<T> {
+            const MODULE: &'static str = MODULE;
+            const EVENT: &'static str = #event_name;
+        }
+
+        pub trait #event_trait<T: #module> {
+            fn #event(&self) -> Result<Option<#ident<T>>, #codec::Error>;
+        }
+
+        impl<T: #module> #event_trait<T> for #subxt::ExtrinsicSuccess<T> {
+            fn #event(&self) -> Result<Option<#ident<T>>, #codec::Error> {
+                self.find_event()
+            }
+        }
+    };
+
+    TokenStream::from(expanded)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_transfer_event() {
+        let input = quote! {
+            #[derive(Debug, Decode, Eq, Event, PartialEq)]
+            pub struct TransferEvent<T: Balances> {
+                pub from: <T as System>::AccountId,
+                pub to: <T as System>::AccountId,
+                pub amount: T::Balance,
+            }
+        };
+        let expected = quote! {
+            impl<T: Balances> substrate_subxt::Event<T> for TransferEvent<T> {
+                const MODULE: &'static str = MODULE;
+                const EVENT: &'static str = "Transfer";
+            }
+
+            pub trait TransferEventExt<T: Balances> {
+                fn transfer(&self) -> Result<Option<TransferEvent<T>>, codec::Error>;
+            }
+
+            impl<T: Balances> TransferEventExt<T> for substrate_subxt::ExtrinsicSuccess<T> {
+                fn transfer(&self) -> Result<Option<TransferEvent<T>>, codec::Error> {
+                    self.find_event()
+                }
+            }
+        };
+        let derive_input = syn::parse2(input).unwrap();
+        let s = Structure::new(&derive_input);
+        let result = event(s);
+        utils::assert_proc_macro(result, expected);
+    }
+}

proc-macro/src/lib.rs

@@ -0,0 +1,39 @@
+extern crate proc_macro;
+
+mod call;
+mod event;
+mod module;
+mod store;
+mod test;
+mod utils;
+
+use proc_macro::TokenStream;
+use synstructure::{
+    decl_derive,
+    Structure,
+};
+
+#[proc_macro_attribute]
+pub fn module(args: TokenStream, input: TokenStream) -> TokenStream {
+    module::module(args.into(), input.into()).into()
+}
+
+decl_derive!([Call] => call);
+fn call(s: Structure) -> TokenStream {
+    call::call(s).into()
+}
+
+decl_derive!([Event] => event);
+fn event(s: Structure) -> TokenStream {
+    event::event(s).into()
+}
+
+decl_derive!([Store, attributes(store)] => store);
+fn store(s: Structure) -> TokenStream {
+    store::store(s).into()
+}
+
+#[proc_macro]
+pub fn subxt_test(input: TokenStream) -> TokenStream {
+    test::test(input.into()).into()
+}

proc-macro/src/module.rs

@@ -0,0 +1,123 @@
+use crate::utils;
+use heck::SnakeCase;
+use proc_macro2::TokenStream;
+use quote::{
+    format_ident,
+    quote,
+};
+
+fn events_decoder_trait_name(module: &syn::Ident) -> syn::Ident {
+    format_ident!("{}EventsDecoder", module.to_string())
+}
+
+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();
+
+    let subxt = utils::use_crate("substrate-subxt");
+    let module = &input.ident;
+    let module_name = module.to_string();
+    let module_events_decoder = events_decoder_trait_name(module);
+    let with_module = with_module_ident(module);
+
+    let bounds = input.supertraits.iter().filter_map(|bound| {
+        if let syn::TypeParamBound::Trait(syn::TraitBound { path, .. }) = bound {
+            let module = utils::path_to_ident(path);
+            let with_module = with_module_ident(module);
+            Some(quote! {
+                self.#with_module()?;
+            })
+        } else {
+            None
+        }
+    });
+    let types = input.items.iter().filter_map(|item| {
+        if let syn::TraitItem::Type(ty) = item {
+            let ident = &ty.ident;
+            let ident_str = ident.to_string();
+            Some(quote! {
+                self.register_type_size::<T::#ident>(#ident_str)?;
+            })
+        } else {
+            None
+        }
+    });
+
+    quote! {
+        #input
+
+        const MODULE: &str = #module_name;
+
+        pub trait #module_events_decoder {
+            fn #with_module(&mut self) -> Result<(), #subxt::EventsError>;
+        }
+
+        impl<T: #module> #module_events_decoder for
+            #subxt::EventsDecoder<T>
+        {
+            fn #with_module(&mut self) -> Result<(), #subxt::EventsError> {
+                #(#bounds)*
+                #(#types)*
+                Ok(())
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_balance_module() {
+        let attr = quote!(#[module]);
+        let input = quote! {
+            pub trait Balances: System {
+                type Balance: frame_support::Parameter
+                    + sp_runtime::traits::Member
+                    + sp_runtime::traits::AtLeast32Bit
+                    + codec::Codec
+                    + Default
+                    + Copy
+                    + sp_runtime::traits::MaybeSerialize
+                    + std::fmt::Debug
+                    + From<<Self as System>::BlockNumber>;
+            }
+        };
+        let expected = quote! {
+            pub trait Balances: System {
+                type Balance: frame_support::Parameter
+                    + sp_runtime::traits::Member
+                    + sp_runtime::traits::AtLeast32Bit
+                    + codec::Codec
+                    + Default
+                    + Copy
+                    + sp_runtime::traits::MaybeSerialize
+                    + std::fmt::Debug
+                    + From< <Self as System>::BlockNumber>;
+            }
+
+            const MODULE: &str = "Balances";
+
+            pub trait BalancesEventsDecoder {
+                fn with_balances(&mut self) -> Result<(), substrate_subxt::EventsError>;
+            }
+
+            impl<T: Balances> BalancesEventsDecoder for
+                substrate_subxt::EventsDecoder<T>
+            {
+                fn with_balances(&mut self) -> Result<(), substrate_subxt::EventsError> {
+                    self.with_system()?;
+                    self.register_type_size::<T::Balance>("Balance")?;
+                    Ok(())
+                }
+            }
+        };
+
+        let result = module(attr, input);
+        utils::assert_proc_macro(result, expected);
+    }
+}

proc-macro/src/store.rs

@@ -0,0 +1,189 @@
+use crate::utils;
+use heck::SnakeCase;
+use proc_macro2::{
+    TokenStream,
+    TokenTree,
+};
+use quote::{
+    format_ident,
+    quote,
+};
+use syn::{
+    parse::{
+        Parse,
+        ParseStream,
+    },
+    Token,
+};
+use synstructure::Structure;
+
+struct Returns {
+    returns: syn::Ident,
+    _eq: Token![=],
+    ty: syn::Type,
+}
+
+impl Parse for Returns {
+    fn parse(input: ParseStream) -> syn::Result<Self> {
+        Ok(Returns {
+            returns: input.parse()?,
+            _eq: input.parse()?,
+            ty: input.parse()?,
+        })
+    }
+}
+
+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
+}
+
+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 = 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 ret = bindings
+        .iter()
+        .filter_map(|bi| bi.ast().attrs.iter().filter_map(parse_returns_attr).next())
+        .next()
+        .expect("#[store(returns = ..)] needs to be specified.");
+    let store_ty = format_ident!(
+        "{}",
+        match 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)*);
+
+    quote! {
+        impl#generics #subxt::Store<T> for #ident<#(#params),*> {
+            const MODULE: &'static str = MODULE;
+            const FIELD: &'static str = #store_name;
+            type Returns = #ret;
+            fn key(
+                &self,
+                metadata: &#subxt::Metadata,
+            ) -> Result<#sp_core::storage::StorageKey, #subxt::MetadataError> {
+                Ok(metadata
+                    .module(Self::MODULE)?
+                    .storage(Self::FIELD)?
+                    .#store_ty()?
+                    .key(#keys))
+            }
+        }
+
+        pub trait #store_trait<T: #module> {
+            fn #store<'a>(
+                &'a self,
+                #args
+            ) -> core::pin::Pin<Box<dyn core::future::Future<Output = Result<Option<#ret>, #subxt::Error>> + Send + 'a>>;
+        }
+
+        impl<T, S, E> #store_trait<T> for #subxt::Client<T, S, E>
+        where
+            T: #module + Send + Sync,
+            S: 'static,
+            E: Send + Sync + 'static,
+        {
+            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))
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_account_store() {
+        let input = quote! {
+            #[derive(Encode, Store)]
+            pub struct AccountStore<'a, T: Balances> {
+                #[store(returns = AccountData<T::Balance>)]
+                account_id: &'a <T as System>::AccountId,
+            }
+        };
+        let expected = quote! {
+            impl<'a, T: Balances> substrate_subxt::Store<T> for AccountStore<'a, T> {
+                const MODULE: &'static str = MODULE;
+                const FIELD: &'static str = "Account";
+                type Returns = AccountData<T::Balance>;
+                fn key(
+                    &self,
+                    metadata: &substrate_subxt::Metadata,
+                ) -> Result<sp_core::storage::StorageKey, substrate_subxt::MetadataError> {
+                    Ok(metadata
+                        .module(Self::MODULE)?
+                        .storage(Self::FIELD)?
+                        .map()?
+                        .key(&self.account_id,))
+                }
+            }
+
+            pub trait AccountStoreExt<T: Balances> {
+                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>>;
+            }
+
+            impl<T, S, E> AccountStoreExt<T> for substrate_subxt::Client<T, S, E>
+            where
+                T: Balances + Send + Sync,
+                S: 'static,
+                E: Send + Sync + 'static,
+            {
+                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>>
+                {
+                    Box::pin(self.fetch(AccountStore { account_id, }, None))
+                }
+            }
+        };
+        let derive_input = syn::parse2(input).unwrap();
+        let s = Structure::new(&derive_input);
+        let result = store(s);
+        utils::assert_proc_macro(result, expected);
+    }
+}

proc-macro/src/test.rs

@@ -0,0 +1,497 @@
+use crate::utils;
+use proc_macro2::TokenStream;
+use quote::{
+    format_ident,
+    quote,
+};
+use syn::{
+    parse::{
+        Parse,
+        ParseStream,
+    },
+    punctuated::Punctuated,
+};
+
+mod kw {
+    use syn::custom_keyword;
+
+    custom_keyword!(name);
+    custom_keyword!(runtime);
+    custom_keyword!(account);
+    custom_keyword!(signature);
+    custom_keyword!(extra);
+    custom_keyword!(step);
+    custom_keyword!(state);
+    custom_keyword!(call);
+    custom_keyword!(event);
+    custom_keyword!(assert);
+}
+
+#[derive(Debug)]
+struct Item<K, V> {
+    key: K,
+    colon: syn::token::Colon,
+    value: V,
+}
+
+impl<K: Parse, V: Parse> Parse for Item<K, V> {
+    fn parse(input: ParseStream) -> syn::Result<Self> {
+        Ok(Self {
+            key: input.parse()?,
+            colon: input.parse()?,
+            value: input.parse()?,
+        })
+    }
+}
+
+#[derive(Debug)]
+struct Items<I> {
+    brace: syn::token::Brace,
+    items: Punctuated<I, syn::token::Comma>,
+}
+
+impl<I: Parse> Parse for Items<I> {
+    fn parse(input: ParseStream) -> syn::Result<Self> {
+        let content;
+        Ok(Self {
+            brace: syn::braced!(content in input),
+            items: content.parse_terminated(I::parse)?,
+        })
+    }
+}
+
+type ItemTest = Items<TestItem>;
+
+#[derive(Debug)]
+enum TestItem {
+    Name(Item<kw::name, syn::Ident>),
+    Runtime(Item<kw::runtime, syn::Type>),
+    Account(Item<kw::account, syn::Ident>),
+    Signature(Item<kw::signature, syn::Type>),
+    Extra(Item<kw::extra, syn::Type>),
+    State(Item<kw::state, ItemState>),
+    Step(Item<kw::step, ItemStep>),
+}
+
+impl Parse for TestItem {
+    fn parse(input: ParseStream) -> syn::Result<Self> {
+        if input.peek(kw::name) {
+            Ok(TestItem::Name(input.parse()?))
+        } else if input.peek(kw::runtime) {
+            Ok(TestItem::Runtime(input.parse()?))
+        } else if input.peek(kw::account) {
+            Ok(TestItem::Account(input.parse()?))
+        } else if input.peek(kw::signature) {
+            Ok(TestItem::Signature(input.parse()?))
+        } else if input.peek(kw::extra) {
+            Ok(TestItem::Extra(input.parse()?))
+        } else if input.peek(kw::state) {
+            Ok(TestItem::State(input.parse()?))
+        } else {
+            Ok(TestItem::Step(input.parse()?))
+        }
+    }
+}
+
+type ItemStep = Items<StepItem>;
+
+#[derive(Debug)]
+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>),
+}
+
+impl Parse for StepItem {
+    fn parse(input: ParseStream) -> syn::Result<Self> {
+        if input.peek(kw::state) {
+            Ok(StepItem::State(input.parse()?))
+        } else if input.peek(kw::call) {
+            Ok(StepItem::Call(input.parse()?))
+        } else if input.peek(kw::event) {
+            Ok(StepItem::Event(input.parse()?))
+        } else {
+            Ok(StepItem::Assert(input.parse()?))
+        }
+    }
+}
+
+type ItemState = Items<StateItem>;
+type StateItem = Item<syn::Ident, syn::Expr>;
+
+struct Test {
+    name: syn::Ident,
+    runtime: syn::Type,
+    account: syn::Ident,
+    signature: syn::Type,
+    extra: syn::Type,
+    state: Option<State>,
+    steps: Vec<Step>,
+}
+
+impl From<ItemTest> for Test {
+    fn from(test: ItemTest) -> Self {
+        let mut name = None;
+        let mut runtime = None;
+        let mut account = None;
+        let mut signature = None;
+        let mut extra = None;
+        let mut state = None;
+        let mut steps = vec![];
+        for test_item in test.items {
+            match test_item {
+                TestItem::Name(item) => {
+                    name = Some(item.value);
+                }
+                TestItem::Runtime(item) => {
+                    runtime = Some(item.value);
+                }
+                TestItem::Account(item) => {
+                    account = Some(item.value);
+                }
+                TestItem::Signature(item) => {
+                    signature = Some(item.value);
+                }
+                TestItem::Extra(item) => {
+                    extra = Some(item.value);
+                }
+                TestItem::State(item) => {
+                    state = Some(item.value.into());
+                }
+                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()
+        });
+        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()
+            }),
+            extra: extra.unwrap_or_else(|| {
+                let subxt = utils::use_crate("substrate-subxt");
+                syn::parse2(quote!(#subxt::DefaultExtra<#runtime>)).unwrap()
+            }),
+            runtime,
+            state,
+            steps,
+        }
+    }
+}
+
+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 Test {
+            name,
+            runtime,
+            account,
+            signature,
+            extra,
+            state,
+            steps,
+        } = self;
+        let step = steps
+            .into_iter()
+            .map(|step| step.into_tokens(&account, state.as_ref()));
+        quote! {
+            #[async_std::test]
+            #[ignore]
+            async fn #name() {
+                #env_logger::try_init().ok();
+                let client = #subxt::ClientBuilder::<#runtime, #signature, #extra>::new()
+                    .build().await.unwrap();
+                #[allow(unused)]
+                let alice = #sp_keyring::AccountKeyring::Alice.to_account_id();
+                #[allow(unused)]
+                let bob = #sp_keyring::AccountKeyring::Bob.to_account_id();
+                #[allow(unused)]
+                let charlie = #sp_keyring::AccountKeyring::Charlie.to_account_id();
+                #[allow(unused)]
+                let dave = #sp_keyring::AccountKeyring::Dave.to_account_id();
+                #[allow(unused)]
+                let eve = #sp_keyring::AccountKeyring::Eve.to_account_id();
+                #[allow(unused)]
+                let ferdie = #sp_keyring::AccountKeyring::Ferdie.to_account_id();
+
+                #({
+                    #step
+                })*
+            }
+        }
+    }
+}
+
+struct Step {
+    state: Option<State>,
+    call: syn::Expr,
+    event_name: Vec<syn::Path>,
+    event: Vec<syn::Expr>,
+    assert: syn::Expr,
+}
+
+impl From<ItemStep> for Step {
+    fn from(step: ItemStep) -> Self {
+        let mut state = None;
+        let mut call = None;
+        let mut event_name = vec![];
+        let mut event = vec![];
+        let mut assert = None;
+
+        for step_item in step.items {
+            match step_item {
+                StepItem::State(item) => {
+                    state = Some(item.value.into());
+                }
+                StepItem::Call(item) => {
+                    call = Some(item.value);
+                }
+                StepItem::Event(item) => {
+                    event_name.push(struct_name(&item.value));
+                    event.push(item.value);
+                }
+                StepItem::Assert(item) => {
+                    assert = Some(item.value);
+                }
+            }
+        }
+
+        Self {
+            state,
+            call: call.expect("Step requires a call."),
+            event_name,
+            event,
+            assert: assert.expect("Step requires assert."),
+        }
+    }
+}
+
+impl Step {
+    fn into_tokens(
+        self,
+        account: &syn::Ident,
+        test_state: Option<&State>,
+    ) -> TokenStream {
+        let sp_keyring = utils::use_crate("sp-keyring");
+        let Step {
+            state,
+            call,
+            event_name,
+            event,
+            assert,
+        } = self;
+        let state = state
+            .as_ref()
+            .unwrap_or_else(|| test_state.expect("No state for step"));
+        let State {
+            state_name,
+            state,
+            state_param,
+        } = state;
+        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),* }
+            };
+
+            #[allow(unused)]
+            let result = xt
+                .watch()
+                .submit(#call)
+                .await
+                .unwrap();
+
+            #(
+                assert_eq!(
+                    result.find_event::<#event_name<_>>().unwrap(),
+                    Some(#event)
+                );
+            )*
+
+            let post = {
+                #(
+                    let #state_name = client.fetch(#state, None).await.unwrap().unwrap();
+                )*
+                State { #(#state_name),* }
+            };
+
+            #assert
+        }
+    }
+}
+
+struct State {
+    state_name: Vec<syn::Ident>,
+    state: Vec<syn::Expr>,
+    state_param: Vec<syn::Ident>,
+}
+
+impl From<ItemState> for State {
+    fn from(item_state: ItemState) -> Self {
+        let mut state_name = vec![];
+        let mut state = vec![];
+        for item in item_state.items {
+            state_name.push(item.key);
+            state.push(item.value);
+        }
+        let state_param = (b'A'..b'Z')
+            .map(|c| format_ident!("{}", (c as char).to_string()))
+            .take(state_name.len())
+            .collect::<Vec<_>>();
+        Self {
+            state_name,
+            state,
+            state_param,
+        }
+    }
+}
+
+fn struct_name(expr: &syn::Expr) -> syn::Path {
+    if let syn::Expr::Struct(syn::ExprStruct { path, .. }) = expr {
+        return path.clone()
+    } else {
+        panic!("not a struct");
+    }
+}
+
+pub fn test(input: TokenStream) -> TokenStream {
+    let item_test: ItemTest = syn::parse2(input).unwrap();
+    Test::from(item_test).into_tokens()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn transfer_test_case() {
+        let input = quote! {{
+            name: test_transfer_balance,
+            runtime: KusamaRuntime,
+            account: Alice,
+            step: {
+                state: {
+                    alice: AccountStore { account_id: &alice },
+                    bob: AccountStore { account_id: &bob },
+                },
+                call: TransferCall {
+                    to: &bob,
+                    amount: 10_000,
+                },
+                event: TransferEvent {
+                    from: alice.clone(),
+                    to: bob.clone(),
+                    amount: 10_000,
+                },
+                assert: {
+                    assert_eq!(pre.alice.free, post.alice.free - 10_000);
+                    assert_eq!(pre.bob.free, post.bob.free + 10_000);
+                },
+            },
+        }};
+        let expected = quote! {
+            #[async_std::test]
+            #[ignore]
+            async fn test_transfer_balance() {
+                env_logger::try_init().ok();
+                let client = substrate_subxt::ClientBuilder::<
+                    KusamaRuntime,
+                    sp_runtime::MultiSignature,
+                    substrate_subxt::DefaultExtra<KusamaRuntime>
+                >::new().build().await.unwrap();
+                #[allow(unused)]
+                let alice = sp_keyring::AccountKeyring::Alice.to_account_id();
+                #[allow(unused)]
+                let bob = sp_keyring::AccountKeyring::Bob.to_account_id();
+                #[allow(unused)]
+                let charlie = sp_keyring::AccountKeyring::Charlie.to_account_id();
+                #[allow(unused)]
+                let dave = sp_keyring::AccountKeyring::Dave.to_account_id();
+                #[allow(unused)]
+                let eve = sp_keyring::AccountKeyring::Eve.to_account_id();
+                #[allow(unused)]
+                let ferdie = sp_keyring::AccountKeyring::Ferdie.to_account_id();
+
+                {
+                    let xt = client.xt(sp_keyring::AccountKeyring::Alice.pair(), None).await.unwrap();
+
+                    struct State<A, B> {
+                        alice: A,
+                        bob: B,
+                    }
+
+                    let pre = {
+                        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 }
+                    };
+
+                    #[allow(unused)]
+                    let result = xt
+                        .watch()
+                        .submit(TransferCall {
+                            to: &bob,
+                            amount: 10_000,
+                        })
+                        .await
+                        .unwrap();
+
+                    assert_eq!(
+                        result.find_event::<TransferEvent<_>>().unwrap(),
+                        Some(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);
+                    }
+                }
+            }
+        };
+        let result = test(input);
+        utils::assert_proc_macro(result, expected);
+    }
+}

proc-macro/src/utils.rs

@@ -0,0 +1,82 @@
+use proc_macro2::{
+    Span,
+    TokenStream,
+};
+use quote::quote;
+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())
+}
+
+pub fn bindings<'a>(s: &'a Structure) -> Vec<&'a BindingInfo<'a>> {
+    let mut bindings = vec![];
+    for variant in s.variants() {
+        for binding in variant.bindings() {
+            bindings.push(binding);
+        }
+    }
+    bindings
+}
+
+pub fn module_name(generics: &syn::Generics) -> &syn::Path {
+    generics
+        .params
+        .iter()
+        .filter_map(|p| {
+            if let syn::GenericParam::Type(p) = p {
+                p.bounds
+                    .iter()
+                    .filter_map(|b| {
+                        if let syn::TypeParamBound::Trait(t) = b {
+                            Some(&t.path)
+                        } else {
+                            None
+                        }
+                    })
+                    .next()
+            } else {
+                None
+            }
+        })
+        .next()
+        .unwrap()
+}
+
+pub fn path_to_ident(path: &syn::Path) -> &syn::Ident {
+    &path.segments.iter().last().unwrap().ident
+}
+
+pub fn type_params(generics: &syn::Generics) -> Vec<TokenStream> {
+    generics
+        .params
+        .iter()
+        .filter_map(|g| {
+            match g {
+                syn::GenericParam::Type(p) => {
+                    let ident = &p.ident;
+                    Some(quote!(#ident))
+                }
+                syn::GenericParam::Lifetime(p) => {
+                    let lifetime = &p.lifetime;
+                    Some(quote!(#lifetime))
+                }
+                syn::GenericParam::Const(_) => None,
+            }
+        })
+        .collect()
+}
+
+#[cfg(test)]
+pub(crate) fn assert_proc_macro(
+    result: proc_macro2::TokenStream,
+    expected: proc_macro2::TokenStream,
+) {
+    let result = result.to_string();
+    let expected = expected.to_string();
+    pretty_assertions::assert_eq!(result, expected);
+}