Add migration for ForeignAssetCreator

Author: ParthDesai

Cargo.lock

@@ -27,8 +27,8 @@ use {
     },
     pallet_migrations::{GetMigrations, Migration},
     runtime_common::migrations::{
-        PolkadotXcmMigrationFixVersion, XcmpQueueMigrationFixVersion, XcmpQueueMigrationV3,
-        XcmpQueueMigrationV4,
+        ForeignAssetCreatorMigration, PolkadotXcmMigrationFixVersion, XcmpQueueMigrationFixVersion,
+        XcmpQueueMigrationV3, XcmpQueueMigrationV4,
     },
     sp_std::{marker::PhantomData, prelude::*},
 };
@@ -71,6 +71,9 @@ where
     Runtime: cumulus_pallet_xcmp_queue::Config,
     Runtime: pallet_xcm_executor_utils::Config,
     Runtime: pallet_xcm::Config,
+    Runtime: pallet_foreign_asset_creator::Config,
+    <Runtime as pallet_foreign_asset_creator::Config>::ForeignAsset:
+        TryFrom<staging_xcm::v3::MultiLocation>,
 {
     fn get_migrations() -> Vec<Box<dyn Migration>> {
         let migrate_polkadot_xcm_v1 =

container-chains/runtime-templates/simple/src/migrations.rs

@@ -14,12 +14,14 @@ workspace = true
 
 [dependencies]
 hex-literal = { workspace = true }
+log = { workspace = true }
 parity-scale-codec = { workspace = true, features = [ "derive" ] }
 scale-info = { workspace = true, features = [ "derive" ] }
 
 # Own
 pallet-configuration = { workspace = true }
 pallet-data-preservers = { workspace = true }
+pallet-foreign-asset-creator = { workspace = true }
 pallet-invulnerables = { workspace = true }
 pallet-pooled-staking = { workspace = true }
 pallet-registrar = { workspace = true }
@@ -41,6 +43,7 @@ cumulus-pallet-xcmp-queue = { workspace = true }
 
 # Polkadot
 pallet-xcm = { workspace = true }
+staging-xcm = { workspace = true }
 
 sp-core = { workspace = true }
 sp-runtime = { workspace = true }
@@ -59,9 +62,11 @@ std = [
 	"frame-support/std",
 	"frame-system/std",
 	"frame-try-runtime?/std",
+	"log/std",
 	"pallet-balances/std",
 	"pallet-configuration/std",
 	"pallet-data-preservers/std",
+	"pallet-foreign-asset-creator/std",
 	"pallet-invulnerables/std",
 	"pallet-migrations/std",
 	"pallet-pooled-staking/std",
@@ -74,6 +79,7 @@ std = [
 	"sp-core/std",
 	"sp-runtime/std",
 	"sp-std/std",
+	"staging-xcm/std",
 ]
 
 runtime-benchmarks = [
@@ -84,6 +90,7 @@ runtime-benchmarks = [
 	"pallet-balances/runtime-benchmarks",
 	"pallet-configuration/runtime-benchmarks",
 	"pallet-data-preservers/runtime-benchmarks",
+	"pallet-foreign-asset-creator/runtime-benchmarks",
 	"pallet-invulnerables/runtime-benchmarks",
 	"pallet-migrations/runtime-benchmarks",
 	"pallet-pooled-staking/runtime-benchmarks",
@@ -102,6 +109,7 @@ try-runtime = [
 	"pallet-balances/try-runtime",
 	"pallet-configuration/try-runtime",
 	"pallet-data-preservers/try-runtime",
+	"pallet-foreign-asset-creator/try-runtime",
 	"pallet-invulnerables/try-runtime",
 	"pallet-migrations/try-runtime",
 	"pallet-pooled-staking/try-runtime",

runtime/common/Cargo.toml

@@ -36,15 +36,19 @@
 
 #[cfg(feature = "try-runtime")]
 use frame_support::ensure;
+use frame_support::migration::storage_key_iter;
 
 use {
     cumulus_primitives_core::ParaId,
     frame_support::{
         pallet_prelude::GetStorageVersion,
         traits::{OnRuntimeUpgrade, PalletInfoAccess, StorageVersion},
         weights::Weight,
+        StoragePrefixedMap,
     },
     pallet_configuration::{weights::WeightInfo as _, HostConfiguration},
+    pallet_foreign_asset_creator::AssetId,
+    pallet_foreign_asset_creator::{AssetIdToForeignAsset, ForeignAssetToAssetId},
     pallet_migrations::{GetMigrations, Migration},
     sp_core::Get,
     sp_std::{collections::btree_set::BTreeSet, marker::PhantomData, prelude::*},
@@ -516,6 +520,9 @@ where
     Runtime: pallet_xcm::Config,
     <Runtime as pallet_balances::Config>::RuntimeHoldReason:
         From<pallet_pooled_staking::HoldReason>,
+    Runtime: pallet_foreign_asset_creator::Config,
+    <Runtime as pallet_foreign_asset_creator::Config>::ForeignAsset:
+        TryFrom<staging_xcm::v3::MultiLocation>,
 {
     fn get_migrations() -> Vec<Box<dyn Migration>> {
         // let migrate_invulnerables = MigrateInvulnerables::<Runtime>(Default::default());
@@ -540,6 +547,8 @@ where
             RegistrarParaManagerMigration::<Runtime>(Default::default());
 
         let migrate_pallet_xcm_v4 = MigrateToLatestXcmVersion::<Runtime>(Default::default());
+        let foreign_asset_creator_migration =
+            ForeignAssetCreatorMigration::<Runtime>(Default::default());
 
         vec![
             // Applied in runtime 200
@@ -564,6 +573,105 @@ where
             Box::new(migrate_registrar_pending_verification),
             Box::new(migrate_registrar_manager),
             Box::new(migrate_pallet_xcm_v4),
+            Box::new(foreign_asset_creator_migration),
         ]
     }
 }
+
+pub struct ForeignAssetCreatorMigration<Runtime>(PhantomData<Runtime>);
+
+impl<Runtime> Migration for ForeignAssetCreatorMigration<Runtime>
+where
+    Runtime: pallet_foreign_asset_creator::Config,
+    <Runtime as pallet_foreign_asset_creator::Config>::ForeignAsset:
+        TryFrom<staging_xcm::v3::MultiLocation>,
+{
+    fn friendly_name(&self) -> &str {
+        "TM_ForeignAssetCreatorMigration"
+    }
+
+    fn migrate(&self, _available_weight: Weight) -> Weight {
+        use frame_support::pallet_prelude::*;
+
+        use staging_xcm::v3::MultiLocation as OldLocation;
+
+        let pallet_prefix = AssetIdToForeignAsset::<Runtime>::pallet_prefix();
+        let asset_id_to_foreign_asset_storage_prefix =
+            AssetIdToForeignAsset::<Runtime>::storage_prefix();
+        let foreign_asset_to_asset_id_prefix = ForeignAssetToAssetId::<Runtime>::storage_prefix();
+
+        // Data required to migrate ForeignAsset values
+        // Read all the data into memory.
+        let asset_id_to_foreign_asset_data: Vec<_> =
+            storage_key_iter::<AssetId<Runtime>, OldLocation, Blake2_128Concat>(
+                pallet_prefix,
+                asset_id_to_foreign_asset_storage_prefix,
+            )
+            .drain()
+            .collect();
+
+        // Data required to migrate ForeignAsset keys
+        let foreign_asset_to_asset_id_data: Vec<_> =
+            storage_key_iter::<OldLocation, AssetId<Runtime>, Blake2_128Concat>(
+                pallet_prefix,
+                foreign_asset_to_asset_id_prefix,
+            )
+            .drain()
+            .collect();
+
+        let foreign_asset_to_asset_id_count = foreign_asset_to_asset_id_data.len();
+
+        let migrated_count = asset_id_to_foreign_asset_data
+            .len()
+            .saturating_add(foreign_asset_to_asset_id_data.len());
+
+        log::info!("Migrating {:?} elements", migrated_count);
+
+        // Removing older entries with old location as key
+        let mut removal_result = storage::unhashed::clear_prefix(
+            &ForeignAssetToAssetId::<Runtime>::final_prefix(),
+            None,
+            None,
+        );
+        while removal_result.maybe_cursor.is_some() {
+            removal_result = storage::unhashed::clear_prefix(
+                &ForeignAssetToAssetId::<Runtime>::final_prefix(),
+                None,
+                removal_result.maybe_cursor.as_deref(),
+            );
+        }
+
+        // Write to the new storage with removed and added fields
+        for (asset_id, old_location) in asset_id_to_foreign_asset_data {
+            if let Ok(new_location) = Runtime::ForeignAsset::try_from(old_location) {
+                AssetIdToForeignAsset::<Runtime>::insert(asset_id, new_location);
+            } else {
+                log::warn!("Location could not be converted safely to xcmV4")
+            }
+        }
+
+        for (old_location, asset_id) in foreign_asset_to_asset_id_data {
+            if let Ok(new_location) = Runtime::ForeignAsset::try_from(old_location) {
+                ForeignAssetToAssetId::<Runtime>::insert(new_location, asset_id);
+            } else {
+                log::warn!("Location could not be converted safely to xcmV4")
+            }
+        }
+
+        // One db read and one db write per element, plus the on-chain storage
+        Runtime::DbWeight::get()
+            .reads(migrated_count as u64)
+            .saturating_add(Runtime::DbWeight::get().writes(migrated_count as u64 + 3u64))
+            .saturating_add(Runtime::DbWeight::get().writes(foreign_asset_to_asset_id_count as u64))
+    }
+
+    #[cfg(feature = "try-runtime")]
+    fn pre_upgrade(&self) -> Result<Vec<u8>, DispatchError> {
+        Ok(vec![])
+    }
+
+    #[cfg(feature = "try-runtime")]
+    fn post_upgrade(&self, _state: Vec<u8>) -> Result<(), DispatchError> {
+        Ok(())
+    }
+}