Enrich metadata with type information (#8615)

* Cargo.lock after merge * Restore scale-info feature * Fully qualify TypeInfo derive * Skip PendingSwap T * Add missing skip_type_params attr * metadata docs features * Reduce pallet event attribute to struct * Cargo.lock * Update frame/balances/src/tests_composite.rs Co-authored-by: Guillaume Thiolliere <gui.thiolliere@gmail.com> * Line widths check * Cargo.lock * Add scale-info/std * Update frame/system/src/lib.rs Co-authored-by: Guillaume Thiolliere <gui.thiolliere@gmail.com> * Use `skip_type_params` to remove `TypeInfo` requirements on checks * Revert "Remove unused Call metadata stuff" This reverts commit 41311f85 * Skip BalanceSwapAction type parameter * Remove unused event metadata macro * Update frame-metadata * Update primitives/npos-elections/compact/src/codec.rs Co-authored-by: Guillaume Thiolliere <gui.thiolliere@gmail.com> * Manual TypeInfo for Header * Remove TypeInfo requirement for consts in BoundedVec etc. * Another TypeInfo bound removed * review: fix indentation * TypeInfo impls for Identity types * Add some todos to add custom TypeInfo impls * Update frame/support/procedural/src/pallet/expand/pallet_struct.rs Co-authored-by: Guillaume Thiolliere <gui.thiolliere@gmail.com> * Add some todos to add custom TypeInfo impls * Add a test for manual Data TypeInfo impl * Add custom TypeInfo impl for Vote * Era custom TypeInfo crimes * Revert finality-grandpa version to 0.14.z * review: renamed module to pallet_constants_metadata * New line at end of file * Add missing scale-info/std * Update frame/support/src/storage/types/mod.rs Co-authored-by: Guillaume Thiolliere <gui.thiolliere@gmail.com> * Remove StorageEntryType::Map unused flag * Add missing scale-info dependency after merge * SignedExtension::AdditionalSigned metadata * Update frame-metadata, use abbreviated docs and args fields * Update frame/example/Cargo.toml Co-authored-by: Keith Yeung <kungfukeith11@gmail.com> * Add scale_info/std and remove unused scale-info dependency * Remove scale-info dependency * Remove treasury pallet::metadata * Remove redundant Event test * Add back scale-info as dev dependency * fix error metadata when no error defined in decl_module * Add Module3 to tests * Fix metadata test * Add docs feature to frame-support test * WIP fixing pallet metadata test * Remove redundant FunctionMetadata, FunctionArgumentMetadata as per https://github.com/paritytech/frame-metadata/pull/20 * Use main branch of frame-metadata * Use patch of scale-info for latest changes * Use latest patched scale-info * Manual TypeInfo for DigestItem * Manual TypeInfo for DigestItem * Update scale-info * Skip __Ignore variants for Error, depends on https://github.com/paritytech/scale-info/pull/117 * Named fields for FRAME v2 pallet Call variants * Named fields for FRAME v1 pallet Call variants * Add missing scale-info dependency * WIP expand benchmark call variant * fix benchmark with new function create a new function for each variant of a pallet call. This function is called by benchmarking macro in order not to break call creation with unnamed argument * fix tests * more fix * Fix staking tests * Fix offchain workers calls * Cherry pick rustfmt.toml from master * cargo +nightly-2021-06-22 fmt --all * Update to new call variant structs * More call variant struct updates * Remove unused import * More call variant structs * More call variant structs * Even more call variant structs * Mooar variant structs * Evermore variant structs * Call variant structs ad infinitum * Fmt * More call variants * Last call variant * Call variants all done? * Fix SS58Prefix type * Potential workaround for BitFlags<IdentityFields> TypeInfo * Enable docs capturing for Call, Event, and Error types * Fix IdentityFields TypeInfo * Remove metadata-docs feature * Add capture_docs = true for legacy Call, Event and Error types * Fmt * Fix metadata test type * Update benchmarks with call struct variants * Fmt * More test fixes * Fmt * Fix benches * Use latest capture_docs attr * Latest scale_info * Fmt * review: change &Vec to &[] * Remove pallet metadata attr * review: remove commented out test code * review: skip_type_params trailing comma suggestion * Update to scale-info 0.10.0 * Update construct_runtime ui tests, different because of metadata TypeInfo impls * Add some TypeInfo derives for UI tests * Update storage ensure span ui stderrs * Update call argument bound ui tests Possibly changed because change from tuple to struct variants? * Add scale-info dev dependency * Update to latest finality-grandpa release * review: missing newline * review: missing scale-info/std * review: remove duplicate scale-info/std * review: remove fully qualified TypeInfo * review: add missing scale-info/std * review: remove unnecessary imports. * Fmt * Use crates.io RC version of frame-metadata * Remove scale-info/std because it is a dev dependency * Add missing scale_info dev-dependency for test * Delete empty metadata folder * Fix sp_std import * review: improve manual UncheckedExtrinsic TypeInfo impl * review: use full scale-info for dev-dependency * Remove DefaultByteGetter impl * review: derive TypeInfo for generic header * Fmt * Update primitives/runtime/src/generic/unchecked_extrinsic.rs Co-authored-by: Keith Yeung <kungfukeith11@gmail.com> * Update primitives/runtime/src/generic/unchecked_extrinsic.rs Co-authored-by: Keith Yeung <kungfukeith11@gmail.com> * Update bin/node/executor/Cargo.toml Co-authored-by: Bastian Köcher <bkchr@users.noreply.github.com> * Update frame/identity/src/types.rs Co-authored-by: Bastian Köcher <bkchr@users.noreply.github.com> * Update frame/support/src/dispatch.rs Co-authored-by: Bastian Köcher <bkchr@users.noreply.github.com> * Remove redundant derive * Simplify scale-info dependency * Strip underscore prefix from call variant struct names * Another underscore field * More underscore fields * Another underscore field * Update to frame-metadata 14.0.0-rc.2 with combined StorageEntryType::Map * Fmt * Revert weights formatting * Fix up some tests * Fix up some tests for StorageEntryTypeMetadata * scale-info dev dependency * Fix test error * Add missing TypeInfo derives * Add back missing scale-info dependency * Add back missing scale-info dependency * Fix npos compact impls * Cargo.lock * Fmt * Fix errors * Fmt * Fix renamed raw_solution field * Fix error * Fmt * Fix some benchmarks * Fmt * Stray R * Fix * Add missing TypeInfos * ui test fix * Fix line widths * Revert "ui test fix" This reverts commit 2d15ec058a216e3f92d713f1174603a2bb1eac65. * Upgrade to scale-info 0.11.0 * Revert "Upgrade to scale-info 0.11.0" This reverts commit 047bb179085a0059c36cd20ab405f55cf0867e28. * Add Runtime type * Update to scale-info 0.12 * Update to scale-info 1.0 * Update frame-metadata to version 14.0.0 * Patch finality-grandpa until release available * Fix metadata tests * Fix metadata tests * Fmt * Remove patched finality-grandpa * Fix tests, use scale_info imports * Fix pallet tests * Add BlockNumber TypeInfo bound * ui test fix * Cargo.lock * Remove pallet metadata * Cargo.lock * Add missing scale-info dependency * Remove pallet event metadata * Fix error * Fix collective errors * Semicolol * Fmt * Remove another metadata attribute * Add new variant to custom digest TypeInfo * Fmt * Cargo.lock from master * Remove comma lol * Fix example call error * Fix example call error properly Co-authored-by: Guillaume Thiolliere <gui.thiolliere@gmail.com> Co-authored-by: Keith Yeung <kungfukeith11@gmail.com> Co-authored-by: Shawn Tabrizi <shawntabrizi@gmail.com> Co-authored-by: Bastian Köcher <bkchr@users.noreply.github.com>
2026-04-27 02:17:58 +00:00 · 2021-09-15 12:40:41 +01:00
parent ebe78a4c1b
commit 49b6dfd2e5
305 changed files with 4015 additions and 3947 deletions
@@ -54,6 +54,7 @@ pub fn expand_outer_dispatch(
 			Clone, PartialEq, Eq,
 			#scrate::codec::Encode,
 			#scrate::codec::Decode,
+			#scrate::scale_info::TypeInfo,
 			#scrate::RuntimeDebug,
 		)]
 		pub enum Call {
@@ -75,6 +75,7 @@ pub fn expand_outer_event(
 			Clone, PartialEq, Eq,
 			#scrate::codec::Encode,
 			#scrate::codec::Decode,
+			#scrate::scale_info::TypeInfo,
 			#scrate::RuntimeDebug,
 		)]
 		#[allow(non_camel_case_types)]
@@ -26,7 +26,7 @@ pub fn expand_runtime_metadata(
 	scrate: &TokenStream,
 	extrinsic: &TypePath,
 ) -> TokenStream {
-	let modules = pallet_declarations
+	let pallets = pallet_declarations
 		.iter()
 		.filter_map(|pallet_declaration| {
 			pallet_declaration.find_part("Pallet").map(|_| {
@@ -42,21 +42,21 @@ pub fn expand_runtime_metadata(
 		.map(|(decl, filtered_names)| {
 			let name = &decl.name;
 			let index = &decl.index;
-			let storage = expand_pallet_metadata_storage(&filtered_names, runtime, scrate, decl);
-			let calls = expand_pallet_metadata_calls(&filtered_names, runtime, scrate, decl);
+			let storage = expand_pallet_metadata_storage(&filtered_names, runtime, decl);
+			let calls = expand_pallet_metadata_calls(&filtered_names, runtime, decl);
 			let event = expand_pallet_metadata_events(&filtered_names, runtime, scrate, decl);
-			let constants = expand_pallet_metadata_constants(runtime, scrate, decl);
-			let errors = expand_pallet_metadata_errors(runtime, scrate, decl);
+			let constants = expand_pallet_metadata_constants(runtime, decl);
+			let errors = expand_pallet_metadata_errors(runtime, decl);

 			quote! {
-				#scrate::metadata::ModuleMetadata {
-					name: #scrate::metadata::DecodeDifferent::Encode(stringify!(#name)),
+				#scrate::metadata::PalletMetadata {
+					name: stringify!(#name),
 					index: #index,
 					storage: #storage,
 					calls: #calls,
 					event: #event,
 					constants: #constants,
-					errors: #errors,
+					error: #errors,
 				}
 			}
 		})
@@ -65,20 +65,26 @@ pub fn expand_runtime_metadata(
 	quote! {
 		impl #runtime {
 			pub fn metadata() -> #scrate::metadata::RuntimeMetadataPrefixed {
-				#scrate::metadata::RuntimeMetadataLastVersion {
-					modules: #scrate::metadata::DecodeDifferent::Encode(&[ #(#modules),* ]),
-					extrinsic: #scrate::metadata::ExtrinsicMetadata {
+				#scrate::metadata::RuntimeMetadataLastVersion::new(
+					#scrate::sp_std::vec![ #(#pallets),* ],
+					#scrate::metadata::ExtrinsicMetadata {
+						ty: #scrate::scale_info::meta_type::<#extrinsic>(),
 						version: <#extrinsic as #scrate::sp_runtime::traits::ExtrinsicMetadata>::VERSION,
 						signed_extensions: <
 								<
 									#extrinsic as #scrate::sp_runtime::traits::ExtrinsicMetadata
 								>::SignedExtensions as #scrate::sp_runtime::traits::SignedExtension
-							>::identifier()
+							>::metadata()
 								.into_iter()
-								.map(#scrate::metadata::DecodeDifferent::Encode)
+								.map(|meta| #scrate::metadata::SignedExtensionMetadata {
+									identifier: meta.identifier,
+									ty: meta.ty,
+									additional_signed: meta.additional_signed,
+								})
 								.collect(),
 					},
-				}.into()
+					#scrate::scale_info::meta_type::<#runtime>()
+				).into()
 			}
 		}
 	}
@@ -87,7 +93,6 @@ pub fn expand_runtime_metadata(
 fn expand_pallet_metadata_storage(
 	filtered_names: &[&'static str],
 	runtime: &Ident,
-	scrate: &TokenStream,
 	decl: &Pallet,
 ) -> TokenStream {
 	if filtered_names.contains(&"Storage") {
@@ -95,11 +100,7 @@ fn expand_pallet_metadata_storage(
 		let path = &decl.path;

 		quote! {
-			Some(#scrate::metadata::DecodeDifferent::Encode(
-				#scrate::metadata::FnEncode(
-					#path::Pallet::<#runtime #(, #path::#instance)*>::storage_metadata
-				)
-			))
+			Some(#path::Pallet::<#runtime #(, #path::#instance)*>::storage_metadata())
 		}
 	} else {
 		quote!(None)
@@ -109,7 +110,6 @@ fn expand_pallet_metadata_storage(
 fn expand_pallet_metadata_calls(
 	filtered_names: &[&'static str],
 	runtime: &Ident,
-	scrate: &TokenStream,
 	decl: &Pallet,
 ) -> TokenStream {
 	if filtered_names.contains(&"Call") {
@@ -117,11 +117,7 @@ fn expand_pallet_metadata_calls(
 		let path = &decl.path;

 		quote! {
-			Some(#scrate::metadata::DecodeDifferent::Encode(
-				#scrate::metadata::FnEncode(
-					#path::Pallet::<#runtime #(, #path::#instance)*>::call_functions
-				)
-			))
+			Some(#path::Pallet::<#runtime #(, #path::#instance)*>::call_functions())
 		}
 	} else {
 		quote!(None)
@@ -150,45 +146,31 @@ fn expand_pallet_metadata_events(
 		};

 		quote! {
-			Some(#scrate::metadata::DecodeDifferent::Encode(
-				#scrate::metadata::FnEncode(#pallet_event::metadata)
-			))
+			Some(
+				#scrate::metadata::PalletEventMetadata {
+					ty: #scrate::scale_info::meta_type::<#pallet_event>()
+				}
+			)
 		}
 	} else {
 		quote!(None)
 	}
 }

-fn expand_pallet_metadata_constants(
-	runtime: &Ident,
-	scrate: &TokenStream,
-	decl: &Pallet,
-) -> TokenStream {
+fn expand_pallet_metadata_constants(runtime: &Ident, decl: &Pallet) -> TokenStream {
 	let path = &decl.path;
 	let instance = decl.instance.as_ref().into_iter();

 	quote! {
-		#scrate::metadata::DecodeDifferent::Encode(
-			#scrate::metadata::FnEncode(
-				#path::Pallet::<#runtime #(, #path::#instance)*>::module_constants_metadata
-			)
-		)
+		#path::Pallet::<#runtime #(, #path::#instance)*>::pallet_constants_metadata()
 	}
 }

-fn expand_pallet_metadata_errors(
-	runtime: &Ident,
-	scrate: &TokenStream,
-	decl: &Pallet,
-) -> TokenStream {
+fn expand_pallet_metadata_errors(runtime: &Ident, decl: &Pallet) -> TokenStream {
 	let path = &decl.path;
 	let instance = decl.instance.as_ref().into_iter();

 	quote! {
-		#scrate::metadata::DecodeDifferent::Encode(
-			#scrate::metadata::FnEncode(
-				<#path::Pallet::<#runtime #(, #path::#instance)*> as #scrate::metadata::ModuleErrorMetadata>::metadata
-			)
-		)
+		#path::Pallet::<#runtime #(, #path::#instance)*>::error_metadata()
 	}
 }
@@ -171,7 +171,10 @@ pub fn expand_outer_origin(
 			}
 		}

-		#[derive(Clone, PartialEq, Eq, #scrate::RuntimeDebug, #scrate::codec::Encode, #scrate::codec::Decode)]
+		#[derive(
+			Clone, PartialEq, Eq, #scrate::RuntimeDebug, #scrate::codec::Encode,
+			#scrate::codec::Decode, #scrate::scale_info::TypeInfo,
+		)]
 		#[allow(non_camel_case_types)]
 		pub enum OriginCaller {
 			#[codec(index = #system_index)]
@@ -151,7 +151,10 @@ fn construct_runtime_parsed(definition: RuntimeDefinition) -> Result<TokenStream
 			type __hidden_use_of_unchecked_extrinsic = #unchecked_extrinsic;
 		};

-		#[derive(Clone, Copy, PartialEq, Eq, #scrate::sp_runtime::RuntimeDebug)]
+		#[derive(
+			Clone, Copy, PartialEq, Eq, #scrate::sp_runtime::RuntimeDebug,
+			#scrate::scale_info::TypeInfo
+		)]
 		pub struct #name;
 		impl #scrate::sp_runtime::traits::GetNodeBlockType for #name {
 			type NodeBlock = #node_block;
@@ -48,7 +48,7 @@ pub fn impl_key_prefix_for_tuples(input: proc_macro::TokenStream) -> Result<Toke

 			let trait_impls = quote! {
 				impl<
-					#(#current_tuple: FullCodec,)*
+					#(#current_tuple: FullCodec + StaticTypeInfo,)*
 					#(#hashers: StorageHasher,)*
 					#(#kargs: EncodeLike<#prefixes>),*
 				> HasKeyPrefix<( #( #kargs, )* )> for ( #( Key<#hashers, #current_tuple>, )* ) {
@@ -60,7 +60,7 @@ pub fn impl_key_prefix_for_tuples(input: proc_macro::TokenStream) -> Result<Toke
 				}

 				impl<
-					#(#current_tuple: FullCodec,)*
+					#(#current_tuple: FullCodec + StaticTypeInfo,)*
 					#(#hashers: ReversibleStorageHasher,)*
 					#(#kargs: EncodeLike<#prefixes>),*
 				> HasReversibleKeyPrefix<( #( #kargs, )* )> for ( #( Key<#hashers, #current_tuple>, )* ) {
@@ -16,7 +16,6 @@
 // limitations under the License.

 use crate::{pallet::Def, COUNTER};
-use frame_support_procedural_tools::clean_type_string;
 use syn::spanned::Spanned;

 ///
@@ -43,6 +42,15 @@ pub fn expand_call(def: &mut Def) -> proc_macro2::TokenStream {
 	let pallet_ident = &def.pallet_struct.pallet;

 	let fn_name = methods.iter().map(|method| &method.name).collect::<Vec<_>>();
+	let new_call_variant_fn_name = fn_name
+		.iter()
+		.map(|fn_name| quote::format_ident!("new_call_variant_{}", fn_name))
+		.collect::<Vec<_>>();
+
+	let new_call_variant_doc = fn_name
+		.iter()
+		.map(|fn_name| format!("Create a call with the variant `{}`.", fn_name))
+		.collect::<Vec<_>>();

 	let fn_weight = methods.iter().map(|method| &method.weight);

@@ -53,6 +61,42 @@ pub fn expand_call(def: &mut Def) -> proc_macro2::TokenStream {
 		.map(|method| method.args.iter().map(|(_, name, _)| name.clone()).collect::<Vec<_>>())
 		.collect::<Vec<_>>();

+	let args_name_stripped = methods
+		.iter()
+		.map(|method| {
+			method
+				.args
+				.iter()
+				.map(|(_, name, _)| {
+					syn::Ident::new(&name.to_string().trim_start_matches('_'), name.span())
+				})
+				.collect::<Vec<_>>()
+		})
+		.collect::<Vec<_>>();
+
+	let make_args_name_pattern = |ref_tok| {
+		args_name
+			.iter()
+			.zip(args_name_stripped.iter())
+			.map(|(args_name, args_name_stripped)| {
+				args_name
+					.iter()
+					.zip(args_name_stripped)
+					.map(|(args_name, args_name_stripped)| {
+						if args_name == args_name_stripped {
+							quote::quote!( #ref_tok #args_name )
+						} else {
+							quote::quote!( #args_name_stripped: #ref_tok #args_name )
+						}
+					})
+					.collect::<Vec<_>>()
+			})
+			.collect::<Vec<_>>()
+	};
+
+	let args_name_pattern = make_args_name_pattern(None);
+	let args_name_pattern_ref = make_args_name_pattern(Some(quote::quote!(ref)));
+
 	let args_type = methods
 		.iter()
 		.map(|method| method.args.iter().map(|(_, _, type_)| type_.clone()).collect::<Vec<_>>())
@@ -72,21 +116,6 @@ pub fn expand_call(def: &mut Def) -> proc_macro2::TokenStream {
 			.collect::<Vec<_>>()
 	});

-	let args_metadata_type = methods.iter().map(|method| {
-		method
-			.args
-			.iter()
-			.map(|(is_compact, _, type_)| {
-				let final_type = if *is_compact {
-					quote::quote_spanned!(type_.span() => Compact<#type_>)
-				} else {
-					quote::quote!(#type_)
-				};
-				clean_type_string(&final_type.to_string())
-			})
-			.collect::<Vec<_>>()
-	});
-
 	let default_docs = [syn::parse_quote!(
 		r"Contains one variant per dispatchable that can be called by an extrinsic."
 	)];
@@ -131,9 +160,11 @@ pub fn expand_call(def: &mut Def) -> proc_macro2::TokenStream {
 			#frame_support::PartialEqNoBound,
 			#frame_support::codec::Encode,
 			#frame_support::codec::Decode,
+			#frame_support::scale_info::TypeInfo,
 		)]
 		#[codec(encode_bound())]
 		#[codec(decode_bound())]
+		#[scale_info(skip_type_params(#type_use_gen), capture_docs = "always")]
 		#[allow(non_camel_case_types)]
 		pub enum #call_ident<#type_decl_bounded_gen> #where_clause {
 			#[doc(hidden)]
@@ -142,7 +173,25 @@ pub fn expand_call(def: &mut Def) -> proc_macro2::TokenStream {
 				#frame_support::sp_std::marker::PhantomData<(#type_use_gen,)>,
 				#frame_support::Never,
 			),
-			#( #( #[doc = #fn_doc] )* #fn_name( #( #args_compact_attr #args_type ),* ), )*
+			#(
+				#( #[doc = #fn_doc] )*
+				#fn_name {
+					#( #args_compact_attr #args_name_stripped: #args_type ),*
+				},
+			)*
+		}
+
+		impl<#type_impl_gen> #call_ident<#type_use_gen> #where_clause {
+			#(
+				#[doc = #new_call_variant_doc]
+				pub fn #new_call_variant_fn_name(
+					#( #args_name_stripped: #args_type ),*
+				) -> Self {
+					Self::#fn_name {
+						#( #args_name_stripped ),*
+					}
+				}
+			)*
 		}

 		impl<#type_impl_gen> #frame_support::dispatch::GetDispatchInfo
@@ -152,7 +201,7 @@ pub fn expand_call(def: &mut Def) -> proc_macro2::TokenStream {
 			fn get_dispatch_info(&self) -> #frame_support::dispatch::DispatchInfo {
 				match *self {
 					#(
-						Self::#fn_name ( #( ref #args_name, )* ) => {
+						Self::#fn_name { #( #args_name_pattern_ref, )* } => {
 							let __pallet_base_weight = #fn_weight;

 							let __pallet_weight = <
@@ -186,7 +235,7 @@ pub fn expand_call(def: &mut Def) -> proc_macro2::TokenStream {
 		{
 			fn get_call_name(&self) -> &'static str {
 				match *self {
-					#( Self::#fn_name(..) => stringify!(#fn_name), )*
+					#( Self::#fn_name { .. } => stringify!(#fn_name), )*
 					Self::__Ignore(_, _) => unreachable!("__PhantomItem cannot be used."),
 				}
 			}
@@ -207,7 +256,7 @@ pub fn expand_call(def: &mut Def) -> proc_macro2::TokenStream {
 			) -> #frame_support::dispatch::DispatchResultWithPostInfo {
 				match self {
 					#(
-						Self::#fn_name( #( #args_name, )* ) => {
+						Self::#fn_name { #( #args_name_pattern, )* } => {
 							#frame_support::sp_tracing::enter_span!(
 								#frame_support::sp_tracing::trace_span!(stringify!(#fn_name))
 							);
@@ -231,30 +280,8 @@ pub fn expand_call(def: &mut Def) -> proc_macro2::TokenStream {

 		impl<#type_impl_gen> #pallet_ident<#type_use_gen> #where_clause {
 			#[doc(hidden)]
-			#[allow(dead_code)]
-			pub fn call_functions() -> &'static [#frame_support::dispatch::FunctionMetadata] {
-				&[ #(
-					#frame_support::dispatch::FunctionMetadata {
-						name: #frame_support::dispatch::DecodeDifferent::Encode(
-							stringify!(#fn_name)
-						),
-						arguments: #frame_support::dispatch::DecodeDifferent::Encode(
-							&[ #(
-								#frame_support::dispatch::FunctionArgumentMetadata {
-									name: #frame_support::dispatch::DecodeDifferent::Encode(
-										stringify!(#args_name)
-									),
-									ty: #frame_support::dispatch::DecodeDifferent::Encode(
-										#args_metadata_type
-									),
-								},
-							)* ]
-						),
-						documentation: #frame_support::dispatch::DecodeDifferent::Encode(
-							&[ #( #fn_doc ),* ]
-						),
-					},
-				)* ]
+			pub fn call_functions() -> #frame_support::metadata::PalletCallMetadata {
+				#frame_support::scale_info::meta_type::<#call_ident<#type_use_gen>>().into()
 			}
 		}
 	)
@@ -15,7 +15,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.

-use crate::pallet::{parse::helper::get_doc_literals, Def};
+use crate::pallet::Def;
+use frame_support_procedural_tools::get_doc_literals;

 ///
 /// * Generate default rust doc
@@ -16,8 +16,6 @@
 // limitations under the License.

 use crate::pallet::Def;
-use frame_support_procedural_tools::clean_type_string;
-use quote::ToTokens;

 struct ConstDef {
 	/// Name of the associated type.
@@ -35,7 +33,6 @@ struct ConstDef {
 pub fn expand_constants(def: &mut Def) -> proc_macro2::TokenStream {
 	let frame_support = &def.frame_support;
 	let type_impl_gen = &def.type_impl_generics(proc_macro2::Span::call_site());
-	let type_decl_gen = &def.type_decl_generics(proc_macro2::Span::call_site());
 	let type_use_gen = &def.type_use_generics(proc_macro2::Span::call_site());
 	let pallet_ident = &def.pallet_struct.pallet;

@@ -74,50 +71,17 @@ pub fn expand_constants(def: &mut Def) -> proc_macro2::TokenStream {

 	let consts = config_consts.chain(extra_consts).map(|const_| {
 		let const_type = &const_.type_;
-		let const_type_str = clean_type_string(&const_type.to_token_stream().to_string());
 		let ident = &const_.ident;
 		let ident_str = format!("{}", ident);
 		let doc = const_.doc.clone().into_iter();
 		let default_byte_impl = &const_.default_byte_impl;
-		let default_byte_getter =
-			syn::Ident::new(&format!("{}DefaultByteGetter", ident), ident.span());

 		quote::quote!({
-			#[allow(non_upper_case_types)]
-			#[allow(non_camel_case_types)]
-			struct #default_byte_getter<#type_decl_gen>(
-				#frame_support::sp_std::marker::PhantomData<(#type_use_gen)>
-			);
-
-			impl<#type_impl_gen> #frame_support::dispatch::DefaultByte for
-				#default_byte_getter<#type_use_gen>
-				#completed_where_clause
-			{
-				fn default_byte(&self) -> #frame_support::sp_std::vec::Vec<u8> {
-					#default_byte_impl
-				}
-			}
-
-			unsafe impl<#type_impl_gen> Send for #default_byte_getter<#type_use_gen>
-				#completed_where_clause
-			{}
-			unsafe impl<#type_impl_gen> Sync for #default_byte_getter<#type_use_gen>
-				#completed_where_clause
-			{}
-
-			#frame_support::dispatch::ModuleConstantMetadata {
-				name: #frame_support::dispatch::DecodeDifferent::Encode(#ident_str),
-				ty: #frame_support::dispatch::DecodeDifferent::Encode(#const_type_str),
-				value: #frame_support::dispatch::DecodeDifferent::Encode(
-					#frame_support::dispatch::DefaultByteGetter(
-						&#default_byte_getter::<#type_use_gen>(
-							#frame_support::sp_std::marker::PhantomData
-						)
-					)
-				),
-				documentation: #frame_support::dispatch::DecodeDifferent::Encode(
-					&[ #( #doc ),* ]
-				),
+			#frame_support::metadata::PalletConstantMetadata {
+				name: #ident_str,
+				ty: #frame_support::scale_info::meta_type::<#const_type>(),
+				value: { #default_byte_impl },
+				docs: #frame_support::sp_std::vec![ #( #doc ),* ],
 			}
 		})
 	});
@@ -126,10 +90,10 @@ pub fn expand_constants(def: &mut Def) -> proc_macro2::TokenStream {
 		impl<#type_impl_gen> #pallet_ident<#type_use_gen> #completed_where_clause{

 			#[doc(hidden)]
-			pub fn module_constants_metadata()
-				-> &'static [#frame_support::dispatch::ModuleConstantMetadata]
+			pub fn pallet_constants_metadata()
+				-> #frame_support::sp_std::vec::Vec<#frame_support::metadata::PalletConstantMetadata>
 			{
-				&[ #( #consts ),* ]
+				#frame_support::sp_std::vec![ #( #consts ),* ]
 			}
 		}
 	)
@@ -15,11 +15,11 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.

-use crate::pallet::{parse::helper::get_doc_literals, Def};
+use crate::pallet::Def;
+use frame_support_procedural_tools::get_doc_literals;

 ///
 /// * impl various trait on Error
-/// * impl ModuleErrorMetadata for Error
 pub fn expand_error(def: &mut Def) -> proc_macro2::TokenStream {
 	let error = if let Some(error) = &def.error { error } else { return Default::default() };

@@ -32,6 +32,7 @@ pub fn expand_error(def: &mut Def) -> proc_macro2::TokenStream {

 	let phantom_variant: syn::Variant = syn::parse_quote!(
 		#[doc(hidden)]
+		#[codec(skip)]
 		__Ignore(
 			#frame_support::sp_std::marker::PhantomData<(#type_use_gen)>,
 			#frame_support::Never,
@@ -47,16 +48,6 @@ pub fn expand_error(def: &mut Def) -> proc_macro2::TokenStream {
 		quote::quote_spanned!(error.attr_span => Self::#variant => #variant_str,)
 	});

-	let metadata = error.variants.iter().map(|(variant, doc)| {
-		let variant_str = format!("{}", variant);
-		quote::quote_spanned!(error.attr_span =>
-			#frame_support::error::ErrorMetadata {
-				name: #frame_support::error::DecodeDifferent::Encode(#variant_str),
-				documentation: #frame_support::error::DecodeDifferent::Encode(&[ #( #doc, )* ]),
-			},
-		)
-	});
-
 	let error_item = {
 		let item = &mut def.item.content.as_mut().expect("Checked by def parser").1[error.index];
 		if let syn::Item::Enum(item) = item {
@@ -67,6 +58,13 @@ pub fn expand_error(def: &mut Def) -> proc_macro2::TokenStream {
 	};

 	error_item.variants.insert(0, phantom_variant);
+	// derive TypeInfo for error metadata
+	error_item
+		.attrs
+		.push(syn::parse_quote!( #[derive(#frame_support::scale_info::TypeInfo)] ));
+	error_item.attrs.push(syn::parse_quote!(
+		#[scale_info(skip_type_params(#type_use_gen), capture_docs = "always")]
+	));

 	if get_doc_literals(&error_item.attrs).is_empty() {
 		error_item.attrs.push(syn::parse_quote!(
@@ -130,14 +128,5 @@ pub fn expand_error(def: &mut Def) -> proc_macro2::TokenStream {
 				}
 			}
 		}
-
-		impl<#type_impl_gen> #frame_support::error::ModuleErrorMetadata
-			for #error_ident<#type_use_gen>
-			#config_where_clause
-		{
-			fn metadata() -> &'static [#frame_support::error::ErrorMetadata] {
-				&[ #( #metadata )* ]
-			}
-		}
 	)
 }
@@ -16,9 +16,10 @@
 // limitations under the License.

 use crate::{
-	pallet::{parse::helper::get_doc_literals, Def},
+	pallet::{parse::event::PalletEventDepositAttr, Def},
 	COUNTER,
 };
+use frame_support_procedural_tools::get_doc_literals;
 use syn::{spanned::Spanned, Ident};

 ///
@@ -69,20 +70,6 @@ pub fn expand_event(def: &mut Def) -> proc_macro2::TokenStream {
 	let frame_support = &def.frame_support;
 	let event_use_gen = &event.gen_kind.type_use_gen(event.attr_span);
 	let event_impl_gen = &event.gen_kind.type_impl_gen(event.attr_span);
-	let metadata = event.metadata.iter().map(|(ident, args, docs)| {
-		let name = format!("{}", ident);
-		quote::quote_spanned!(event.attr_span =>
-			#frame_support::event::EventMetadata {
-				name: #frame_support::event::DecodeDifferent::Encode(#name),
-				arguments: #frame_support::event::DecodeDifferent::Encode(&[
-					#( #args, )*
-				]),
-				documentation: #frame_support::event::DecodeDifferent::Encode(&[
-					#( #docs, )*
-				]),
-			},
-		)
-	});

 	let event_item = {
 		let item = &mut def.item.content.as_mut().expect("Checked by def parser").1[event.index];
@@ -126,15 +113,23 @@ pub fn expand_event(def: &mut Def) -> proc_macro2::TokenStream {
 			#frame_support::RuntimeDebugNoBound,
 			#frame_support::codec::Encode,
 			#frame_support::codec::Decode,
+			#frame_support::scale_info::TypeInfo,
 		)]
 	));

-	let deposit_event = if let Some((fn_vis, fn_span)) = &event.deposit_event {
+	// skip requirement for type params to implement `TypeInfo`, and require docs capture
+	event_item.attrs.push(syn::parse_quote!(
+		#[scale_info(skip_type_params(#event_use_gen), capture_docs = "always")]
+	));
+
+	let deposit_event = if let Some(deposit_event) = &event.deposit_event {
 		let event_use_gen = &event.gen_kind.type_use_gen(event.attr_span);
 		let trait_use_gen = &def.trait_use_generics(event.attr_span);
 		let type_impl_gen = &def.type_impl_generics(event.attr_span);
 		let type_use_gen = &def.type_use_generics(event.attr_span);

+		let PalletEventDepositAttr { fn_vis, fn_span, .. } = deposit_event;
+
 		quote::quote_spanned!(*fn_span =>
 			impl<#type_impl_gen> Pallet<#type_use_gen> #completed_where_clause {
 				#fn_vis fn deposit_event(event: Event<#event_use_gen>) {
@@ -174,13 +169,5 @@ pub fn expand_event(def: &mut Def) -> proc_macro2::TokenStream {
 		impl<#event_impl_gen> From<#event_ident<#event_use_gen>> for () #event_where_clause {
 			fn from(_: #event_ident<#event_use_gen>) {}
 		}
-
-		impl<#event_impl_gen> #event_ident<#event_use_gen> #event_where_clause {
-			#[allow(dead_code)]
-			#[doc(hidden)]
-			pub fn metadata() -> &'static [#frame_support::event::EventMetadata] {
-				&[ #( #metadata )* ]
-			}
-		}
 	)
 }
@@ -15,10 +15,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.

-use crate::{
-	pallet::{parse::helper::get_doc_literals, Def},
-	COUNTER,
-};
+use crate::{pallet::Def, COUNTER};
+use frame_support_procedural_tools::get_doc_literals;
 use syn::{spanned::Spanned, Ident};

 ///
@@ -32,7 +32,8 @@ mod store_trait;
 mod type_value;
 mod validate_unsigned;

-use crate::pallet::{parse::helper::get_doc_literals, Def};
+use crate::pallet::Def;
+use frame_support_procedural_tools::get_doc_literals;
 use quote::ToTokens;

 /// Merge where clause together, `where` token span is taken from the first not none one.
@@ -15,13 +15,14 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.

-use crate::pallet::{expand::merge_where_clauses, parse::helper::get_doc_literals, Def};
+use crate::pallet::{expand::merge_where_clauses, Def};
+use frame_support_procedural_tools::get_doc_literals;

 ///
 /// * Add derive trait on Pallet
 /// * Implement GetStorageVersion on Pallet
 /// * Implement OnGenesis on Pallet
-/// * Implement ModuleErrorMetadata on Pallet
+/// * Implement `fn error_metadata` on Pallet
 /// * declare Module type alias for construct_runtime
 /// * replace the first field type of `struct Pallet` with `PhantomData` if it is `_`
 /// * implementation of `PalletInfoAccess` information
@@ -76,28 +77,22 @@ pub fn expand_pallet_struct(def: &mut Def) -> proc_macro2::TokenStream {
 		)]
 	));

-	let module_error_metadata = if let Some(error_def) = &def.error {
+	let pallet_error_metadata = if let Some(error_def) = &def.error {
 		let error_ident = &error_def.error;
 		quote::quote_spanned!(def.pallet_struct.attr_span =>
-			impl<#type_impl_gen> #frame_support::error::ModuleErrorMetadata
-				for #pallet_ident<#type_use_gen>
-				#config_where_clause
-			{
-				fn metadata() -> &'static [#frame_support::error::ErrorMetadata] {
-					<
-						#error_ident<#type_use_gen> as #frame_support::error::ModuleErrorMetadata
-					>::metadata()
+			impl<#type_impl_gen> #pallet_ident<#type_use_gen> #config_where_clause {
+				pub fn error_metadata() -> Option<#frame_support::metadata::PalletErrorMetadata> {
+					Some(#frame_support::metadata::PalletErrorMetadata {
+						ty: #frame_support::scale_info::meta_type::<#error_ident<#type_use_gen>>()
+					})
 				}
 			}
 		)
 	} else {
 		quote::quote_spanned!(def.pallet_struct.attr_span =>
-			impl<#type_impl_gen> #frame_support::error::ModuleErrorMetadata
-				for #pallet_ident<#type_use_gen>
-				#config_where_clause
-			{
-				fn metadata() -> &'static [#frame_support::error::ErrorMetadata] {
-					&[]
+			impl<#type_impl_gen> #pallet_ident<#type_use_gen> #config_where_clause {
+				pub fn error_metadata() -> Option<#frame_support::metadata::PalletErrorMetadata> {
+					None
 				}
 			}
 		)
@@ -159,7 +154,7 @@ pub fn expand_pallet_struct(def: &mut Def) -> proc_macro2::TokenStream {
 	};

 	quote::quote_spanned!(def.pallet_struct.attr_span =>
-		#module_error_metadata
+		#pallet_error_metadata

 		/// Type alias to `Pallet`, to be used by `construct_runtime`.
 		///
@@ -19,7 +19,6 @@ use crate::pallet::{
 	parse::storage::{Metadata, QueryKind, StorageDef, StorageGenerics},
 	Def,
 };
-use frame_support_procedural_tools::clean_type_string;
 use std::collections::HashSet;

 /// Generate the prefix_ident related the the storage.
@@ -176,89 +175,15 @@ pub fn expand_storages(def: &mut Def) -> proc_macro2::TokenStream {

 		let cfg_attrs = &storage.cfg_attrs;

-		let metadata_trait = match &storage.metadata {
-			Metadata::Value { .. } => quote::quote_spanned!(storage.attr_span =>
-				#frame_support::storage::types::StorageValueMetadata
-			),
-			Metadata::Map { .. } => quote::quote_spanned!(storage.attr_span =>
-				#frame_support::storage::types::StorageMapMetadata
-			),
-			Metadata::DoubleMap { .. } => quote::quote_spanned!(storage.attr_span =>
-				#frame_support::storage::types::StorageDoubleMapMetadata
-			),
-			Metadata::NMap { .. } => quote::quote_spanned!(storage.attr_span =>
-				#frame_support::storage::types::StorageNMapMetadata
-			),
-		};
-
-		let ty = match &storage.metadata {
-			Metadata::Value { value } => {
-				let value = clean_type_string(&quote::quote!(#value).to_string());
-				quote::quote_spanned!(storage.attr_span =>
-					#frame_support::metadata::StorageEntryType::Plain(
-						#frame_support::metadata::DecodeDifferent::Encode(#value)
-					)
-				)
-			},
-			Metadata::Map { key, value } => {
-				let value = clean_type_string(&quote::quote!(#value).to_string());
-				let key = clean_type_string(&quote::quote!(#key).to_string());
-				quote::quote_spanned!(storage.attr_span =>
-					#frame_support::metadata::StorageEntryType::Map {
-						hasher: <#full_ident as #metadata_trait>::HASHER,
-						key: #frame_support::metadata::DecodeDifferent::Encode(#key),
-						value: #frame_support::metadata::DecodeDifferent::Encode(#value),
-						unused: false,
-					}
-				)
-			},
-			Metadata::DoubleMap { key1, key2, value } => {
-				let value = clean_type_string(&quote::quote!(#value).to_string());
-				let key1 = clean_type_string(&quote::quote!(#key1).to_string());
-				let key2 = clean_type_string(&quote::quote!(#key2).to_string());
-				quote::quote_spanned!(storage.attr_span =>
-					#frame_support::metadata::StorageEntryType::DoubleMap {
-						hasher: <#full_ident as #metadata_trait>::HASHER1,
-						key2_hasher: <#full_ident as #metadata_trait>::HASHER2,
-						key1: #frame_support::metadata::DecodeDifferent::Encode(#key1),
-						key2: #frame_support::metadata::DecodeDifferent::Encode(#key2),
-						value: #frame_support::metadata::DecodeDifferent::Encode(#value),
-					}
-				)
-			},
-			Metadata::NMap { keys, value, .. } => {
-				let keys = keys
-					.iter()
-					.map(|key| clean_type_string(&quote::quote!(#key).to_string()))
-					.collect::<Vec<_>>();
-				let value = clean_type_string(&quote::quote!(#value).to_string());
-				quote::quote_spanned!(storage.attr_span =>
-					#frame_support::metadata::StorageEntryType::NMap {
-						keys: #frame_support::metadata::DecodeDifferent::Encode(&[
-							#( #keys, )*
-						]),
-						hashers: #frame_support::metadata::DecodeDifferent::Encode(
-							<#full_ident as #metadata_trait>::HASHERS,
-						),
-						value: #frame_support::metadata::DecodeDifferent::Encode(#value),
-					}
-				)
-			},
-		};
-
 		quote::quote_spanned!(storage.attr_span =>
 			#(#cfg_attrs)* #frame_support::metadata::StorageEntryMetadata {
-				name: #frame_support::metadata::DecodeDifferent::Encode(
-					<#full_ident as #metadata_trait>::NAME
-				),
-				modifier: <#full_ident as #metadata_trait>::MODIFIER,
-				ty: #ty,
-				default: #frame_support::metadata::DecodeDifferent::Encode(
-					<#full_ident as #metadata_trait>::DEFAULT
-				),
-				documentation: #frame_support::metadata::DecodeDifferent::Encode(&[
+				name: <#full_ident as #frame_support::storage::StorageEntryMetadata>::NAME,
+				modifier: <#full_ident as #frame_support::storage::StorageEntryMetadata>::MODIFIER,
+				ty: <#full_ident as #frame_support::storage::StorageEntryMetadata>::ty(),
+				default: <#full_ident as #frame_support::storage::StorageEntryMetadata>::default(),
+				docs: #frame_support::sp_std::vec![
 					#( #docs, )*
-				]),
+				],
 			}
 		)
 	});
@@ -419,18 +344,16 @@ pub fn expand_storages(def: &mut Def) -> proc_macro2::TokenStream {
 			#completed_where_clause
 		{
 			#[doc(hidden)]
-			pub fn storage_metadata() -> #frame_support::metadata::StorageMetadata {
-				#frame_support::metadata::StorageMetadata {
-					prefix: #frame_support::metadata::DecodeDifferent::Encode(
-						<
-							<T as #frame_system::Config>::PalletInfo as
-							#frame_support::traits::PalletInfo
-						>::name::<#pallet_ident<#type_use_gen>>()
-							.expect("Every active pallet has a name in the runtime; qed")
-					),
-					entries: #frame_support::metadata::DecodeDifferent::Encode(
-						&[ #( #entries, )* ]
-					),
+			pub fn storage_metadata() -> #frame_support::metadata::PalletStorageMetadata {
+				#frame_support::metadata::PalletStorageMetadata {
+					prefix: <
+						<T as #frame_system::Config>::PalletInfo as
+						#frame_support::traits::PalletInfo
+					>::name::<#pallet_ident<#type_use_gen>>()
+						.expect("Every active pallet has a name in the runtime; qed"),
+					entries: #frame_support::sp_std::vec![
+						#( #entries, )*
+					],
 				}
 			}
 		}
@@ -16,6 +16,7 @@
 // limitations under the License.

 use super::helper;
+use frame_support_procedural_tools::get_doc_literals;
 use quote::ToTokens;
 use syn::spanned::Spanned;

@@ -219,7 +220,7 @@ impl CallDef {
 					args.push((!arg_attrs.is_empty(), arg_ident, arg.ty.clone()));
 				}

-				let docs = helper::get_doc_literals(&method.attrs);
+				let docs = get_doc_literals(&method.attrs);

 				methods.push(CallVariantDef { name: method.sig.ident.clone(), weight, args, docs });
 			} else {
@@ -234,7 +235,7 @@ impl CallDef {
 			instances,
 			methods,
 			where_clause: item.generics.where_clause.clone(),
-			docs: helper::get_doc_literals(&item.attrs),
+			docs: get_doc_literals(&item.attrs),
 		})
 	}
 }
@@ -17,6 +17,7 @@

 use super::helper;
 use core::convert::TryFrom;
+use frame_support_procedural_tools::get_doc_literals;
 use quote::ToTokens;
 use syn::spanned::Spanned;

@@ -69,7 +70,7 @@ impl TryFrom<&syn::TraitItemType> for ConstMetadataDef {
 		let err = |span, msg| {
 			syn::Error::new(span, format!("Invalid usage of `#[pallet::constant]`: {}", msg))
 		};
-		let doc = helper::get_doc_literals(&trait_ty.attrs);
+		let doc = get_doc_literals(&trait_ty.attrs);
 		let ident = trait_ty.ident.clone();
 		let bound = trait_ty
 			.bounds
@@ -16,6 +16,7 @@
 // limitations under the License.

 use super::helper;
+use frame_support_procedural_tools::get_doc_literals;
 use quote::ToTokens;
 use syn::spanned::Spanned;

@@ -80,7 +81,7 @@ impl ErrorDef {
 					return Err(syn::Error::new(span, msg))
 				}

-				Ok((variant.ident.clone(), helper::get_doc_literals(&variant.attrs)))
+				Ok((variant.ident.clone(), get_doc_literals(&variant.attrs)))
 			})
 			.collect::<Result<_, _>>()?;

@@ -16,13 +16,11 @@
 // limitations under the License.

 use super::helper;
-use frame_support_procedural_tools::clean_type_string;
 use quote::ToTokens;
 use syn::spanned::Spanned;

 /// List of additional token to be used for parsing.
 mod keyword {
-	syn::custom_keyword!(metadata);
 	syn::custom_keyword!(Event);
 	syn::custom_keyword!(pallet);
 	syn::custom_keyword!(generate_deposit);
@@ -35,60 +33,31 @@ pub struct EventDef {
 	pub index: usize,
 	/// The keyword Event used (contains span).
 	pub event: keyword::Event,
-	/// Event metadatas: `(name, args, docs)`.
-	pub metadata: Vec<(syn::Ident, Vec<String>, Vec<syn::Lit>)>,
 	/// A set of usage of instance, must be check for consistency with trait.
 	pub instances: Vec<helper::InstanceUsage>,
 	/// The kind of generic the type `Event` has.
 	pub gen_kind: super::GenericKind,
 	/// Whether the function `deposit_event` must be generated.
-	pub deposit_event: Option<(syn::Visibility, proc_macro2::Span)>,
+	pub deposit_event: Option<PalletEventDepositAttr>,
 	/// Where clause used in event definition.
 	pub where_clause: Option<syn::WhereClause>,
 	/// The span of the pallet::event attribute.
 	pub attr_span: proc_macro2::Span,
 }

-/// Attribute for Event: defines metadata name to use.
+/// Attribute for a pallet's Event.
 ///
 /// Syntax is:
-/// * `#[pallet::metadata(SomeType = MetadataName, ...)]`
 /// * `#[pallet::generate_deposit($vis fn deposit_event)]`
-enum PalletEventAttr {
-	Metadata {
-		metadata: Vec<(syn::Type, String)>,
-		// Span of the attribute
-		span: proc_macro2::Span,
-	},
-	DepositEvent {
-		fn_vis: syn::Visibility,
-		// Span for the keyword deposit_event
-		fn_span: proc_macro2::Span,
-		// Span of the attribute
-		span: proc_macro2::Span,
-	},
+pub struct PalletEventDepositAttr {
+	pub fn_vis: syn::Visibility,
+	// Span for the keyword deposit_event
+	pub fn_span: proc_macro2::Span,
+	// Span of the attribute
+	pub span: proc_macro2::Span,
 }

-impl PalletEventAttr {
-	fn span(&self) -> proc_macro2::Span {
-		match self {
-			Self::Metadata { span, .. } => *span,
-			Self::DepositEvent { span, .. } => *span,
-		}
-	}
-}
-
-/// Parse for syntax `$Type = "$SomeString"`.
-fn parse_event_metadata_element(
-	input: syn::parse::ParseStream,
-) -> syn::Result<(syn::Type, String)> {
-	let typ = input.parse::<syn::Type>()?;
-	input.parse::<syn::Token![=]>()?;
-	let ident = input.parse::<syn::LitStr>()?;
-	Ok((typ, ident.value()))
-}
-
-impl syn::parse::Parse for PalletEventAttr {
+impl syn::parse::Parse for PalletEventDepositAttr {
 	fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
 		input.parse::<syn::Token![#]>()?;
 		let content;
@@ -96,56 +65,33 @@ impl syn::parse::Parse for PalletEventAttr {
 		content.parse::<keyword::pallet>()?;
 		content.parse::<syn::Token![::]>()?;

-		let lookahead = content.lookahead1();
-		if lookahead.peek(keyword::metadata) {
-			let span = content.parse::<keyword::metadata>()?.span();
-			let metadata_content;
-			syn::parenthesized!(metadata_content in content);
+		let span = content.parse::<keyword::generate_deposit>()?.span();
+		let generate_content;
+		syn::parenthesized!(generate_content in content);
+		let fn_vis = generate_content.parse::<syn::Visibility>()?;
+		generate_content.parse::<syn::Token![fn]>()?;
+		let fn_span = generate_content.parse::<keyword::deposit_event>()?.span();

-			let metadata = metadata_content
-				.parse_terminated::<_, syn::Token![,]>(parse_event_metadata_element)?
-				.into_pairs()
-				.map(syn::punctuated::Pair::into_value)
-				.collect();
-
-			Ok(PalletEventAttr::Metadata { metadata, span })
-		} else if lookahead.peek(keyword::generate_deposit) {
-			let span = content.parse::<keyword::generate_deposit>()?.span();
-
-			let generate_content;
-			syn::parenthesized!(generate_content in content);
-			let fn_vis = generate_content.parse::<syn::Visibility>()?;
-			generate_content.parse::<syn::Token![fn]>()?;
-			let fn_span = generate_content.parse::<keyword::deposit_event>()?.span();
-
-			Ok(PalletEventAttr::DepositEvent { fn_vis, span, fn_span })
-		} else {
-			Err(lookahead.error())
-		}
+		Ok(PalletEventDepositAttr { fn_vis, span, fn_span })
 	}
 }

 struct PalletEventAttrInfo {
-	metadata: Option<Vec<(syn::Type, String)>>,
-	deposit_event: Option<(syn::Visibility, proc_macro2::Span)>,
+	deposit_event: Option<PalletEventDepositAttr>,
 }

 impl PalletEventAttrInfo {
-	fn from_attrs(attrs: Vec<PalletEventAttr>) -> syn::Result<Self> {
-		let mut metadata = None;
+	fn from_attrs(attrs: Vec<PalletEventDepositAttr>) -> syn::Result<Self> {
 		let mut deposit_event = None;
 		for attr in attrs {
-			match attr {
-				PalletEventAttr::Metadata { metadata: m, .. } if metadata.is_none() =>
-					metadata = Some(m),
-				PalletEventAttr::DepositEvent { fn_vis, fn_span, .. }
-					if deposit_event.is_none() =>
-					deposit_event = Some((fn_vis, fn_span)),
-				attr => return Err(syn::Error::new(attr.span(), "Duplicate attribute")),
+			if deposit_event.is_none() {
+				deposit_event = Some(attr)
+			} else {
+				return Err(syn::Error::new(attr.span, "Duplicate attribute"))
 			}
 		}

-		Ok(PalletEventAttrInfo { metadata, deposit_event })
+		Ok(PalletEventAttrInfo { deposit_event })
 	}
 }

@@ -161,9 +107,9 @@ impl EventDef {
 			return Err(syn::Error::new(item.span(), "Invalid pallet::event, expected item enum"))
 		};

-		let event_attrs: Vec<PalletEventAttr> = helper::take_item_pallet_attrs(&mut item.attrs)?;
+		let event_attrs: Vec<PalletEventDepositAttr> =
+			helper::take_item_pallet_attrs(&mut item.attrs)?;
 		let attr_info = PalletEventAttrInfo::from_attrs(event_attrs)?;
-		let metadata = attr_info.metadata.unwrap_or_else(Vec::new);
 		let deposit_event = attr_info.deposit_event;

 		if !matches!(item.vis, syn::Visibility::Public(_)) {
@@ -190,39 +136,6 @@ impl EventDef {

 		let event = syn::parse2::<keyword::Event>(item.ident.to_token_stream())?;

-		let metadata = item
-			.variants
-			.iter()
-			.map(|variant| {
-				let name = variant.ident.clone();
-				let docs = helper::get_doc_literals(&variant.attrs);
-				let args = variant
-					.fields
-					.iter()
-					.map(|field| {
-						metadata
-							.iter()
-							.find(|m| m.0 == field.ty)
-							.map(|m| m.1.clone())
-							.unwrap_or_else(|| {
-								clean_type_string(&field.ty.to_token_stream().to_string())
-							})
-					})
-					.collect();
-
-				(name, args, docs)
-			})
-			.collect();
-
-		Ok(EventDef {
-			attr_span,
-			index,
-			metadata,
-			instances,
-			deposit_event,
-			event,
-			gen_kind,
-			where_clause,
-		})
+		Ok(EventDef { attr_span, index, instances, deposit_event, event, gen_kind, where_clause })
 	}
 }
@@ -16,6 +16,7 @@
 // limitations under the License.

 use super::helper;
+use frame_support_procedural_tools::get_doc_literals;
 use syn::spanned::Spanned;

 /// List of additional token to be used for parsing.
@@ -104,7 +105,7 @@ impl ExtraConstantsDef {
 			extra_constants.push(ExtraConstantDef {
 				ident: method.sig.ident.clone(),
 				type_,
-				doc: helper::get_doc_literals(&method.attrs),
+				doc: get_doc_literals(&method.attrs),
 			});
 		}

@@ -139,24 +139,6 @@ impl MutItemAttrs for syn::ItemMod {
 	}
 }

-/// Return all doc attributes literals found.
-pub fn get_doc_literals(attrs: &Vec<syn::Attribute>) -> Vec<syn::Lit> {
-	attrs
-		.iter()
-		.filter_map(|attr| {
-			if let Ok(syn::Meta::NameValue(meta)) = attr.parse_meta() {
-				if meta.path.get_ident().map_or(false, |ident| ident == "doc") {
-					Some(meta.lit)
-				} else {
-					None
-				}
-			} else {
-				None
-			}
-		})
-		.collect()
-}
-
 /// Parse for `()`
 struct Unit;
 impl syn::parse::Parse for Unit {
@@ -16,6 +16,7 @@
 // limitations under the License.

 use super::helper;
+use frame_support_procedural_tools::get_doc_literals;
 use quote::ToTokens;
 use std::collections::HashMap;
 use syn::spanned::Spanned;
@@ -609,7 +610,7 @@ impl StorageDef {
 		instances.push(helper::check_type_def_gen(&item.generics, item.ident.span())?);

 		let where_clause = item.generics.where_clause.clone();
-		let docs = helper::get_doc_literals(&item.attrs);
+		let docs = get_doc_literals(&item.attrs);

 		let typ = if let syn::Type::Path(typ) = &*item.ty {
 			typ
@@ -126,6 +126,7 @@ fn create_and_impl_instance_struct(
 			Clone, Eq, PartialEq,
 			#scrate::codec::Encode,
 			#scrate::codec::Decode,
+			#scrate::scale_info::TypeInfo,
 			#scrate::RuntimeDebug,
 		)]
 		#doc
@@ -18,31 +18,28 @@
 //! Implementation of `storage_metadata` on module structure, used by construct_runtime.

 use super::{DeclStorageDefExt, StorageLineDefExt, StorageLineTypeDef};
-use frame_support_procedural_tools::clean_type_string;
+use frame_support_procedural_tools::get_doc_literals;
 use proc_macro2::TokenStream;
 use quote::quote;

 fn storage_line_metadata_type(scrate: &TokenStream, line: &StorageLineDefExt) -> TokenStream {
 	let value_type = &line.value_type;
-	let value_type = clean_type_string(&quote!( #value_type ).to_string());
 	match &line.storage_type {
 		StorageLineTypeDef::Simple(_) => {
 			quote! {
 				#scrate::metadata::StorageEntryType::Plain(
-					#scrate::metadata::DecodeDifferent::Encode(#value_type),
+					#scrate::scale_info::meta_type::<#value_type>()
 				)
 			}
 		},
 		StorageLineTypeDef::Map(map) => {
 			let hasher = map.hasher.into_metadata();
 			let key = &map.key;
-			let key = clean_type_string(&quote!(#key).to_string());
 			quote! {
 				#scrate::metadata::StorageEntryType::Map {
-					hasher: #scrate::metadata::#hasher,
-					key: #scrate::metadata::DecodeDifferent::Encode(#key),
-					value: #scrate::metadata::DecodeDifferent::Encode(#value_type),
-					unused: false,
+					hashers: #scrate::sp_std::vec! [ #scrate::metadata::#hasher ],
+					key: #scrate::scale_info::meta_type::<#key>(),
+					value: #scrate::scale_info::meta_type::<#value_type>(),
 				}
 			}
 		},
@@ -50,39 +47,32 @@ fn storage_line_metadata_type(scrate: &TokenStream, line: &StorageLineDefExt) ->
 			let hasher1 = map.hasher1.into_metadata();
 			let hasher2 = map.hasher2.into_metadata();
 			let key1 = &map.key1;
-			let key1 = clean_type_string(&quote!(#key1).to_string());
 			let key2 = &map.key2;
-			let key2 = clean_type_string(&quote!(#key2).to_string());
 			quote! {
-				#scrate::metadata::StorageEntryType::DoubleMap {
-					hasher: #scrate::metadata::#hasher1,
-					key1: #scrate::metadata::DecodeDifferent::Encode(#key1),
-					key2: #scrate::metadata::DecodeDifferent::Encode(#key2),
-					value: #scrate::metadata::DecodeDifferent::Encode(#value_type),
-					key2_hasher: #scrate::metadata::#hasher2,
+				#scrate::metadata::StorageEntryType::Map {
+					hashers: #scrate::sp_std::vec! [
+						#scrate::metadata::#hasher1,
+						#scrate::metadata::#hasher2,
+					],
+					key: #scrate::scale_info::meta_type::<(#key1, #key2)>(),
+					value: #scrate::scale_info::meta_type::<#value_type>(),
 				}
 			}
 		},
 		StorageLineTypeDef::NMap(map) => {
-			let keys = map
-				.keys
-				.iter()
-				.map(|key| clean_type_string(&quote!(#key).to_string()))
-				.collect::<Vec<_>>();
+			let key_tuple = &map.to_key_tuple();
 			let hashers = map
 				.hashers
 				.iter()
 				.map(|hasher| hasher.to_storage_hasher_struct())
 				.collect::<Vec<_>>();
 			quote! {
-				#scrate::metadata::StorageEntryType::NMap {
-					keys: #scrate::metadata::DecodeDifferent::Encode(&[
-						#( #keys, )*
-					]),
-					hashers: #scrate::metadata::DecodeDifferent::Encode(&[
+				#scrate::metadata::StorageEntryType::Map {
+					hashers: #scrate::sp_std::vec! [
 						#( #scrate::metadata::StorageHasher::#hashers, )*
-					]),
-					value: #scrate::metadata::DecodeDifferent::Encode(#value_type),
+					],
+					key: #scrate::scale_info::meta_type::<#key_tuple>(),
+					value: #scrate::scale_info::meta_type::<#value_type>(),
 				}
 			}
 		},
@@ -129,8 +119,7 @@ fn default_byte_getter(

 		#[cfg(feature = "std")]
 		impl<#runtime_generic: #runtime_trait, #optional_instance_bound>
-			#scrate::metadata::DefaultByte
-			for #struct_name<#runtime_generic, #optional_instance>
+			#struct_name<#runtime_generic, #optional_instance>
 			#where_clause
 		{
 			fn default_byte(&self) -> #scrate::sp_std::vec::Vec<u8> {
@@ -142,16 +131,9 @@ fn default_byte_getter(
 			}
 		}

-		unsafe impl<#runtime_generic: #runtime_trait, #optional_instance_bound> Send
-			for #struct_name<#runtime_generic, #optional_instance> #where_clause {}
-
-		unsafe impl<#runtime_generic: #runtime_trait, #optional_instance_bound> Sync
-			for #struct_name<#runtime_generic, #optional_instance> #where_clause {}
-
 		#[cfg(not(feature = "std"))]
 		impl<#runtime_generic: #runtime_trait, #optional_instance_bound>
-			#scrate::metadata::DefaultByte
-			for #struct_name<#runtime_generic, #optional_instance>
+			#struct_name<#runtime_generic, #optional_instance>
 			#where_clause
 		{
 			fn default_byte(&self) -> #scrate::sp_std::vec::Vec<u8> {
@@ -187,25 +169,15 @@ pub fn impl_metadata(def: &DeclStorageDefExt) -> TokenStream {
 		let (default_byte_getter_struct_def, default_byte_getter_struct_instance) =
 			default_byte_getter(scrate, line, def);

-		let mut docs = TokenStream::new();
-		for attr in line.attrs.iter().filter_map(|v| v.parse_meta().ok()) {
-			if let syn::Meta::NameValue(meta) = attr {
-				if meta.path.is_ident("doc") {
-					let lit = meta.lit;
-					docs.extend(quote!(#lit,));
-				}
-			}
-		}
+		let docs = get_doc_literals(&line.attrs);

 		let entry = quote! {
 			#scrate::metadata::StorageEntryMetadata {
-				name: #scrate::metadata::DecodeDifferent::Encode(#str_name),
+				name: #str_name,
 				modifier: #modifier,
 				ty: #ty,
-				default: #scrate::metadata::DecodeDifferent::Encode(
-					#scrate::metadata::DefaultByteGetter(&#default_byte_getter_struct_instance)
-				),
-				documentation: #scrate::metadata::DecodeDifferent::Encode(&[ #docs ]),
+				default: #default_byte_getter_struct_instance.default_byte(),
+				docs: #scrate::sp_std::vec![ #( #docs ),* ],
 			},
 		};

@@ -222,9 +194,9 @@ pub fn impl_metadata(def: &DeclStorageDefExt) -> TokenStream {
 	};

 	let store_metadata = quote!(
-		#scrate::metadata::StorageMetadata {
-			prefix: #scrate::metadata::DecodeDifferent::Encode(#prefix),
-			entries: #scrate::metadata::DecodeDifferent::Encode(&[ #entries ][..]),
+		#scrate::metadata::PalletStorageMetadata {
+			prefix: #prefix,
+			entries: #scrate::sp_std::vec![ #entries ],
 		}
 	);

@@ -237,7 +209,7 @@ pub fn impl_metadata(def: &DeclStorageDefExt) -> TokenStream {

 		impl#module_impl #module_struct #where_clause {
 			#[doc(hidden)]
-			pub fn storage_metadata() -> #scrate::metadata::StorageMetadata {
+			pub fn storage_metadata() -> #scrate::metadata::PalletStorageMetadata {
 				#store_metadata
 			}
 		}
@@ -100,3 +100,21 @@ pub fn clean_type_string(input: &str) -> String {
 		.replace("< ", "<")
 		.replace(" >", ">")
 }
+
+/// Return all doc attributes literals found.
+pub fn get_doc_literals(attrs: &[syn::Attribute]) -> Vec<syn::Lit> {
+	attrs
+		.iter()
+		.filter_map(|attr| {
+			if let Ok(syn::Meta::NameValue(meta)) = attr.parse_meta() {
+				if meta.path.get_ident().map_or(false, |ident| ident == "doc") {
+					Some(meta.lit)
+				} else {
+					None
+				}
+			} else {
+				None
+			}
+		})
+		.collect()
+}