break sp-api dependency cycle (#4352)

* move benches into tests, ignore non-passing doctests

* Rename sr-api folder

* Move test-primitives to primitives, use that for sp-api doctests

substrate/primitives/api/proc-macro/src/decl_runtime_apis.rs

@@ -0,0 +1,943 @@
+// Copyright 2018-2019 Parity Technologies (UK) Ltd.
+// This file is part of Substrate.
+
+// Substrate is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Substrate is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Substrate.  If not, see <http://www.gnu.org/licenses/>.
+
+use crate::utils::{
+	generate_crate_access, generate_hidden_includes, generate_runtime_mod_name_for_trait,
+	fold_fn_decl_for_client_side, unwrap_or_error, extract_parameter_names_types_and_borrows,
+	generate_native_call_generator_fn_name, return_type_extract_type,
+	generate_method_runtime_api_impl_name, generate_call_api_at_fn_name, prefix_function_with_trait,
+	replace_wild_card_parameter_names,
+};
+
+use proc_macro2::{TokenStream, Span};
+
+use quote::quote;
+
+use syn::{
+	spanned::Spanned, parse_macro_input, parse::{Parse, ParseStream, Result, Error}, ReturnType,
+	fold::{self, Fold}, parse_quote, ItemTrait, Generics, GenericParam, Attribute, FnArg, Type,
+	visit::{Visit, self}, TraitBound, Meta, NestedMeta, Lit, TraitItem, Ident, TraitItemMethod,
+};
+
+use std::collections::HashMap;
+
+use blake2_rfc;
+
+/// The ident used for the block generic parameter.
+const BLOCK_GENERIC_IDENT: &str = "Block";
+
+/// Unique identifier used to make the hidden includes unique for this macro.
+const HIDDEN_INCLUDES_ID: &str = "DECL_RUNTIME_APIS";
+
+/// The `core_trait` attribute.
+const CORE_TRAIT_ATTRIBUTE: &str = "core_trait";
+/// The `api_version` attribute.
+///
+/// Is used to set the current version of the trait.
+const API_VERSION_ATTRIBUTE: &str = "api_version";
+/// The `changed_in` attribute.
+///
+/// Is used when the function signature changed between different versions of a trait.
+/// This attribute should be placed on the old signature of the function.
+const CHANGED_IN_ATTRIBUTE: &str = "changed_in";
+/// The `renamed` attribute.
+///
+/// Is used when a trait method was renamed.
+const RENAMED_ATTRIBUTE: &str = "renamed";
+/// The `skip_initialize_block` attribute.
+///
+/// Is used when a trait method does not require that the block is initialized
+/// before being called.
+const SKIP_INITIALIZE_BLOCK_ATTRIBUTE: &str = "skip_initialize_block";
+/// The `initialize_block` attribute.
+///
+/// A trait method tagged with this attribute, initializes the runtime at
+/// certain block.
+const INITIALIZE_BLOCK_ATTRIBUTE: &str = "initialize_block";
+/// All attributes that we support in the declaration of a runtime api trait.
+const SUPPORTED_ATTRIBUTE_NAMES: &[&str] = &[
+	CORE_TRAIT_ATTRIBUTE, API_VERSION_ATTRIBUTE, CHANGED_IN_ATTRIBUTE,
+	RENAMED_ATTRIBUTE, SKIP_INITIALIZE_BLOCK_ATTRIBUTE,
+	INITIALIZE_BLOCK_ATTRIBUTE,
+];
+
+/// The structure used for parsing the runtime api declarations.
+struct RuntimeApiDecls {
+	decls: Vec<ItemTrait>,
+}
+
+impl Parse for RuntimeApiDecls {
+	fn parse(input: ParseStream) -> Result<Self> {
+		let mut decls = Vec::new();
+
+		while !input.is_empty() {
+			decls.push(ItemTrait::parse(input)?);
+		}
+
+		Ok(Self { decls })
+	}
+}
+
+/// Extend the given generics with `Block: BlockT` as first generic parameter.
+fn extend_generics_with_block(generics: &mut Generics) {
+	let c = generate_crate_access(HIDDEN_INCLUDES_ID);
+
+	generics.lt_token = Some(Default::default());
+	generics.params.insert(0, parse_quote!( Block: #c::BlockT ));
+	generics.gt_token = Some(Default::default());
+}
+
+/// Remove all attributes from the vector that are supported by us in the declaration of a runtime
+/// api trait. The returned hashmap contains all found attribute names as keys and the rest of the
+/// attribute body as `TokenStream`.
+fn remove_supported_attributes(attrs: &mut Vec<Attribute>) -> HashMap<&'static str, Attribute> {
+	let mut result = HashMap::new();
+	attrs.retain(|v| {
+		match SUPPORTED_ATTRIBUTE_NAMES.iter().find(|a| v.path.is_ident(a)) {
+			Some(attribute) => {
+				result.insert(*attribute, v.clone());
+				false
+			},
+			None => true,
+		}
+	});
+
+	result
+}
+
+/// Visits the ast and checks if `Block` ident is used somewhere.
+struct IsUsingBlock {
+	result: bool,
+}
+
+impl<'ast> Visit<'ast> for IsUsingBlock {
+	fn visit_ident(&mut self, i: &'ast Ident) {
+		if i == BLOCK_GENERIC_IDENT {
+			self.result = true;
+		}
+	}
+}
+
+/// Visits the ast and checks if `Block` ident is used somewhere.
+fn type_is_using_block(ty: &Type) -> bool {
+	let mut visitor = IsUsingBlock { result: false };
+	visitor.visit_type(ty);
+	visitor.result
+}
+
+/// Visits the ast and checks if `Block` ident is used somewhere.
+fn return_type_is_using_block(ty: &ReturnType) -> bool {
+	let mut visitor = IsUsingBlock { result: false };
+	visitor.visit_return_type(ty);
+	visitor.result
+}
+
+/// Replace all occurrences of `Block` with `NodeBlock`
+struct ReplaceBlockWithNodeBlock {}
+
+impl Fold for ReplaceBlockWithNodeBlock {
+	fn fold_ident(&mut self, input: Ident) -> Ident {
+		if input == BLOCK_GENERIC_IDENT {
+			Ident::new("NodeBlock", Span::call_site())
+		} else {
+			input
+		}
+	}
+}
+
+/// Replace all occurrences of `Block` with `NodeBlock`
+fn fn_arg_replace_block_with_node_block(fn_arg: FnArg) -> FnArg {
+	let mut replace = ReplaceBlockWithNodeBlock {};
+	fold::fold_fn_arg(&mut replace, fn_arg)
+}
+
+/// Replace all occurrences of `Block` with `NodeBlock`
+fn return_type_replace_block_with_node_block(return_type: ReturnType) -> ReturnType {
+	let mut replace = ReplaceBlockWithNodeBlock {};
+	fold::fold_return_type(&mut replace, return_type)
+}
+
+/// Generate the functions that generate the native call closure for each trait method.
+fn generate_native_call_generators(decl: &ItemTrait) -> Result<TokenStream> {
+	let fns = decl.items.iter().filter_map(|i| match i {
+		TraitItem::Method(ref m) => Some(&m.sig),
+		_ => None,
+	});
+
+	let mut result = Vec::new();
+	let trait_ = &decl.ident;
+	let crate_ = generate_crate_access(HIDDEN_INCLUDES_ID);
+
+	// Auxiliary function that is used to convert between types that use different block types.
+	// The function expects that both are convertible by encoding the one and decoding the other.
+	result.push(quote!(
+		#[cfg(any(feature = "std", test))]
+		fn convert_between_block_types
+			<I: #crate_::Encode, R: #crate_::Decode>(
+				input: &I, error_desc: &'static str,
+			) -> std::result::Result<R, String>
+		{
+			<R as #crate_::Decode>::decode(
+				&mut &#crate_::Encode::encode(input)[..],
+			).map_err(|e| format!("{} {}", error_desc, e.what()))
+		}
+	));
+
+	// Generate a native call generator for each function of the given trait.
+	for fn_ in fns {
+		let params = extract_parameter_names_types_and_borrows(&fn_)?;
+		let trait_fn_name = &fn_.ident;
+		let fn_name = generate_native_call_generator_fn_name(&fn_.ident);
+		let output = return_type_replace_block_with_node_block(fn_.output.clone());
+		let output_ty = return_type_extract_type(&output);
+		let output = quote!( std::result::Result<#output_ty, String> );
+
+		// Every type that is using the `Block` generic parameter, we need to encode/decode,
+		// to make it compatible between the runtime/node.
+		let conversions = params.iter().filter(|v| type_is_using_block(&v.1)).map(|(n, t, _)| {
+			let name_str = format!(
+				"Could not convert parameter `{}` between node and runtime:", quote!(#n)
+			);
+			quote!(
+				let #n: #t = convert_between_block_types(&#n, #name_str)?;
+			)
+		});
+		// Same as for the input types, we need to check if we also need to convert the output,
+		// before returning it.
+		let output_conversion = if return_type_is_using_block(&fn_.output) {
+			quote!(
+				convert_between_block_types(
+					&res,
+					"Could not convert return value from runtime to node!"
+				)
+			)
+		} else {
+			quote!( Ok(res) )
+		};
+
+		let input_names = params.iter().map(|v| &v.0);
+		// If the type is using the block generic type, we will encode/decode it to make it
+		// compatible. To ensure that we forward it by ref/value, we use the value given by the
+		// the user. Otherwise if it is not using the block, we don't need to add anything.
+		let input_borrows = params
+			.iter()
+			.map(|v| if type_is_using_block(&v.1) { v.2.clone() } else { None });
+
+		// Replace all `Block` with `NodeBlock`, add `'a` lifetime to references and collect
+		// all the function inputs.
+		let fn_inputs = fn_
+			.inputs
+			.iter()
+			.map(|v| fn_arg_replace_block_with_node_block(v.clone()))
+			.map(|v| match v {
+				FnArg::Typed(ref arg) => {
+					let mut arg = arg.clone();
+					if let Type::Reference(ref mut r) = *arg.ty {
+						r.lifetime = Some(parse_quote!( 'a ));
+					}
+					FnArg::Typed(arg)
+				},
+				r => r.clone(),
+			});
+
+		let (impl_generics, ty_generics, where_clause) = decl.generics.split_for_impl();
+		// We need to parse them again, to get an easy access to the actual parameters.
+		let impl_generics: Generics = parse_quote!( #impl_generics );
+		let impl_generics_params = impl_generics.params.iter().map(|p| {
+			match p {
+				GenericParam::Type(ref ty) => {
+					let mut ty = ty.clone();
+					ty.bounds.push(parse_quote!( 'a ));
+					GenericParam::Type(ty)
+				},
+				// We should not see anything different than type params here.
+				r => r.clone(),
+			}
+		});
+
+		// Generate the generator function
+		result.push(quote!(
+			#[cfg(any(feature = "std", test))]
+			pub fn #fn_name<
+				'a, ApiImpl: #trait_ #ty_generics, NodeBlock: #crate_::BlockT
+				#(, #impl_generics_params)*
+			>(
+				#( #fn_inputs ),*
+			) -> impl FnOnce() -> #output + 'a #where_clause {
+				move || {
+					#( #conversions )*
+					let res = ApiImpl::#trait_fn_name(#( #input_borrows #input_names ),*);
+					#output_conversion
+				}
+			}
+		));
+	}
+
+	Ok(quote!( #( #result )* ))
+}
+
+/// Try to parse the given `Attribute` as `renamed` attribute.
+fn parse_renamed_attribute(renamed: &Attribute) -> Result<(String, u32)> {
+	let meta = renamed.parse_meta()?;
+
+	let err = Err(Error::new(
+			meta.span(),
+			&format!(
+				"Unexpected `{renamed}` attribute. The supported format is `{renamed}(\"old_name\", version_it_was_renamed)`",
+				renamed = RENAMED_ATTRIBUTE,
+			)
+		)
+	);
+
+	match meta {
+		Meta::List(list) => {
+			if list.nested.len() > 2 && list.nested.is_empty() {
+				err
+			} else {
+				let mut itr = list.nested.iter();
+				let old_name = match itr.next() {
+					Some(NestedMeta::Lit(Lit::Str(i))) => {
+						i.value()
+					},
+					_ => return err,
+				};
+
+				let version = match itr.next() {
+					Some(NestedMeta::Lit(Lit::Int(i))) => {
+						i.base10_parse()?
+					},
+					_ => return err,
+				};
+
+				Ok((old_name, version))
+			}
+		},
+		_ => err,
+	}
+}
+
+/// Generate the functions that call the api at a given block for a given trait method.
+fn generate_call_api_at_calls(decl: &ItemTrait) -> Result<TokenStream> {
+	let fns = decl.items.iter().filter_map(|i| match i {
+		TraitItem::Method(ref m) => Some((&m.attrs, &m.sig)),
+		_ => None,
+	});
+
+	let mut result = Vec::new();
+	let crate_ = generate_crate_access(HIDDEN_INCLUDES_ID);
+
+	// Generate a native call generator for each function of the given trait.
+	for (attrs, fn_) in fns {
+		let trait_name = &decl.ident;
+		let trait_fn_name = prefix_function_with_trait(&trait_name, &fn_.ident);
+		let fn_name = generate_call_api_at_fn_name(&fn_.ident);
+
+		let attrs = remove_supported_attributes(&mut attrs.clone());
+
+		if attrs.contains_key(RENAMED_ATTRIBUTE) && attrs.contains_key(CHANGED_IN_ATTRIBUTE) {
+			return Err(Error::new(
+				fn_.span(),
+				format!(
+					"`{}` and `{}` are not supported at once.",
+					RENAMED_ATTRIBUTE,
+					CHANGED_IN_ATTRIBUTE
+				)
+			));
+		}
+
+		// We do not need to generate this function for a method that signature was changed.
+		if attrs.contains_key(CHANGED_IN_ATTRIBUTE) {
+			continue;
+		}
+
+		let skip_initialize_block = attrs.contains_key(SKIP_INITIALIZE_BLOCK_ATTRIBUTE);
+		let update_initialized_block = if attrs.contains_key(INITIALIZE_BLOCK_ATTRIBUTE) {
+			quote!(
+				|| *initialized_block.borrow_mut() = Some(*at)
+			)
+		} else {
+			quote!(|| ())
+		};
+
+		// Parse the renamed attributes.
+		let mut renames = Vec::new();
+		if let Some((_, a)) = attrs
+			.iter()
+			.find(|a| a.0 == &RENAMED_ATTRIBUTE)
+		{
+			let (old_name, version) = parse_renamed_attribute(a)?;
+			renames.push((version, prefix_function_with_trait(&trait_name, &old_name)));
+		}
+
+		renames.sort_unstable_by(|l, r| r.cmp(l));
+		let (versions, old_names) = renames.into_iter().fold(
+			(Vec::new(), Vec::new()),
+			|(mut versions, mut old_names), (version, old_name)| {
+				versions.push(version);
+				old_names.push(old_name);
+				(versions, old_names)
+			}
+		);
+
+		// Generate the generator function
+		result.push(quote!(
+			#[cfg(any(feature = "std", test))]
+			pub fn #fn_name<
+				R: #crate_::Encode + #crate_::Decode + PartialEq,
+				NC: FnOnce() -> std::result::Result<R, String> + std::panic::UnwindSafe,
+				Block: #crate_::BlockT,
+				T: #crate_::CallRuntimeAt<Block>,
+				C: #crate_::Core<Block, Error = T::Error>,
+			>(
+				call_runtime_at: &T,
+				core_api: &C,
+				at: &#crate_::BlockId<Block>,
+				args: Vec<u8>,
+				changes: &std::cell::RefCell<#crate_::OverlayedChanges>,
+				initialized_block: &std::cell::RefCell<Option<#crate_::BlockId<Block>>>,
+				native_call: Option<NC>,
+				context: #crate_::ExecutionContext,
+				recorder: &Option<#crate_::ProofRecorder<Block>>,
+			) -> std::result::Result<#crate_::NativeOrEncoded<R>, T::Error> {
+				let version = call_runtime_at.runtime_version_at(at)?;
+				use #crate_::InitializeBlock;
+				let initialize_block = if #skip_initialize_block {
+					InitializeBlock::Skip
+				} else {
+					InitializeBlock::Do(&initialized_block)
+				};
+				let update_initialized_block = #update_initialized_block;
+
+				#(
+					// Check if we need to call the function by an old name.
+					if version.apis.iter().any(|(s, v)| {
+						s == &ID && *v < #versions
+					}) {
+						let ret = call_runtime_at.call_api_at::<R, fn() -> _, _>(
+							core_api,
+							at,
+							#old_names,
+							args,
+							changes,
+							initialize_block,
+							None,
+							context,
+							recorder,
+						)?;
+
+						update_initialized_block();
+						return Ok(ret);
+					}
+				)*
+
+				let ret = call_runtime_at.call_api_at(
+					core_api,
+					at,
+					#trait_fn_name,
+					args,
+					changes,
+					initialize_block,
+					native_call,
+					context,
+					recorder,
+				)?;
+
+				update_initialized_block();
+				Ok(ret)
+			}
+		));
+	}
+
+	Ok(quote!( #( #result )* ))
+}
+
+/// Generate the declaration of the trait for the runtime.
+fn generate_runtime_decls(decls: &[ItemTrait]) -> TokenStream {
+	let mut result = Vec::new();
+
+	for decl in decls {
+		let mut decl = decl.clone();
+		extend_generics_with_block(&mut decl.generics);
+		let mod_name = generate_runtime_mod_name_for_trait(&decl.ident);
+		let found_attributes = remove_supported_attributes(&mut decl.attrs);
+		let api_version = unwrap_or_error(get_api_version(&found_attributes).map(|v| {
+			generate_runtime_api_version(v as u32)
+		}));
+		let id = generate_runtime_api_id(&decl.ident.to_string());
+
+		let call_api_at_calls = unwrap_or_error(generate_call_api_at_calls(&decl));
+
+		// Remove methods that have the `changed_in` attribute as they are not required for the
+		// runtime anymore.
+		decl.items = decl.items.iter_mut().filter_map(|i| match i {
+			TraitItem::Method(ref mut method) => {
+				if remove_supported_attributes(&mut method.attrs).contains_key(CHANGED_IN_ATTRIBUTE) {
+					None
+				} else {
+					// Make sure we replace all the wild card parameter names.
+					replace_wild_card_parameter_names(&mut method.sig);
+					Some(TraitItem::Method(method.clone()))
+				}
+			}
+			r => Some(r.clone()),
+		}).collect();
+
+		let native_call_generators = unwrap_or_error(generate_native_call_generators(&decl));
+
+		result.push(quote!(
+			#[doc(hidden)]
+			#[allow(dead_code)]
+			#[allow(deprecated)]
+			pub mod #mod_name {
+				use super::*;
+
+				#decl
+
+				pub #api_version
+
+				pub #id
+
+				#native_call_generators
+
+				#call_api_at_calls
+			}
+		));
+	}
+
+	quote!( #( #result )* )
+}
+
+/// Modify the given runtime api declaration to be usable on the client side.
+struct ToClientSideDecl<'a> {
+	block_id: &'a TokenStream,
+	crate_: &'a TokenStream,
+	found_attributes: &'a mut HashMap<&'static str, Attribute>,
+	/// Any error that we found while converting this declaration.
+	errors: &'a mut Vec<TokenStream>,
+	trait_: &'a Ident,
+}
+
+impl<'a> ToClientSideDecl<'a> {
+	fn fold_item_trait_items(&mut self, items: Vec<TraitItem>) -> Vec<TraitItem> {
+		let mut result = Vec::new();
+
+		items.into_iter().for_each(|i| match i {
+			TraitItem::Method(method) => {
+				let (fn_decl, fn_impl, fn_decl_ctx) = self.fold_trait_item_method(method);
+				result.push(fn_decl.into());
+				result.push(fn_decl_ctx.into());
+
+				if let Some(fn_impl) = fn_impl {
+					result.push(fn_impl.into());
+				}
+			},
+			r => result.push(r),
+		});
+
+		result
+	}
+
+	fn fold_trait_item_method(&mut self, method: TraitItemMethod)
+		-> (TraitItemMethod, Option<TraitItemMethod>, TraitItemMethod) {
+		let crate_ = self.crate_;
+		let context = quote!( #crate_::ExecutionContext::OffchainCall(None) );
+		let fn_impl = self.create_method_runtime_api_impl(method.clone());
+		let fn_decl = self.create_method_decl(method.clone(), context);
+		let fn_decl_ctx = self.create_method_decl_with_context(method);
+
+		(fn_decl, fn_impl, fn_decl_ctx)
+	}
+
+	fn create_method_decl_with_context(&mut self, method: TraitItemMethod) -> TraitItemMethod {
+		let crate_ = self.crate_;
+		let context_arg: syn::FnArg = parse_quote!( context: #crate_::ExecutionContext );
+		let mut fn_decl_ctx = self.create_method_decl(method, quote!( context ));
+		fn_decl_ctx.sig.ident = Ident::new(&format!("{}_with_context", &fn_decl_ctx.sig.ident), Span::call_site());
+		fn_decl_ctx.sig.inputs.insert(2, context_arg);
+
+		fn_decl_ctx
+	}
+
+	/// Takes the given method and creates a `method_runtime_api_impl` method that will be
+	/// implemented in the runtime for the client side.
+	fn create_method_runtime_api_impl(&mut self, mut method: TraitItemMethod) -> Option<TraitItemMethod> {
+		if remove_supported_attributes(&mut method.attrs).contains_key(CHANGED_IN_ATTRIBUTE) {
+			return None;
+		}
+
+		let fn_sig = &method.sig;
+		let ret_type = return_type_extract_type(&fn_sig.output);
+
+		// Get types and if the value is borrowed from all parameters.
+		// If there is an error, we push it as the block to the user.
+		let param_types = match extract_parameter_names_types_and_borrows(fn_sig) {
+			Ok(res) => res.into_iter().map(|v| {
+				let ty = v.1;
+				let borrow = v.2;
+				quote!( #borrow #ty )
+			}).collect::<Vec<_>>(),
+			Err(e) => {
+				self.errors.push(e.to_compile_error());
+				Vec::new()
+			}
+		};
+		let name = generate_method_runtime_api_impl_name(&self.trait_, &method.sig.ident);
+		let block_id = self.block_id;
+		let crate_ = self.crate_;
+
+		Some(
+			parse_quote!{
+				#[doc(hidden)]
+				fn #name(
+					&self,
+					at: &#block_id,
+					context: #crate_::ExecutionContext,
+					params: Option<( #( #param_types ),* )>,
+					params_encoded: Vec<u8>,
+				) -> std::result::Result<#crate_::NativeOrEncoded<#ret_type>, Self::Error>;
+			}
+		)
+	}
+
+	/// Takes the method declared by the user and creates the declaration we require for the runtime
+	/// api client side. This method will call by default the `method_runtime_api_impl` for doing
+	/// the actual call into the runtime.
+	fn create_method_decl(
+		&mut self,
+		mut method: TraitItemMethod,
+		context: TokenStream,
+	) -> TraitItemMethod {
+		let params = match extract_parameter_names_types_and_borrows(&method.sig) {
+			Ok(res) => res.into_iter().map(|v| v.0).collect::<Vec<_>>(),
+			Err(e) => {
+				self.errors.push(e.to_compile_error());
+				Vec::new()
+			}
+		};
+		let params2 = params.clone();
+		let ret_type = return_type_extract_type(&method.sig.output);
+
+		fold_fn_decl_for_client_side(&mut method.sig, &self.block_id);
+
+		let name_impl = generate_method_runtime_api_impl_name(&self.trait_, &method.sig.ident);
+		let crate_ = self.crate_;
+
+		let found_attributes = remove_supported_attributes(&mut method.attrs);
+		// If the method has a `changed_in` attribute, we need to alter the method name to
+		// `method_before_version_VERSION`.
+		let (native_handling, param_tuple) = match get_changed_in(&found_attributes) {
+			Ok(Some(version)) => {
+				// Make sure that the `changed_in` version is at least the current `api_version`.
+				if get_api_version(&self.found_attributes).ok() < Some(version) {
+					self.errors.push(
+						Error::new(
+							method.span(),
+							"`changed_in` version can not be greater than the `api_version`",
+						).to_compile_error()
+					);
+				}
+
+				let ident = Ident::new(
+					&format!("{}_before_version_{}", method.sig.ident, version),
+					method.sig.ident.span(),
+				);
+				method.sig.ident = ident;
+				method.attrs.push(parse_quote!( #[deprecated] ));
+
+				let panic = format!("Calling `{}` should not return a native value!", method.sig.ident);
+				(quote!( panic!(#panic) ), quote!( None ))
+			},
+			Ok(None) => (quote!( Ok(n) ), quote!( Some(( #( #params2 ),* )) )),
+			Err(e) => {
+				self.errors.push(e.to_compile_error());
+				(quote!( unimplemented!() ), quote!( None ))
+			}
+		};
+
+		let function_name = method.sig.ident.to_string();
+
+		// Generate the default implementation that calls the `method_runtime_api_impl` method.
+		method.default = Some(
+			parse_quote! {
+				{
+					let runtime_api_impl_params_encoded =
+						#crate_::Encode::encode(&( #( &#params ),* ));
+
+					self.#name_impl(
+						__runtime_api_at_param__,
+						#context,
+						#param_tuple,
+						runtime_api_impl_params_encoded,
+					).and_then(|r|
+						match r {
+							#crate_::NativeOrEncoded::Native(n) => {
+								#native_handling
+							},
+							#crate_::NativeOrEncoded::Encoded(r) => {
+								<#ret_type as #crate_::Decode>::decode(&mut &r[..])
+									.map_err(|err|
+										format!(
+											"Failed to decode result of `{}`: {}",
+											#function_name,
+											err.what(),
+										).into()
+									)
+							}
+						}
+					)
+				}
+			}
+		);
+
+		method
+	}
+}
+
+impl<'a> Fold for ToClientSideDecl<'a> {
+	fn fold_item_trait(&mut self, mut input: ItemTrait) -> ItemTrait {
+		extend_generics_with_block(&mut input.generics);
+
+		*self.found_attributes = remove_supported_attributes(&mut input.attrs);
+		// Check if this is the `Core` runtime api trait.
+		let is_core_trait = self.found_attributes.contains_key(CORE_TRAIT_ATTRIBUTE);
+		let block_ident = Ident::new(BLOCK_GENERIC_IDENT, Span::call_site());
+
+		if is_core_trait {
+			// Add all the supertraits we want to have for `Core`.
+			let crate_ = &self.crate_;
+			input.supertraits = parse_quote!(
+				'static
+				+ Send
+				+ Sync
+				+ #crate_::ApiExt<#block_ident>
+			);
+		} else {
+			// Add the `Core` runtime api as super trait.
+			let crate_ = &self.crate_;
+			input.supertraits.push(parse_quote!( #crate_::Core<#block_ident> ));
+		}
+
+		// The client side trait is only required when compiling with the feature `std` or `test`.
+		input.attrs.push(parse_quote!( #[cfg(any(feature = "std", test))] ));
+		input.items = self.fold_item_trait_items(input.items);
+
+		fold::fold_item_trait(self, input)
+	}
+}
+
+/// Parse the given attribute as `API_VERSION_ATTRIBUTE`.
+fn parse_runtime_api_version(version: &Attribute) -> Result<u64> {
+	let meta = version.parse_meta()?;
+
+	let err = Err(Error::new(
+			meta.span(),
+			&format!(
+				"Unexpected `{api_version}` attribute. The supported format is `{api_version}(1)`",
+				api_version = API_VERSION_ATTRIBUTE
+			)
+		)
+	);
+
+	match meta {
+		Meta::List(list) => {
+			if list.nested.len() != 1 {
+				err
+			} else if let Some(NestedMeta::Lit(Lit::Int(i))) = list.nested.first() {
+				i.base10_parse()
+			} else {
+				err
+			}
+		},
+		_ => err,
+	}
+}
+
+/// Generates the identifier as const variable for the given `trait_name`
+/// by hashing the `trait_name`.
+fn generate_runtime_api_id(trait_name: &str) -> TokenStream {
+	let mut res = [0; 8];
+	res.copy_from_slice(blake2_rfc::blake2b::blake2b(8, &[], trait_name.as_bytes()).as_bytes());
+
+	quote!(	const ID: [u8; 8] = [ #( #res ),* ]; )
+}
+
+/// Generates the const variable that holds the runtime api version.
+fn generate_runtime_api_version(version: u32) -> TokenStream {
+	quote!( const VERSION: u32 = #version; )
+}
+
+/// Generates the implementation of `RuntimeApiInfo` for the given trait.
+fn generate_runtime_info_impl(trait_: &ItemTrait, version: u64) -> TokenStream {
+	let trait_name = &trait_.ident;
+	let crate_ = generate_crate_access(HIDDEN_INCLUDES_ID);
+	let id = generate_runtime_api_id(&trait_name.to_string());
+	let version = generate_runtime_api_version(version as u32);
+
+	let impl_generics = trait_.generics.type_params().map(|t| {
+		let ident = &t.ident;
+		let colon_token = &t.colon_token;
+		let bounds = &t.bounds;
+
+		quote! { #ident #colon_token #bounds }
+	}).chain(std::iter::once(quote! { __Sr_Api_Error__ }));
+
+	let ty_generics = trait_.generics.type_params().map(|t| {
+		let ident = &t.ident;
+		quote! { #ident }
+	}).chain(std::iter::once(quote! { Error = __Sr_Api_Error__ }));
+
+	quote!(
+		#[cfg(any(feature = "std", test))]
+		impl < #( #impl_generics, )* > #crate_::RuntimeApiInfo
+			for #trait_name < #( #ty_generics, )* >
+		{
+			#id
+			#version
+		}
+	)
+}
+
+/// Get changed in version from the user given attribute or `Ok(None)`, if no attribute was given.
+fn get_changed_in(found_attributes: &HashMap<&'static str, Attribute>) -> Result<Option<u64>> {
+	found_attributes.get(&CHANGED_IN_ATTRIBUTE)
+		.map(|v| parse_runtime_api_version(v).map(Some))
+		.unwrap_or(Ok(None))
+}
+
+/// Get the api version from the user given attribute or `Ok(1)`, if no attribute was given.
+fn get_api_version(found_attributes: &HashMap<&'static str, Attribute>) -> Result<u64> {
+	found_attributes.get(&API_VERSION_ATTRIBUTE).map(parse_runtime_api_version).unwrap_or(Ok(1))
+}
+
+/// Generate the declaration of the trait for the client side.
+fn generate_client_side_decls(decls: &[ItemTrait]) -> TokenStream {
+	let mut result = Vec::new();
+
+	for decl in decls {
+		let decl = decl.clone();
+
+		let crate_ = generate_crate_access(HIDDEN_INCLUDES_ID);
+		let block_id = quote!( #crate_::BlockId<Block> );
+		let mut found_attributes = HashMap::new();
+		let mut errors = Vec::new();
+		let trait_ = decl.ident.clone();
+
+		let decl = {
+			let mut to_client_side = ToClientSideDecl {
+				crate_: &crate_,
+				block_id: &block_id,
+				found_attributes: &mut found_attributes,
+				errors: &mut errors,
+				trait_: &trait_,
+			};
+			to_client_side.fold_item_trait(decl)
+		};
+
+		let api_version = get_api_version(&found_attributes);
+
+		let runtime_info = unwrap_or_error(
+			api_version.map(|v| generate_runtime_info_impl(&decl, v))
+		);
+
+		result.push(quote!( #decl #runtime_info #( #errors )* ));
+	}
+
+	quote!( #( #result )* )
+}
+
+/// Checks that a trait declaration is in the format we expect.
+struct CheckTraitDecl {
+	errors: Vec<Error>,
+}
+
+impl<'ast> Visit<'ast> for CheckTraitDecl {
+	fn visit_fn_arg(&mut self, input: &'ast FnArg) {
+		if let FnArg::Receiver(_) = input {
+			self.errors.push(Error::new(input.span(), "`self` as argument not supported."))
+		}
+
+		visit::visit_fn_arg(self, input);
+	}
+
+	fn visit_generic_param(&mut self, input: &'ast GenericParam) {
+		match input {
+			GenericParam::Type(ty) if ty.ident == BLOCK_GENERIC_IDENT => {
+				self.errors.push(
+					Error::new(
+						input.span(),
+						"`Block: BlockT` generic parameter will be added automatically by the \
+						`decl_runtime_apis!` macro!"
+					)
+				)
+			},
+			_ => {}
+		}
+
+		visit::visit_generic_param(self, input);
+	}
+
+	fn visit_trait_bound(&mut self, input: &'ast TraitBound) {
+		if let Some(last_ident) = input.path.segments.last().map(|v| &v.ident) {
+			if last_ident == "BlockT" || last_ident == BLOCK_GENERIC_IDENT {
+				self.errors.push(
+					Error::new(
+						input.span(),
+						"`Block: BlockT` generic parameter will be added automatically by the \
+						`decl_runtime_apis!` macro! If you try to use a different trait than the \
+						substrate `Block` trait, please rename it locally."
+					)
+				)
+			}
+		}
+
+		visit::visit_trait_bound(self, input)
+	}
+}
+
+/// Check that the trait declarations are in the format we expect.
+fn check_trait_decls(decls: &[ItemTrait]) -> Option<TokenStream> {
+	let mut checker = CheckTraitDecl { errors: Vec::new() };
+	decls.iter().for_each(|decl| visit::visit_item_trait(&mut checker, &decl));
+
+	if checker.errors.is_empty() {
+		None
+	} else {
+		let errors = checker.errors.into_iter().map(|e| e.to_compile_error());
+		Some(quote!( #( #errors )* ))
+	}
+}
+
+/// The implementation of the `decl_runtime_apis!` macro.
+pub fn decl_runtime_apis_impl(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
+	// Parse all trait declarations
+	let RuntimeApiDecls { decls: api_decls } = parse_macro_input!(input as RuntimeApiDecls);
+
+	if let Some(errors) = check_trait_decls(&api_decls) {
+		return errors.into();
+	}
+
+	let hidden_includes = generate_hidden_includes(HIDDEN_INCLUDES_ID);
+	let runtime_decls = generate_runtime_decls(&api_decls);
+	let client_side_decls = generate_client_side_decls(&api_decls);
+
+	quote!(
+		#hidden_includes
+
+		#runtime_decls
+
+		#client_side_decls
+	).into()
+}

substrate/primitives/api/proc-macro/src/impl_runtime_apis.rs

@@ -0,0 +1,657 @@
+// Copyright 2018-2019 Parity Technologies (UK) Ltd.
+// This file is part of Substrate.
+
+// Substrate is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Substrate is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Substrate.  If not, see <http://www.gnu.org/licenses/>.
+
+use crate::utils::{
+	unwrap_or_error, generate_crate_access, generate_hidden_includes,
+	generate_runtime_mod_name_for_trait, generate_method_runtime_api_impl_name,
+	extract_parameter_names_types_and_borrows, generate_native_call_generator_fn_name,
+	return_type_extract_type, generate_call_api_at_fn_name, prefix_function_with_trait,
+};
+
+use proc_macro2::{Span, TokenStream};
+
+use quote::quote;
+
+use syn::{
+	spanned::Spanned, parse_macro_input, Ident, Type, ItemImpl, Path, Signature,
+	ImplItem, parse::{Parse, ParseStream, Result, Error}, PathArguments, GenericArgument, TypePath,
+	fold::{self, Fold}, parse_quote
+};
+
+use std::{collections::HashSet, iter};
+
+/// Unique identifier used to make the hidden includes unique for this macro.
+const HIDDEN_INCLUDES_ID: &str = "IMPL_RUNTIME_APIS";
+
+/// The structure used for parsing the runtime api implementations.
+struct RuntimeApiImpls {
+	impls: Vec<ItemImpl>,
+}
+
+impl Parse for RuntimeApiImpls {
+	fn parse(input: ParseStream) -> Result<Self> {
+		let mut impls = Vec::new();
+
+		while !input.is_empty() {
+			impls.push(ItemImpl::parse(input)?);
+		}
+
+		Ok(Self { impls })
+	}
+}
+
+/// Generates the call to the implementation of the requested function.
+/// The generated code includes decoding of the input arguments and encoding of the output.
+fn generate_impl_call(
+	signature: &Signature,
+	runtime: &Type,
+	input: &Ident,
+	impl_trait: &Path
+) -> Result<TokenStream> {
+	let params = extract_parameter_names_types_and_borrows(signature)?;
+
+	let c = generate_crate_access(HIDDEN_INCLUDES_ID);
+	let c_iter = iter::repeat(&c);
+	let fn_name = &signature.ident;
+	let fn_name_str = iter::repeat(fn_name.to_string());
+	let input = iter::repeat(input);
+	let pnames = params.iter().map(|v| &v.0);
+	let pnames2 = params.iter().map(|v| &v.0);
+	let ptypes = params.iter().map(|v| &v.1);
+	let pborrow = params.iter().map(|v| &v.2);
+
+	Ok(
+		quote!(
+			#(
+				let #pnames : #ptypes = match #c_iter::Decode::decode(&mut #input) {
+					Ok(input) => input,
+					Err(e) => panic!("Bad input data provided to {}: {}", #fn_name_str, e.what()),
+				};
+			)*
+
+			#[allow(deprecated)]
+			<#runtime as #impl_trait>::#fn_name(#( #pborrow #pnames2 ),*)
+		)
+	)
+}
+
+/// Extract the trait that is implemented in the given `ItemImpl`.
+fn extract_impl_trait<'a>(impl_: &'a ItemImpl) -> Result<&'a Path> {
+	impl_.trait_.as_ref().map(|v| &v.1).ok_or_else(
+		|| Error::new(impl_.span(), "Only implementation of traits are supported!")
+	).and_then(|p| {
+		if p.segments.len() > 1 {
+			Ok(p)
+		} else {
+			Err(
+				Error::new(
+					p.span(),
+					"The implemented trait has to be referenced with a path, \
+					e.g. `impl client::Core for Runtime`."
+				)
+			)
+		}
+	})
+}
+
+/// Extracts the runtime block identifier.
+fn extract_runtime_block_ident(trait_: &Path) -> Result<&TypePath> {
+	let span = trait_.span();
+	let generics = trait_
+		.segments
+		.last()
+		.ok_or_else(|| Error::new(span, "Empty path not supported"))?;
+
+	match &generics.arguments {
+		PathArguments::AngleBracketed(ref args) => {
+			args.args.first().and_then(|v| match v {
+			GenericArgument::Type(Type::Path(ref block)) => Some(block),
+				_ => None
+			}).ok_or_else(|| Error::new(args.span(), "Missing `Block` generic parameter."))
+		},
+		PathArguments::None => {
+			let span = trait_.segments.last().as_ref().unwrap().span();
+			Err(Error::new(span, "Missing `Block` generic parameter."))
+		},
+		PathArguments::Parenthesized(_) => {
+			Err(Error::new(generics.arguments.span(), "Unexpected parentheses in path!"))
+		}
+	}
+}
+
+/// Generate all the implementation calls for the given functions.
+fn generate_impl_calls(
+	impls: &[ItemImpl],
+	input: &Ident
+) -> Result<Vec<(Ident, Ident, TokenStream)>> {
+	let mut impl_calls = Vec::new();
+
+	for impl_ in impls {
+		let impl_trait_path = extract_impl_trait(impl_)?;
+		let impl_trait = extend_with_runtime_decl_path(impl_trait_path.clone());
+		let impl_trait_ident = &impl_trait_path
+			.segments
+			.last()
+			.ok_or_else(|| Error::new(impl_trait_path.span(), "Empty trait path not possible!"))?
+			.ident;
+
+		for item in &impl_.items {
+			if let ImplItem::Method(method) = item {
+				let impl_call = generate_impl_call(
+					&method.sig,
+					&impl_.self_ty,
+					input,
+					&impl_trait
+				)?;
+
+				impl_calls.push(
+					(impl_trait_ident.clone(), method.sig.ident.clone(), impl_call)
+				);
+			}
+		}
+	}
+
+	Ok(impl_calls)
+}
+
+/// Generate the dispatch function that is used in native to call into the runtime.
+fn generate_dispatch_function(impls: &[ItemImpl]) -> Result<TokenStream> {
+	let data = Ident::new("data", Span::call_site());
+	let c = generate_crate_access(HIDDEN_INCLUDES_ID);
+	let impl_calls = generate_impl_calls(impls, &data)?
+		.into_iter()
+		.map(|(trait_, fn_name, impl_)| {
+			let name = prefix_function_with_trait(&trait_, &fn_name);
+			quote!( #name => Some(#c::Encode::encode(&{ #impl_ })), )
+		});
+
+	Ok(quote!(
+		#[cfg(feature = "std")]
+		pub fn dispatch(method: &str, mut #data: &[u8]) -> Option<Vec<u8>> {
+			match method {
+				#( #impl_calls )*
+				_ => None,
+			}
+		}
+	))
+}
+
+/// Generate the interface functions that are used to call into the runtime in wasm.
+fn generate_wasm_interface(impls: &[ItemImpl]) -> Result<TokenStream> {
+	let input = Ident::new("input", Span::call_site());
+	let c = generate_crate_access(HIDDEN_INCLUDES_ID);
+	let impl_calls = generate_impl_calls(impls, &input)?
+		.into_iter()
+		.map(|(trait_, fn_name, impl_)| {
+			let fn_name = Ident::new(
+				&prefix_function_with_trait(&trait_, &fn_name),
+				Span::call_site()
+			);
+
+			quote!(
+				#[cfg(not(feature = "std"))]
+				#[no_mangle]
+				pub fn #fn_name(input_data: *mut u8, input_len: usize) -> u64 {
+					let mut #input = if input_len == 0 {
+						&[0u8; 0]
+					} else {
+						unsafe {
+							#c::slice::from_raw_parts(input_data, input_len)
+						}
+					};
+
+					let output = { #impl_ };
+					#c::to_substrate_wasm_fn_return_value(&output)
+				}
+			)
+		});
+
+	Ok(quote!( #( #impl_calls )* ))
+}
+
+fn generate_block_and_block_id_ty(
+	runtime: &Type,
+	trait_: &'static str,
+	assoc_type: &'static str,
+) -> (TokenStream, TokenStream) {
+	let crate_ = generate_crate_access(HIDDEN_INCLUDES_ID);
+	let trait_ = Ident::new(trait_, Span::call_site());
+	let assoc_type = Ident::new(assoc_type, Span::call_site());
+
+	let block = quote!( <#runtime as #crate_::#trait_>::#assoc_type );
+	let block_id = quote!( #crate_::BlockId<#block> );
+
+	(block, block_id)
+}
+
+fn generate_node_block_and_block_id_ty(runtime: &Type) -> (TokenStream, TokenStream) {
+	generate_block_and_block_id_ty(runtime, "GetNodeBlockType", "NodeBlock")
+}
+
+fn generate_runtime_api_base_structures(impls: &[ItemImpl]) -> Result<TokenStream> {
+	let crate_ = generate_crate_access(HIDDEN_INCLUDES_ID);
+	let runtime = &impls.get(0).ok_or_else(||
+		Error::new(Span::call_site(), "No api implementation given!")
+	)?.self_ty;
+	let (block, block_id) = generate_node_block_and_block_id_ty(runtime);
+
+	Ok(quote!(
+		pub struct RuntimeApi {}
+		/// Implements all runtime apis for the client side.
+		#[cfg(any(feature = "std", test))]
+		pub struct RuntimeApiImpl<C: #crate_::CallRuntimeAt<#block> + 'static> {
+			call: &'static C,
+			commit_on_success: std::cell::RefCell<bool>,
+			initialized_block: std::cell::RefCell<Option<#block_id>>,
+			changes: std::cell::RefCell<#crate_::OverlayedChanges>,
+			recorder: Option<#crate_::ProofRecorder<#block>>,
+		}
+
+		// `RuntimeApi` itself is not threadsafe. However, an instance is only available in a
+		// `ApiRef` object and `ApiRef` also has an associated lifetime. This lifetimes makes it
+		// impossible to move `RuntimeApi` into another thread.
+		#[cfg(any(feature = "std", test))]
+		unsafe impl<C: #crate_::CallRuntimeAt<#block>> Send for RuntimeApiImpl<C> {}
+		#[cfg(any(feature = "std", test))]
+		unsafe impl<C: #crate_::CallRuntimeAt<#block>> Sync for RuntimeApiImpl<C> {}
+
+		#[cfg(any(feature = "std", test))]
+		impl<C: #crate_::CallRuntimeAt<#block>> #crate_::ApiExt<#block> for RuntimeApiImpl<C> {
+			type Error = C::Error;
+
+			fn map_api_result<F: FnOnce(&Self) -> std::result::Result<R, E>, R, E>(
+				&self,
+				map_call: F
+			) -> std::result::Result<R, E> where Self: Sized {
+				*self.commit_on_success.borrow_mut() = false;
+				let res = map_call(self);
+				*self.commit_on_success.borrow_mut() = true;
+
+				self.commit_on_ok(&res);
+
+				res
+			}
+
+			fn runtime_version_at(
+				&self,
+				at: &#block_id
+			) -> std::result::Result<#crate_::RuntimeVersion, C::Error> {
+				self.call.runtime_version_at(at)
+			}
+
+			fn record_proof(&mut self) {
+				self.recorder = Some(Default::default());
+			}
+
+			fn extract_proof(&mut self) -> Option<#crate_::StorageProof> {
+				self.recorder
+					.take()
+					.map(|recorder| {
+						let trie_nodes = recorder.read()
+							.iter()
+							.filter_map(|(_k, v)| v.as_ref().map(|v| v.to_vec()))
+							.collect();
+						#crate_::StorageProof::new(trie_nodes)
+					})
+			}
+		}
+
+		#[cfg(any(feature = "std", test))]
+		impl<C: #crate_::CallRuntimeAt<#block> + 'static> #crate_::ConstructRuntimeApi<#block, C>
+			for RuntimeApi
+		{
+			type RuntimeApi = RuntimeApiImpl<C>;
+
+			fn construct_runtime_api<'a>(
+				call: &'a C,
+			) -> #crate_::ApiRef<'a, Self::RuntimeApi> {
+				RuntimeApiImpl {
+					call: unsafe { std::mem::transmute(call) },
+					commit_on_success: true.into(),
+					initialized_block: None.into(),
+					changes: Default::default(),
+					recorder: Default::default(),
+				}.into()
+			}
+		}
+
+		#[cfg(any(feature = "std", test))]
+		impl<C: #crate_::CallRuntimeAt<#block>> RuntimeApiImpl<C> {
+			fn call_api_at<
+				R: #crate_::Encode + #crate_::Decode + PartialEq,
+				F: FnOnce(
+					&C,
+					&Self,
+					&std::cell::RefCell<#crate_::OverlayedChanges>,
+					&std::cell::RefCell<Option<#crate_::BlockId<#block>>>,
+					&Option<#crate_::ProofRecorder<#block>>,
+				) -> std::result::Result<#crate_::NativeOrEncoded<R>, E>,
+				E,
+			>(
+				&self,
+				call_api_at: F,
+			) -> std::result::Result<#crate_::NativeOrEncoded<R>, E> {
+				let res = call_api_at(
+					&self.call,
+					self,
+					&self.changes,
+					&self.initialized_block,
+					&self.recorder,
+				);
+
+				self.commit_on_ok(&res);
+				res
+			}
+
+			fn commit_on_ok<R, E>(&self, res: &std::result::Result<R, E>) {
+				if *self.commit_on_success.borrow() {
+					if res.is_err() {
+						self.changes.borrow_mut().discard_prospective();
+					} else {
+						self.changes.borrow_mut().commit_prospective();
+					}
+				}
+			}
+		}
+	))
+}
+
+/// Extend the given trait path with module that contains the declaration of the trait for the
+/// runtime.
+fn extend_with_runtime_decl_path(mut trait_: Path) -> Path {
+	let runtime = {
+		let trait_name = &trait_
+			.segments
+			.last()
+			.as_ref()
+			.expect("Trait path should always contain at least one item; qed")
+			.ident;
+
+		generate_runtime_mod_name_for_trait(trait_name)
+	};
+
+	let pos = trait_.segments.len() - 1;
+	trait_.segments.insert(pos, runtime.clone().into());
+	trait_
+}
+
+/// Generates the implementations of the apis for the runtime.
+fn generate_api_impl_for_runtime(impls: &[ItemImpl]) -> Result<TokenStream> {
+	let mut impls_prepared = Vec::new();
+
+	// We put `runtime` before each trait to get the trait that is intended for the runtime and
+	// we put the `RuntimeBlock` as first argument for the trait generics.
+	for impl_ in impls.iter() {
+		let mut impl_ = impl_.clone();
+		let trait_ = extract_impl_trait(&impl_)?.clone();
+		let trait_ = extend_with_runtime_decl_path(trait_);
+
+		impl_.trait_.as_mut().unwrap().1 = trait_;
+		impls_prepared.push(impl_);
+	}
+
+	Ok(quote!( #( #impls_prepared )* ))
+}
+
+
+/// Auxiliary data structure that is used to convert `impl Api for Runtime` to
+/// `impl Api for RuntimeApi`.
+/// This requires us to replace the runtime `Block` with the node `Block`,
+/// `impl Api for Runtime` with `impl Api for RuntimeApi` and replace the method implementations
+/// with code that calls into the runtime.
+struct ApiRuntimeImplToApiRuntimeApiImpl<'a> {
+	node_block: &'a TokenStream,
+	runtime_block: &'a TypePath,
+	node_block_id: &'a TokenStream,
+	runtime_mod_path: &'a Path,
+	runtime_type: &'a Type,
+	trait_generic_arguments: &'a [GenericArgument],
+	impl_trait: &'a Ident,
+}
+
+impl<'a> Fold for ApiRuntimeImplToApiRuntimeApiImpl<'a> {
+	fn fold_type_path(&mut self, input: TypePath) -> TypePath {
+		let new_ty_path = if input == *self.runtime_block {
+			let node_block = self.node_block;
+			parse_quote!( #node_block )
+		} else {
+			input
+		};
+
+		fold::fold_type_path(self, new_ty_path)
+	}
+
+	fn fold_impl_item_method(&mut self, mut input: syn::ImplItemMethod) -> syn::ImplItemMethod {
+		let block = {
+			let runtime_mod_path = self.runtime_mod_path;
+			let runtime = self.runtime_type;
+			let native_call_generator_ident =
+				generate_native_call_generator_fn_name(&input.sig.ident);
+			let call_api_at_call = generate_call_api_at_fn_name(&input.sig.ident);
+			let trait_generic_arguments = self.trait_generic_arguments;
+			let node_block = self.node_block;
+			let crate_ = generate_crate_access(HIDDEN_INCLUDES_ID);
+			let block_id = self.node_block_id;
+
+			// Generate the access to the native parameters
+			let param_tuple_access = if input.sig.inputs.len() == 1 {
+				vec![ quote!( p ) ]
+			} else {
+				input.sig.inputs.iter().enumerate().map(|(i, _)| {
+					let i = syn::Index::from(i);
+					quote!( p.#i )
+				}).collect::<Vec<_>>()
+			};
+
+			let (param_types, error) = match extract_parameter_names_types_and_borrows(&input.sig) {
+				Ok(res) => (
+					res.into_iter().map(|v| {
+						let ty = v.1;
+						let borrow = v.2;
+						quote!( #borrow #ty )
+					}).collect::<Vec<_>>(),
+					None
+				),
+				Err(e) => (Vec::new(), Some(e.to_compile_error())),
+			};
+
+			// Rewrite the input parameters.
+			input.sig.inputs = parse_quote! {
+				&self,
+				at: &#block_id,
+				context: #crate_::ExecutionContext,
+				params: Option<( #( #param_types ),* )>,
+				params_encoded: Vec<u8>,
+			};
+
+			input.sig.ident = generate_method_runtime_api_impl_name(
+				&self.impl_trait,
+				&input.sig.ident,
+			);
+			let ret_type = return_type_extract_type(&input.sig.output);
+
+			// Generate the correct return type.
+			input.sig.output = parse_quote!(
+				-> std::result::Result<#crate_::NativeOrEncoded<#ret_type>, RuntimeApiImplCall::Error>
+			);
+
+			// Generate the new method implementation that calls into the runtime.
+			parse_quote!(
+				{
+					// Get the error to the user (if we have one).
+					#error
+
+					self.call_api_at(
+						|call_runtime_at, core_api, changes, initialized_block, recorder| {
+							#runtime_mod_path #call_api_at_call(
+								call_runtime_at,
+								core_api,
+								at,
+								params_encoded,
+								changes,
+								initialized_block,
+								params.map(|p| {
+									#runtime_mod_path #native_call_generator_ident ::
+										<#runtime, #node_block #(, #trait_generic_arguments )*> (
+										#( #param_tuple_access ),*
+									)
+								}),
+								context,
+								recorder,
+							)
+						}
+					)
+				}
+			)
+		};
+
+		let mut input =	fold::fold_impl_item_method(self, input);
+		// We need to set the block, after we modified the rest of the ast, otherwise we would
+		// modify our generated block as well.
+		input.block = block;
+		input
+	}
+
+	fn fold_item_impl(&mut self, mut input: ItemImpl) -> ItemImpl {
+		// Implement the trait for the `RuntimeApiImpl`
+		input.self_ty = Box::new(parse_quote!( RuntimeApiImpl<RuntimeApiImplCall> ));
+
+		let crate_ = generate_crate_access(HIDDEN_INCLUDES_ID);
+		let block = self.node_block;
+		input.generics.params.push(
+			parse_quote!( RuntimeApiImplCall: #crate_::CallRuntimeAt<#block> + 'static )
+		);
+
+		// The implementation for the `RuntimeApiImpl` is only required when compiling with
+		// the feature `std` or `test`.
+		input.attrs.push(parse_quote!( #[cfg(any(feature = "std", test))] ));
+
+		fold::fold_item_impl(self, input)
+	}
+}
+
+/// Generate the implementations of the runtime apis for the `RuntimeApi` type.
+fn generate_api_impl_for_runtime_api(impls: &[ItemImpl]) -> Result<TokenStream> {
+	let mut result = Vec::with_capacity(impls.len());
+
+	for impl_ in impls {
+		let impl_trait_path = extract_impl_trait(&impl_)?;
+		let impl_trait = &impl_trait_path
+			.segments
+			.last()
+			.ok_or_else(|| Error::new(impl_trait_path.span(), "Empty trait path not possible!"))?
+			.clone();
+		let runtime_block = extract_runtime_block_ident(impl_trait_path)?;
+		let (node_block, node_block_id) = generate_node_block_and_block_id_ty(&impl_.self_ty);
+		let runtime_type = &impl_.self_ty;
+		let mut runtime_mod_path = extend_with_runtime_decl_path(impl_trait_path.clone());
+		// remove the trait to get just the module path
+		runtime_mod_path.segments.pop();
+
+		let trait_generic_arguments = match impl_trait.arguments {
+			PathArguments::Parenthesized(_) | PathArguments::None => vec![],
+			PathArguments::AngleBracketed(ref b) => b.args.iter().cloned().collect(),
+		};
+
+		let mut visitor = ApiRuntimeImplToApiRuntimeApiImpl {
+			runtime_block,
+			node_block: &node_block,
+			node_block_id: &node_block_id,
+			runtime_mod_path: &runtime_mod_path,
+			runtime_type: &*runtime_type,
+			trait_generic_arguments: &trait_generic_arguments,
+			impl_trait: &impl_trait.ident,
+		};
+
+		result.push(visitor.fold_item_impl(impl_.clone()));
+	}
+	Ok(quote!( #( #result )* ))
+}
+
+/// Generates `RUNTIME_API_VERSIONS` that holds all version information about the implemented
+/// runtime apis.
+fn generate_runtime_api_versions(impls: &[ItemImpl]) -> Result<TokenStream> {
+	let mut result = Vec::with_capacity(impls.len());
+	let mut processed_traits = HashSet::new();
+
+	for impl_ in impls {
+		let mut path = extend_with_runtime_decl_path(extract_impl_trait(&impl_)?.clone());
+		// Remove the trait
+		let trait_ = path
+			.segments
+			.pop()
+			.expect("extract_impl_trait already checks that this is valid; qed")
+			.into_value()
+			.ident;
+
+		let span = trait_.span();
+		if !processed_traits.insert(trait_) {
+			return Err(
+				Error::new(
+					span,
+					"Two traits with the same name detected! \
+					The trait name is used to generate its ID. \
+					Please rename one trait at the declaration!"
+				)
+			)
+		}
+
+		let id: Path = parse_quote!( #path ID );
+		let version: Path = parse_quote!( #path VERSION );
+
+		result.push(quote!( (#id, #version) ));
+	}
+
+	let c = generate_crate_access(HIDDEN_INCLUDES_ID);
+
+	Ok(quote!(
+		const RUNTIME_API_VERSIONS: #c::ApisVec = #c::create_apis_vec!([ #( #result ),* ]);
+	))
+}
+
+/// The implementation of the `impl_runtime_apis!` macro.
+pub fn impl_runtime_apis_impl(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
+	// Parse all impl blocks
+	let RuntimeApiImpls { impls: api_impls } = parse_macro_input!(input as RuntimeApiImpls);
+
+	let dispatch_impl = unwrap_or_error(generate_dispatch_function(&api_impls));
+	let api_impls_for_runtime = unwrap_or_error(generate_api_impl_for_runtime(&api_impls));
+	let base_runtime_api = unwrap_or_error(generate_runtime_api_base_structures(&api_impls));
+	let hidden_includes = generate_hidden_includes(HIDDEN_INCLUDES_ID);
+	let runtime_api_versions = unwrap_or_error(generate_runtime_api_versions(&api_impls));
+	let wasm_interface = unwrap_or_error(generate_wasm_interface(&api_impls));
+	let api_impls_for_runtime_api = unwrap_or_error(generate_api_impl_for_runtime_api(&api_impls));
+
+	quote!(
+		#hidden_includes
+
+		#base_runtime_api
+
+		#api_impls_for_runtime
+
+		#api_impls_for_runtime_api
+
+		#runtime_api_versions
+
+		pub mod api {
+			use super::*;
+
+			#dispatch_impl
+
+			#wasm_interface
+		}
+	).into()
+}

substrate/primitives/api/proc-macro/src/lib.rs

@@ -0,0 +1,36 @@
+// Copyright 2018-2019 Parity Technologies (UK) Ltd.
+// This file is part of Substrate.
+
+// Substrate is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Substrate is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Substrate.  If not, see <http://www.gnu.org/licenses/>.
+
+//! Macros for declaring and implementing runtime apis.
+
+#![recursion_limit = "512"]
+extern crate proc_macro;
+
+use proc_macro::TokenStream;
+
+mod impl_runtime_apis;
+mod decl_runtime_apis;
+mod utils;
+
+#[proc_macro]
+pub fn impl_runtime_apis(input: TokenStream) -> TokenStream {
+	impl_runtime_apis::impl_runtime_apis_impl(input)
+}
+
+#[proc_macro]
+pub fn decl_runtime_apis(input: TokenStream) -> TokenStream {
+	decl_runtime_apis::decl_runtime_apis_impl(input)
+}

substrate/primitives/api/proc-macro/src/utils.rs

@@ -0,0 +1,178 @@
+// Copyright 2018-2019 Parity Technologies (UK) Ltd.
+// This file is part of Substrate.
+
+// Substrate is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Substrate is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Substrate.  If not, see <http://www.gnu.org/licenses/>.
+
+use proc_macro2::{TokenStream, Span};
+
+use syn::{
+	Result, Ident, Signature, parse_quote, Type, Pat, spanned::Spanned, FnArg, Error, token::And,
+};
+
+use quote::quote;
+
+use std::env;
+
+use proc_macro_crate::crate_name;
+
+/// Unwrap the given result, if it is an error, `compile_error!` will be generated.
+pub fn unwrap_or_error(res: Result<TokenStream>) -> TokenStream {
+	res.unwrap_or_else(|e| e.to_compile_error())
+}
+
+fn generate_hidden_includes_mod_name(unique_id: &'static str) -> Ident {
+	Ident::new(&format!("sp_api_hidden_includes_{}", unique_id), Span::call_site())
+}
+
+/// Generates the hidden includes that are required to make the macro independent from its scope.
+pub fn generate_hidden_includes(unique_id: &'static str) -> TokenStream {
+	if env::var("CARGO_PKG_NAME").unwrap() == "sp-api" {
+		TokenStream::new()
+	} else {
+		let mod_name = generate_hidden_includes_mod_name(unique_id);
+		match crate_name("sp-api") {
+			Ok(client_name) => {
+				let client_name = Ident::new(&client_name, Span::call_site());
+				quote!(
+					#[doc(hidden)]
+					mod #mod_name {
+						pub extern crate #client_name as sp_api;
+					}
+				)
+			},
+			Err(e) => {
+				let err = Error::new(Span::call_site(), &e).to_compile_error();
+				quote!( #err )
+			}
+		}
+
+	}.into()
+}
+
+/// Generates the access to the `sc_client` crate.
+pub fn generate_crate_access(unique_id: &'static str) -> TokenStream {
+	if env::var("CARGO_PKG_NAME").unwrap() == "sp-api" {
+		quote!( sp_api )
+	} else {
+		let mod_name = generate_hidden_includes_mod_name(unique_id);
+		quote!( self::#mod_name::sp_api )
+	}.into()
+}
+
+/// Generates the name of the module that contains the trait declaration for the runtime.
+pub fn generate_runtime_mod_name_for_trait(trait_: &Ident) -> Ident {
+	Ident::new(&format!("runtime_decl_for_{}", trait_.to_string()), Span::call_site())
+}
+
+/// Generates a name for a method that needs to be implemented in the runtime for the client side.
+pub fn generate_method_runtime_api_impl_name(trait_: &Ident, method: &Ident) -> Ident {
+	Ident::new(&format!("{}_{}_runtime_api_impl", trait_, method), Span::call_site())
+}
+
+/// Get the type of a `syn::ReturnType`.
+pub fn return_type_extract_type(rt: &syn::ReturnType) -> Type {
+	match rt {
+		syn::ReturnType::Default => parse_quote!( () ),
+		syn::ReturnType::Type(_, ref ty) => *ty.clone(),
+	}
+}
+
+/// Replace the `_` (wild card) parameter names in the given signature with unique identifiers.
+pub fn replace_wild_card_parameter_names(input: &mut Signature) {
+	let mut generated_pattern_counter = 0;
+	input.inputs.iter_mut().for_each(|arg| if let FnArg::Typed(arg) = arg {
+		arg.pat = Box::new(
+			generate_unique_pattern((*arg.pat).clone(), &mut generated_pattern_counter),
+		);
+	});
+}
+
+/// Fold the given `Signature` to make it usable on the client side.
+pub fn fold_fn_decl_for_client_side(
+	input: &mut Signature,
+	block_id: &TokenStream,
+) {
+	replace_wild_card_parameter_names(input);
+
+	// Add `&self, at:& BlockId` as parameters to each function at the beginning.
+	input.inputs.insert(0, parse_quote!( __runtime_api_at_param__: &#block_id ));
+	input.inputs.insert(0, parse_quote!( &self ));
+
+	// Wrap the output in a `Result`
+	input.output = {
+		let ty = return_type_extract_type(&input.output);
+		parse_quote!( -> std::result::Result<#ty, Self::Error> )
+	};
+}
+
+/// Generate an unique pattern based on the given counter, if the given pattern is a `_`.
+pub fn generate_unique_pattern(pat: Pat, counter: &mut u32) -> Pat {
+	match pat {
+		Pat::Wild(_) => {
+			let generated_name = Ident::new(
+				&format!("__runtime_api_generated_name_{}__", counter),
+				pat.span(),
+			);
+			*counter += 1;
+
+			parse_quote!( #generated_name )
+		},
+		_ => pat,
+	}
+ }
+
+/// Extracts the name, the type and `&` or ``(if it is a reference or not)
+/// for each parameter in the given function signature.
+pub fn extract_parameter_names_types_and_borrows(sig: &Signature)
+	-> Result<Vec<(Pat, Type, Option<And>)>>
+{
+	let mut result = Vec::new();
+	let mut generated_pattern_counter = 0;
+	for input in sig.inputs.iter() {
+		match input {
+			FnArg::Typed(arg) => {
+				let (ty, borrow) = match &*arg.ty {
+					Type::Reference(t) => {
+						((*t.elem).clone(), Some(t.and_token))
+					},
+					t => { (t.clone(), None) },
+				};
+
+				let name =
+					generate_unique_pattern((*arg.pat).clone(), &mut generated_pattern_counter);
+				result.push((name, ty, borrow));
+			},
+			FnArg::Receiver(_) => {
+				return Err(Error::new(input.span(), "`self` parameter not supported!"))
+			}
+		}
+	}
+
+	Ok(result)
+}
+
+/// Generates the name for the native call generator function.
+pub fn generate_native_call_generator_fn_name(fn_name: &Ident) -> Ident {
+	Ident::new(&format!("{}_native_call_generator", fn_name.to_string()), Span::call_site())
+}
+
+/// Generates the name for the call api at function.
+pub fn generate_call_api_at_fn_name(fn_name: &Ident) -> Ident {
+	Ident::new(&format!("{}_call_api_at", fn_name.to_string()), Span::call_site())
+}
+
+/// Prefix the given function with the trait name.
+pub fn prefix_function_with_trait<F: ToString>(trait_: &Ident, function: &F) -> String {
+	format!("{}_{}", trait_.to_string(), function.to_string())
+}