Girazoki avoid statemine prefix breaking change

pallets/asset-manager/Cargo.toml

@@ -5,6 +5,7 @@ edition = "2018"
 version = "0.1.0"
 
 [dependencies]
+log = { version = "0.4", default-features = false }
 serde = { version = "1.0.124", optional = true }
 
 # Moonbeam
@@ -47,3 +48,4 @@ std = [
 runtime-benchmarks = [
 	"frame-benchmarking",
 ]
+try-runtime = [ "frame-support/try-runtime" ]

pallets/asset-manager/src/benchmarks.rs

@@ -41,9 +41,22 @@ benchmarks! {
 		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_id, 1)
+	}: _(RawOrigin::Root, asset_type.clone(), 1)
 	verify {
-		assert_eq!(Pallet::<T>::asset_id_units_per_second(asset_id), Some(1));
+		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 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_id, asset_type.clone())
+	verify {
+		assert_eq!(Pallet::<T>::asset_id_type(asset_id), Some(asset_type));
 	}
 }
 

pallets/asset-manager/src/lib.rs

@@ -21,20 +21,24 @@
 //! The main goal of this pallet is to allow moonbeam to register XCM assets
 //! The assumption is we work with AssetTypes, which can then be comperted to AssetIds
 //!
-//! This pallet has two storage items: AssetIdType, which holds a mapping from AssetId->AssetType
-//! AssetIdUnitsPerSecond: an AssetId->u128 mapping that holds how much each AssetId should be
-//! charged per unit of second, in the case such an Asset is received as a XCM asset.
+//! This pallet has three storage items: AssetIdType, which holds a mapping from AssetId->AssetType
+//! AssetTypeUnitsPerSecond: an AssetType->u128 mapping that holds how much each AssetType should be
+//! charged per unit of second, in the case such an Asset is received as a XCM asset. Finally,
+//! AssetTypeId holds a mapping from AssetType -> AssetId.
 //!
-//! This pallet has two extrinsics: register_asset, which registers an Asset in this pallet and
+//! This pallet has three extrinsics: register_asset, which registers an Asset in this pallet and
 //! creates the asset as dictated by the AssetRegistrar trait. set_asset_units_per_second: which
 //! sets the unit per second that should be charged for a particular asset.
+//! change_existing_asset_type: which allows to update the correspondence between AssetId and
+//! AssetType
 
 #![cfg_attr(not(feature = "std"), no_std)]
 
 use frame_support::pallet;
 pub use pallet::*;
 #[cfg(any(test, feature = "runtime-benchmarks"))]
 mod benchmarks;
+pub mod migrations;
 #[cfg(test)]
 pub mod mock;
 #[cfg(test)]
@@ -73,11 +77,15 @@ pub mod pallet {
 		fn get_asset_type(asset_id: T::AssetId) -> Option<T::AssetType> {
 			AssetIdType::<T>::get(asset_id)
 		}
+
+		fn get_asset_id(asset_type: T::AssetType) -> Option<T::AssetId> {
+			AssetTypeId::<T>::get(asset_type)
+		}
 	}
 
-	impl<T: Config> xcm_primitives::UnitsToWeightRatio<T::AssetId> for Pallet<T> {
-		fn get_units_per_second(asset_id: T::AssetId) -> Option<u128> {
-			AssetIdUnitsPerSecond::<T>::get(asset_id)
+	impl<T: Config> xcm_primitives::UnitsToWeightRatio<T::AssetType> for Pallet<T> {
+		fn get_units_per_second(asset_type: T::AssetType) -> Option<u128> {
+			AssetTypeUnitsPerSecond::<T>::get(asset_type)
 		}
 	}
 
@@ -118,19 +126,32 @@ pub mod pallet {
 	#[pallet::generate_deposit(pub(crate) fn deposit_event)]
 	pub enum Event<T: Config> {
 		AssetRegistered(T::AssetId, T::AssetType, T::AssetRegistrarMetadata),
-		UnitsPerSecondChanged(T::AssetId, u128),
+		UnitsPerSecondChanged(T::AssetType, u128),
+		AssetTypeChanged(T::AssetId, T::AssetType),
 	}
 
-	/// Stores the asset TYPE
+	/// Mapping from an asset id to asset type.
+	/// This is mostly used when receiving transaction specifying an asset directly,
+	/// like transferring an asset from this chain to another.
 	#[pallet::storage]
 	#[pallet::getter(fn asset_id_type)]
 	pub type AssetIdType<T: Config> = StorageMap<_, Blake2_128Concat, T::AssetId, T::AssetType>;
 
-	// Stores the units per second for local execution.
-	// Not all assets might contain units per second, hence the different storage
+	/// Reverse mapping of AssetIdType. Mapping from an asset type to an asset id.
+	/// This is mostly used when receiving a multilocation XCM message to retrieve
+	/// the corresponding asset in which tokens should me minted.
 	#[pallet::storage]
-	#[pallet::getter(fn asset_id_units_per_second)]
-	pub type AssetIdUnitsPerSecond<T: Config> = StorageMap<_, Blake2_128Concat, T::AssetId, u128>;
+	#[pallet::getter(fn asset_type_id)]
+	pub type AssetTypeId<T: Config> = StorageMap<_, Blake2_128Concat, T::AssetType, T::AssetId>;
+
+	/// Stores the units per second for local execution for a AssetType.
+	/// This is used to know how to charge for XCM execution in a particular
+	/// asset
+	/// Not all assets might contain units per second, hence the different storage
+	#[pallet::storage]
+	#[pallet::getter(fn asset_type_units_per_second)]
+	pub type AssetTypeUnitsPerSecond<T: Config> =
+		StorageMap<_, Blake2_128Concat, T::AssetType, u128>;
 
 	#[pallet::call]
 	impl<T: Config> Pallet<T> {
@@ -154,6 +175,7 @@ pub mod pallet {
 				.map_err(|_| Error::<T>::ErrorCreatingAsset)?;
 
 			AssetIdType::<T>::insert(&asset_id, &asset);
+			AssetTypeId::<T>::insert(&asset, &asset_id);
 
 			Self::deposit_event(Event::AssetRegistered(asset_id, asset, metadata));
 			Ok(())
@@ -163,19 +185,42 @@ pub mod pallet {
 		#[pallet::weight(T::WeightInfo::set_asset_units_per_second())]
 		pub fn set_asset_units_per_second(
 			origin: OriginFor<T>,
-			asset_id: T::AssetId,
+			asset_type: T::AssetType,
 			units_per_second: u128,
 		) -> DispatchResult {
 			T::AssetModifierOrigin::ensure_origin(origin)?;
 
 			ensure!(
-				AssetIdType::<T>::get(&asset_id).is_some(),
+				AssetTypeId::<T>::get(&asset_type).is_some(),
 				Error::<T>::AssetDoesNotExist
 			);
 
-			AssetIdUnitsPerSecond::<T>::insert(&asset_id, &units_per_second);
+			AssetTypeUnitsPerSecond::<T>::insert(&asset_type, &units_per_second);
+
+			Self::deposit_event(Event::UnitsPerSecondChanged(asset_type, units_per_second));
+			Ok(())
+		}
+
+		/// Change the xcm type mapping for a given assetId
+		#[pallet::weight(T::WeightInfo::set_asset_units_per_second())]
+		pub fn change_existing_asset_type(
+			origin: OriginFor<T>,
+			asset_id: T::AssetId,
+			new_asset_type: T::AssetType,
+		) -> DispatchResult {
+			T::AssetModifierOrigin::ensure_origin(origin)?;
+
+			let previous_asset_type =
+				AssetIdType::<T>::get(&asset_id).ok_or(Error::<T>::AssetDoesNotExist)?;
+
+			// Insert new asset type info
+			AssetIdType::<T>::insert(&asset_id, &new_asset_type);
+			AssetTypeId::<T>::insert(&new_asset_type, &asset_id);
+
+			// Remove previous asset type info
+			AssetTypeId::<T>::remove(&previous_asset_type);
 
-			Self::deposit_event(Event::UnitsPerSecondChanged(asset_id, units_per_second));
+			Self::deposit_event(Event::AssetTypeChanged(asset_id, new_asset_type));
 			Ok(())
 		}
 	}