Implement StorageNMap

frame/assets/src/lib.rs

@@ -158,6 +158,7 @@ pub use pallet::*;
 pub mod pallet {
 	use frame_support::{
 		dispatch::DispatchResult,
+		storage,
 		pallet_prelude::*,
 	};
 	use frame_system::pallet_prelude::*;
@@ -237,12 +238,13 @@ pub mod pallet {
 	#[pallet::storage]
 	/// Approved balance transfers. First balance is the amount approved for transfer. Second
 	/// is the amount of `T::Currency` reserved for storing this.
-	pub(super) type Approvals<T: Config<I>, I: 'static = ()> = StorageDoubleMap<
+	pub(super) type Approvals<T: Config<I>, I: 'static = ()> = StorageNMap<
 		_,
-		Blake2_128Concat,
-		T::AssetId,
-		Blake2_128Concat,
-		ApprovalKey<T::AccountId>,
+		(
+			storage::Key<Blake2_128Concat, T::AssetId>,
+			storage::Key<Blake2_128Concat, T::AccountId>,
+			storage::Key<Blake2_128Concat, T::AccountId>,
+		),
 		Approval<T::Balance, DepositBalanceOf<T, I>>,
 		OptionQuery,
 	>;
@@ -504,7 +506,7 @@ pub mod pallet {
 					details.deposit.saturating_add(metadata.deposit),
 				);
 
-				Approvals::<T, I>::remove_prefix(&id);
+				Approvals::<T, I>::remove_prefix((id,));
 				Self::deposit_event(Event::Destroyed(id));
 
 				// NOTE: could use postinfo to reflect the actual number of accounts/sufficient/approvals
@@ -1120,19 +1122,18 @@ pub mod pallet {
 			let owner = ensure_signed(origin)?;
 			let delegate = T::Lookup::lookup(delegate)?;
 
-			let key = ApprovalKey { owner, delegate };
-			Approvals::<T, I>::try_mutate(id, &key, |maybe_approved| -> DispatchResult {
+			Approvals::<T, I>::try_mutate((id, &owner, &delegate), |maybe_approved| -> DispatchResult {
 				let mut approved = maybe_approved.take().unwrap_or_default();
 				let deposit_required = T::ApprovalDeposit::get();
 				if approved.deposit < deposit_required {
-					T::Currency::reserve(&key.owner, deposit_required - approved.deposit)?;
+					T::Currency::reserve(&owner, deposit_required - approved.deposit)?;
 					approved.deposit = deposit_required;
 				}
 				approved.amount = approved.amount.saturating_add(amount);
 				*maybe_approved = Some(approved);
 				Ok(())
 			})?;
-			Self::deposit_event(Event::ApprovedTransfer(id, key.owner, key.delegate, amount));
+			Self::deposit_event(Event::ApprovedTransfer(id, owner, delegate, amount));
 
 			Ok(())
 		}
@@ -1158,11 +1159,10 @@ pub mod pallet {
 		) -> DispatchResult {
 			let owner = ensure_signed(origin)?;
 			let delegate = T::Lookup::lookup(delegate)?;
-			let key = ApprovalKey { owner, delegate };
-			let approval = Approvals::<T, I>::take(id, &key).ok_or(Error::<T, I>::Unknown)?;
-			T::Currency::unreserve(&key.owner, approval.deposit);
+			let approval = Approvals::<T, I>::take((id, &owner, &delegate)).ok_or(Error::<T, I>::Unknown)?;
+			T::Currency::unreserve(&owner, approval.deposit);
 
-			Self::deposit_event(Event::ApprovalCancelled(id, key.owner, key.delegate));
+			Self::deposit_event(Event::ApprovalCancelled(id, owner, delegate));
 			Ok(())
 		}
 
@@ -1198,11 +1198,10 @@ pub mod pallet {
 			let owner = T::Lookup::lookup(owner)?;
 			let delegate = T::Lookup::lookup(delegate)?;
 
-			let key = ApprovalKey { owner, delegate };
-			let approval = Approvals::<T, I>::take(id, &key).ok_or(Error::<T, I>::Unknown)?;
-			T::Currency::unreserve(&key.owner, approval.deposit);
+			let approval = Approvals::<T, I>::take((id, &owner, &delegate)).ok_or(Error::<T, I>::Unknown)?;
+			T::Currency::unreserve(&owner, approval.deposit);
 
-			Self::deposit_event(Event::ApprovalCancelled(id, key.owner, key.delegate));
+			Self::deposit_event(Event::ApprovalCancelled(id, owner, delegate));
 			Ok(())
 		}
 
@@ -1236,8 +1235,7 @@ pub mod pallet {
 			let owner = T::Lookup::lookup(owner)?;
 			let destination = T::Lookup::lookup(destination)?;
 
-			let key = ApprovalKey { owner, delegate };
-			Approvals::<T, I>::try_mutate_exists(id, &key, |maybe_approved| -> DispatchResult {
+			Approvals::<T, I>::try_mutate_exists((id, &owner, delegate), |maybe_approved| -> DispatchResult {
 				let mut approved = maybe_approved.take().ok_or(Error::<T, I>::Unapproved)?;
 				let remaining = approved
 					.amount
@@ -1249,10 +1247,10 @@ pub mod pallet {
 					best_effort: false,
 					burn_dust: false
 				};
-				Self::do_transfer(id, &key.owner, &destination, amount, None, f)?;
+				Self::do_transfer(id, &owner, &destination, amount, None, f)?;
 
 				if remaining.is_zero() {
-					T::Currency::unreserve(&key.owner, approved.deposit);
+					T::Currency::unreserve(&owner, approved.deposit);
 				} else {
 					approved.amount = remaining;
 					*maybe_approved = Some(approved);

frame/assets/src/types.rs

@@ -65,15 +65,6 @@ impl<Balance, AccountId, DepositBalance> AssetDetails<Balance, AccountId, Deposi
 	}
 }
 
-/// A pair to act as a key for the approval storage map.
-#[derive(Clone, Encode, Decode, Eq, PartialEq, RuntimeDebug)]
-pub struct ApprovalKey<AccountId> {
-	/// The owner of the funds that are being approved.
-	pub(super) owner: AccountId,
-	/// The party to whom transfer of the funds is being delegated.
-	pub(super) delegate: AccountId,
-}
-
 /// Data concerning an approval.
 #[derive(Clone, Encode, Decode, Eq, PartialEq, RuntimeDebug, Default)]
 pub struct Approval<Balance, DepositBalance> {

frame/metadata/src/lib.rs

@@ -300,6 +300,11 @@ pub enum StorageEntryType {
 		value: DecodeDifferentStr,
 		key2_hasher: StorageHasher,
 	},
+	NMap {
+		keys: DecodeDifferentArray<&'static str, StringBuf>,
+		hashers: DecodeDifferentArray<StorageHasher>,
+		value: DecodeDifferentStr,
+	},
 }
 
 /// A storage entry modifier.
@@ -364,8 +369,10 @@ pub enum RuntimeMetadata {
 	V10(RuntimeMetadataDeprecated),
 	/// Version 11 for runtime metadata. No longer used.
 	V11(RuntimeMetadataDeprecated),
-	/// Version 12 for runtime metadata.
-	V12(RuntimeMetadataV12),
+	/// Version 12 for runtime metadata. No longer used.
+	V12(RuntimeMetadataDeprecated),
+	/// Version 13 for runtime metadata.
+	V13(RuntimeMetadataV13),
 }
 
 /// Enum that should fail.
@@ -389,15 +396,15 @@ impl Decode for RuntimeMetadataDeprecated {
 /// The metadata of a runtime.
 #[derive(Eq, Encode, PartialEq, RuntimeDebug)]
 #[cfg_attr(feature = "std", derive(Decode, Serialize))]
-pub struct RuntimeMetadataV12 {
+pub struct RuntimeMetadataV13 {
 	/// Metadata of all the modules.
 	pub modules: DecodeDifferentArray<ModuleMetadata>,
 	/// Metadata of the extrinsic.
 	pub extrinsic: ExtrinsicMetadata,
 }
 
 /// The latest version of the metadata.
-pub type RuntimeMetadataLastVersion = RuntimeMetadataV12;
+pub type RuntimeMetadataLastVersion = RuntimeMetadataV13;
 
 /// All metadata about an runtime module.
 #[derive(Clone, PartialEq, Eq, Encode, RuntimeDebug)]
@@ -425,6 +432,6 @@ impl Into<sp_core::OpaqueMetadata> for RuntimeMetadataPrefixed {
 
 impl Into<RuntimeMetadataPrefixed> for RuntimeMetadataLastVersion {
 	fn into(self) -> RuntimeMetadataPrefixed {
-		RuntimeMetadataPrefixed(META_RESERVED, RuntimeMetadata::V12(self))
+		RuntimeMetadataPrefixed(META_RESERVED, RuntimeMetadata::V13(self))
 	}
 }

frame/support/procedural/src/pallet/expand/storage.rs

@@ -18,6 +18,7 @@
 use crate::pallet::Def;
 use crate::pallet::parse::storage::{Metadata, QueryKind};
 use frame_support_procedural_tools::clean_type_string;
+use syn::spanned::Spanned;
 
 /// Generate the prefix_ident related the the storage.
 /// prefix_ident is used for the prefix struct to be given to storage as first generic param.
@@ -90,6 +91,9 @@ pub fn expand_storages(def: &mut Def) -> proc_macro2::TokenStream {
 				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 {
@@ -126,6 +130,31 @@ pub fn expand_storages(def: &mut Def) -> proc_macro2::TokenStream {
 							value: #frame_support::metadata::DecodeDifferent::Encode(#value),
 						}
 					)
+				},
+				Metadata::NMap { keys, hashers, value, .. } => {
+					let keys = keys
+						.iter()
+						.map(|key| clean_type_string(&quote::quote!(#key).to_string()))
+						.collect::<Vec<_>>();
+					let hashers = hashers
+						.iter()
+						.map(|hasher| syn::Ident::new(
+							&clean_type_string(&quote::quote!(#hasher).to_string()),
+							hasher.span(),
+						))
+						.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(&[
+								#( #frame_support::metadata::StorageHasher::#hashers, )*
+							]),
+							value: #frame_support::metadata::DecodeDifferent::Encode(#value),
+						}
+					)
 				}
 			};
 
@@ -227,6 +256,37 @@ pub fn expand_storages(def: &mut Def) -> proc_macro2::TokenStream {
 						}
 					)
 				},
+				Metadata::NMap { keys, keygen, value, .. } => {
+					let query = match storage.query_kind.as_ref().expect("Checked by def") {
+						QueryKind::OptionQuery => quote::quote_spanned!(storage.attr_span =>
+							Option<#value>
+						),
+						QueryKind::ValueQuery => quote::quote!(#value),
+					};
+					let key_arg = if keys.len() == 1 {
+						quote::quote!((key,))
+					} else {
+						quote::quote!(key)
+					};
+					quote::quote_spanned!(storage.attr_span =>
+						#(#cfg_attrs)*
+						impl<#type_impl_gen> #pallet_ident<#type_use_gen> #completed_where_clause {
+							#( #docs )*
+							pub fn #getter<KArg>(key: KArg) -> #query
+							where
+								KArg: #frame_support::codec::EncodeLike<
+									<#keygen as #frame_support::storage::types::KeyGenerator>::KArg
+								>
+									+ #frame_support::storage::types::TupleToEncodedIter,
+							{
+								<
+									#full_ident as
+									#frame_support::storage::StorageNMap<#keygen, #value>
+								>::get(#key_arg)
+							}
+						}
+					)
+				}
 			}
 		} else {
 			Default::default()

frame/support/procedural/src/pallet/parse/storage.rs

@@ -50,14 +50,20 @@ impl syn::parse::Parse for PalletStorageAttr {
 }
 
 /// The value and key types used by storages. Needed to expand metadata.
-pub enum Metadata{
+pub enum Metadata {
 	Value { value: syn::GenericArgument },
 	Map { value: syn::GenericArgument, key: syn::GenericArgument },
 	DoubleMap {
 		value: syn::GenericArgument,
 		key1: syn::GenericArgument,
 		key2: syn::GenericArgument
 	},
+	NMap {
+		keys: Vec<syn::Type>,
+		hashers: Vec<syn::Type>,
+		keygen: syn::GenericArgument,
+		value: syn::GenericArgument,
+	},
 }
 
 pub enum QueryKind {
@@ -115,6 +121,80 @@ fn retrieve_arg(
 	}
 }
 
+/// Parse the 2nd type argument to `StorageNMap` and return its keys and hashers.
+fn collect_keys_and_hashers(
+	keygen: &syn::GenericArgument,
+) -> syn::Result<(Vec<syn::Type>, Vec<syn::Type>)> {
+	if let syn::GenericArgument::Type(syn::Type::Tuple(tup)) = keygen {
+		tup
+			.elems
+			.iter()
+			.try_fold((vec![], vec![]), |mut acc, ty| {
+				let (key, hasher) = extract_key_and_hasher(ty)?;
+
+				acc.0.push(key);
+				acc.1.push(hasher);
+				Ok(acc)
+			})
+	} else if let syn::GenericArgument::Type(ty) = keygen {
+		let (key, hasher) = extract_key_and_hasher(ty)?;
+
+		Ok((vec![key], vec![hasher]))
+	} else {
+		let msg = format!("Invalid pallet::storage, expected tuple of Key structs or Key struct");
+		Err(syn::Error::new(keygen.span(), msg))
+	}
+}
+
+/// In `Key<H, K>`, extract H and K and return (K, H).
+fn extract_key_and_hasher(ty: &syn::Type) -> syn::Result<(syn::Type, syn::Type)> {
+	let typ = if let syn::Type::Path(typ) = ty {
+		typ
+	} else {
+		let msg = format!("Invalid pallet::storage, expected type path");
+		return Err(syn::Error::new(ty.span(), msg));
+	};
+
+	let key_struct = typ.path.segments.last().ok_or_else(|| {
+		let msg = format!("Invalid pallet::storage, expected type path with at least one segment");
+		syn::Error::new(typ.path.span(), msg)
+	})?;
+	if key_struct.ident != "Key" {
+		let msg = format!("Invalid pallet::storage, expected Key struct");
+		return Err(syn::Error::new(key_struct.ident.span(), msg));
+	}
+
+	let ty_params = if let syn::PathArguments::AngleBracketed(args) = &key_struct.arguments {
+		args
+	} else {
+		let msg = format!("Invalid pallet::storage, expected angle bracketed arguments");
+		return Err(syn::Error::new(key_struct.arguments.span(), msg));
+	};
+
+	if ty_params.args.len() != 2 {
+		let msg = format!("Invalid pallet::storage, unexpected number of generic arguments \
+			for Key struct, expected 2 args, found {}", ty_params.args.len());
+		return Err(syn::Error::new(ty_params.span(), msg));
+	}
+
+	let hasher = match &ty_params.args[0] {
+		syn::GenericArgument::Type(hasher_ty) => hasher_ty.clone(),
+		_ => {
+			let msg = format!("Invalid pallet::storage, expected type");
+			return Err(syn::Error::new(ty_params.args[0].span(), msg));
+		}
+	};
+	let key = match &ty_params.args[1] {
+		syn::GenericArgument::Type(key_ty) => key_ty.clone(),
+		_ => {
+			let msg = format!("Invalid pallet::storage, expected type");
+			return Err(syn::Error::new(ty_params.args[1].span(), msg));
+		}
+	};
+
+	Ok((key, hasher))
+}
+
 impl StorageDef {
 	pub fn try_from(
 		attr_span: proc_macro2::Span,
@@ -177,11 +257,22 @@ impl StorageDef {
 					value: retrieve_arg(&typ.path.segments[0], 5)?,
 				}
 			}
+			"StorageNMap" => {
+				query_kind = retrieve_arg(&typ.path.segments[0], 3);
+				let keygen = retrieve_arg(&typ.path.segments[0], 1)?;
+				let (keys, hashers) = collect_keys_and_hashers(&keygen)?;
+				Metadata::NMap {
+					keys,
+					hashers,
+					keygen,
+					value: retrieve_arg(&typ.path.segments[0], 2)?,
+				}
+			}
 			found => {
 				let msg = format!(
 					"Invalid pallet::storage, expected ident: `StorageValue` or \
-					`StorageMap` or `StorageDoubleMap` in order to expand metadata, found \
-					`{}`",
+					`StorageMap` or `StorageDoubleMap` or `StorageNMap` in order \
+					to expand metadata, found `{}`",
 					found,
 				);
 				return Err(syn::Error::new(item.ty.span(), msg));