Girazoki supported fee payment assets storage

pallets/asset-manager/src/benchmarks.rs

@@ -37,37 +37,73 @@ benchmarks! {
 	}
 
 	set_asset_units_per_second {
-		// does not really matter what we register
+		// We make it dependent on the number of existing assets already
+		let x in 5..100;
+		for i in 0..x {
+			let asset_type:  T::AssetType = MultiLocation::new(0, X1(GeneralIndex(i as u128))).into();
+			let metadata = T::AssetRegistrarMetadata::default();
+			let amount = 1u32.into();
+			Pallet::<T>::register_asset(RawOrigin::Root.into(), asset_type.clone(), metadata, amount, true)?;
+			Pallet::<T>::set_asset_units_per_second(RawOrigin::Root.into(), asset_type.clone(), 1, i)?;
+		}
+
+		// does not really matter what we register, as long as it is different than the previous
 		let asset_type = T::AssetType::default();
 		let metadata = T::AssetRegistrarMetadata::default();
 		let amount = 1u32.into();
 		let asset_id: T::AssetId = asset_type.clone().into();
 		Pallet::<T>::register_asset(RawOrigin::Root.into(), asset_type.clone(), metadata, amount, true)?;
 
-	}: _(RawOrigin::Root, asset_type.clone(), 1)
+	}: _(RawOrigin::Root, asset_type.clone(), 1, x)
 	verify {
+		assert!(Pallet::<T>::supported_fee_payment_assets().contains(&asset_type));
 		assert_eq!(Pallet::<T>::asset_type_units_per_second(asset_type), Some(1));
 	}
 
 	change_existing_asset_type {
-		// does not really matter what we register
-		let asset_type = T::AssetType::default();
-		let new_asset_type: T::AssetType = MultiLocation::new(
+		// We make it dependent on the number of existing assets already
+		let x in 5..100;
+		for i in 0..x {
+			let asset_type:  T::AssetType = MultiLocation::new(0, X1(GeneralIndex(i as u128))).into();
+			let metadata = T::AssetRegistrarMetadata::default();
+			let amount = 1u32.into();
+			Pallet::<T>::register_asset(RawOrigin::Root.into(), asset_type.clone(), metadata, amount, true)?;
+			Pallet::<T>::set_asset_units_per_second(RawOrigin::Root.into(), asset_type.clone(), 1, i)?;
+		}
+
+		let new_asset_type = T::AssetType::default();
+		let asset_type_to_be_changed: T::AssetType = MultiLocation::new(
 			0,
-			X1(GeneralIndex(0))
+			X1(GeneralIndex((x-1) as u128))
 		).into();
+		let asset_id_to_be_changed = asset_type_to_be_changed.into();
 
-		let metadata = T::AssetRegistrarMetadata::default();
-		let amount = 1u32.into();
-		let asset_id: T::AssetId = asset_type.clone().into();
-		Pallet::<T>::register_asset(RawOrigin::Root.into(), asset_type.clone(), metadata, amount, true)?;
-		// Worst case: we also set assets units per second
-		Pallet::<T>::set_asset_units_per_second(RawOrigin::Root.into(), asset_type.clone(), 1)?;
-
-	}: _(RawOrigin::Root, asset_id, new_asset_type.clone())
+	}: _(RawOrigin::Root, asset_id_to_be_changed, new_asset_type.clone(), x)
 	verify {
-		assert_eq!(Pallet::<T>::asset_id_type(asset_id), Some(new_asset_type.clone()));
+		assert_eq!(Pallet::<T>::asset_id_type(asset_id_to_be_changed), Some(new_asset_type.clone()));
 		assert_eq!(Pallet::<T>::asset_type_units_per_second(&new_asset_type), Some(1));
+		assert!(Pallet::<T>::supported_fee_payment_assets().contains(&new_asset_type));
+	}
+
+	remove_supported_asset {
+		// We make it dependent on the number of existing assets already
+		let x in 5..100;
+		for i in 0..x {
+			let asset_type:  T::AssetType = MultiLocation::new(0, X1(GeneralIndex(i as u128))).into();
+			let metadata = T::AssetRegistrarMetadata::default();
+			let amount = 1u32.into();
+			Pallet::<T>::register_asset(RawOrigin::Root.into(), asset_type.clone(), metadata, amount, true)?;
+			Pallet::<T>::set_asset_units_per_second(RawOrigin::Root.into(), asset_type.clone(), 1, i)?;
+		}
+		let asset_type_to_be_removed: T::AssetType = MultiLocation::new(
+			0,
+			X1(GeneralIndex((x-1) as u128))
+		).into();
+		// We try to remove the last asset type
+	}: _(RawOrigin::Root, asset_type_to_be_removed.clone(), x)
+	verify {
+		assert!(!Pallet::<T>::supported_fee_payment_assets().contains(&asset_type_to_be_removed));
+		assert_eq!(Pallet::<T>::asset_type_units_per_second(asset_type_to_be_removed), None);
 	}
 }
 

pallets/asset-manager/src/lib.rs

@@ -53,6 +53,7 @@ pub mod pallet {
 	use frame_system::pallet_prelude::*;
 	use parity_scale_codec::HasCompact;
 	use sp_runtime::traits::{AccountIdConversion, AtLeast32BitUnsigned};
+	use sp_std::vec::Vec;
 
 	#[pallet::pallet]
 	#[pallet::without_storage_info]
@@ -85,6 +86,9 @@ pub mod pallet {
 	}
 
 	impl<T: Config> xcm_primitives::UnitsToWeightRatio<T::AssetType> for Pallet<T> {
+		fn payment_is_supported(asset_type: T::AssetType) -> bool {
+			SupportedFeePaymentAssets::<T>::get().contains(&asset_type)
+		}
 		fn get_units_per_second(asset_type: T::AssetType) -> Option<u128> {
 			AssetTypeUnitsPerSecond::<T>::get(asset_type)
 		}
@@ -121,6 +125,7 @@ pub mod pallet {
 		ErrorCreatingAsset,
 		AssetAlreadyExists,
 		AssetDoesNotExist,
+		TooLowNumAssetsWeightHint,
 	}
 
 	#[pallet::event]
@@ -129,6 +134,7 @@ pub mod pallet {
 		AssetRegistered(T::AssetId, T::AssetType, T::AssetRegistrarMetadata),
 		UnitsPerSecondChanged(T::AssetType, u128),
 		AssetTypeChanged(T::AssetId, T::AssetType),
+		SupportedAssetRemoved(T::AssetType),
 	}
 
 	/// Mapping from an asset id to asset type.
@@ -154,6 +160,11 @@ pub mod pallet {
 	pub type AssetTypeUnitsPerSecond<T: Config> =
 		StorageMap<_, Blake2_128Concat, T::AssetType, u128>;
 
+	// Supported fee asset payments
+	#[pallet::storage]
+	#[pallet::getter(fn supported_fee_payment_assets)]
+	pub type SupportedFeePaymentAssets<T: Config> = StorageValue<_, Vec<T::AssetType>, ValueQuery>;
+
 	#[pallet::call]
 	impl<T: Config> Pallet<T> {
 		/// Register new asset with the asset manager
@@ -182,12 +193,13 @@ pub mod pallet {
 			Ok(())
 		}
 
-		/// Change the amount of units we are charging per execution second for a given AssetId
-		#[pallet::weight(T::WeightInfo::set_asset_units_per_second())]
+		/// Change the amount of units we are charging per execution second for a given AssetType
+		#[pallet::weight(T::WeightInfo::set_asset_units_per_second(*num_assets_weight_hint))]
 		pub fn set_asset_units_per_second(
 			origin: OriginFor<T>,
 			asset_type: T::AssetType,
 			units_per_second: u128,
+			num_assets_weight_hint: u32,
 		) -> DispatchResult {
 			T::AssetModifierOrigin::ensure_origin(origin)?;
 
@@ -196,6 +208,20 @@ pub mod pallet {
 				Error::<T>::AssetDoesNotExist
 			);
 
+			// Grab supported assets
+			let mut supported_assets = SupportedFeePaymentAssets::<T>::get();
+
+			ensure!(
+				num_assets_weight_hint >= (supported_assets.len() as u32),
+				Error::<T>::TooLowNumAssetsWeightHint
+			);
+
+			// If not in our supported asset list, then put it
+			if !supported_assets.contains(&asset_type) {
+				supported_assets.push(asset_type.clone());
+				SupportedFeePaymentAssets::<T>::put(supported_assets);
+			}
+
 			AssetTypeUnitsPerSecond::<T>::insert(&asset_type, &units_per_second);
 
 			Self::deposit_event(Event::UnitsPerSecondChanged(asset_type, units_per_second));
@@ -205,14 +231,23 @@ pub mod pallet {
 		/// Change the xcm type mapping for a given assetId
 		/// We also change this if the previous units per second where pointing at the old
 		/// assetType
-		#[pallet::weight(T::WeightInfo::change_existing_asset_type())]
+		#[pallet::weight(T::WeightInfo::change_existing_asset_type(*num_assets_weight_hint))]
 		pub fn change_existing_asset_type(
 			origin: OriginFor<T>,
 			asset_id: T::AssetId,
 			new_asset_type: T::AssetType,
+			num_assets_weight_hint: u32,
 		) -> DispatchResult {
 			T::AssetModifierOrigin::ensure_origin(origin)?;
 
+			// Grab supported assets
+			let mut supported_assets = SupportedFeePaymentAssets::<T>::get();
+
+			ensure!(
+				num_assets_weight_hint >= (supported_assets.len() as u32),
+				Error::<T>::TooLowNumAssetsWeightHint
+			);
+
 			let previous_asset_type =
 				AssetIdType::<T>::get(&asset_id).ok_or(Error::<T>::AssetDoesNotExist)?;
 
@@ -223,7 +258,33 @@ pub mod pallet {
 			// Remove previous asset type info
 			AssetTypeId::<T>::remove(&previous_asset_type);
 
+			// Change AssetTypeUnitsPerSecond
 			if let Some(units) = AssetTypeUnitsPerSecond::<T>::get(&previous_asset_type) {
+				// If the old exists in supported assts (it should), remove it
+				if let Some(index) =
+					supported_assets
+						.iter()
+						.enumerate()
+						.find_map(|(index, asset)| {
+							if previous_asset_type == asset.clone() {
+								Some(index)
+							} else {
+								None
+							}
+						}) {
+					// Remove
+					supported_assets.remove(index);
+				}
+
+				// If new is not in supported assets, push it
+				if !supported_assets.contains(&new_asset_type) {
+					// Push the new one
+					supported_assets.push(new_asset_type.clone());
+				}
+
+				// Insert supported fee payment assets
+				SupportedFeePaymentAssets::<T>::put(supported_assets);
+
 				// Remove previous asset type info
 				AssetTypeUnitsPerSecond::<T>::remove(&previous_asset_type);
 				AssetTypeUnitsPerSecond::<T>::insert(&new_asset_type, units);
@@ -232,6 +293,47 @@ pub mod pallet {
 			Self::deposit_event(Event::AssetTypeChanged(asset_id, new_asset_type));
 			Ok(())
 		}
+
+		/// Remove a given assetType from the supported assets for fee payment
+		#[pallet::weight(T::WeightInfo::remove_supported_asset(*num_assets_weight_hint))]
+		pub fn remove_supported_asset(
+			origin: OriginFor<T>,
+			asset_type: T::AssetType,
+			num_assets_weight_hint: u32,
+		) -> DispatchResult {
+			T::AssetModifierOrigin::ensure_origin(origin)?;
+
+			// Grab supported assets
+			let mut supported_assets = SupportedFeePaymentAssets::<T>::get();
+
+			ensure!(
+				num_assets_weight_hint >= (supported_assets.len() as u32),
+				Error::<T>::TooLowNumAssetsWeightHint
+			);
+			let index = supported_assets
+				.iter()
+				.enumerate()
+				.find_map(|(index, asset)| {
+					if asset_type == asset.clone() {
+						Some(index)
+					} else {
+						None
+					}
+				})
+				.ok_or(Error::<T>::AssetDoesNotExist)?;
+
+			// Remove
+			supported_assets.remove(index);
+
+			// Insert
+			SupportedFeePaymentAssets::<T>::put(supported_assets);
+
+			// Remove
+			AssetTypeUnitsPerSecond::<T>::remove(&asset_type);
+
+			Self::deposit_event(Event::SupportedAssetRemoved(asset_type));
+			Ok(())
+		}
 	}
 
 	impl<T: Config> Pallet<T> {