// Copyright (C) Moondance Labs Ltd.

// This file is part of Tanssi.

// Tanssi is free software: you can redistribute it and/or modify

// it under the terms of the GNU General Public License as published by

// the Free Software Foundation, either version 3 of the License, or

// (at your option) any later version.

// Tanssi is distributed in the hope that it will be useful,

// but WITHOUT ANY WARRANTY; without even the implied warranty of

// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

// GNU General Public License for more details.

// You should have received a copy of the GNU General Public License

// along with Tanssi.  If not, see <http://www.gnu.org/licenses/>

// Copyright (C) Moondance Labs Ltd.

// This file is part of Tanssi.

// Tanssi is free software: you can redistribute it and/or modify

// it under the terms of the GNU General Public License as published by

// the Free Software Foundation, either version 3 of the License, or

// (at your option) any later version.

// Tanssi is distributed in the hope that it will be useful,

// but WITHOUT ANY WARRANTY; without even the implied warranty of

// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

// GNU General Public License for more details.

// You should have received a copy of the GNU General Public License

// along with Tanssi.  If not, see <http://www.gnu.org/licenses/>

//! # Migrations

//!

//! This module acts as a registry where each migration is defined. Each migration should implement

//! the "Migration" trait declared in the pallet-migrations crate.

extern crate alloc;

use {

    cumulus_primitives_core::ParaId,

    frame_support::{

        migration::{clear_storage_prefix, move_pallet, storage_key_iter},

        pallet_prelude::GetStorageVersion,

        parameter_types,

        traits::{

            fungible::MutateHold, OnRuntimeUpgrade, PalletInfoAccess, ReservableCurrency,

            StorageVersion,

        },

        weights::Weight,

        Blake2_128Concat, BoundedVec, StoragePrefixedMap,

    },

    pallet_configuration::{weights::WeightInfo as _, HostConfiguration},

    pallet_foreign_asset_creator::{AssetId, AssetIdToForeignAsset, ForeignAssetToAssetId},

    pallet_migrations::{GetMigrations, Migration},

    pallet_registrar::HoldReason,

    sp_core::Get,

    sp_runtime::Perbill,

    sp_std::{collections::btree_set::BTreeSet, marker::PhantomData, prelude::*},

};

#[cfg(feature = "try-runtime")]

use {frame_support::ensure, parity_scale_codec::DecodeAll};

#[derive(

    Default,

    Clone,

    parity_scale_codec::Encode,

    parity_scale_codec::Decode,

    PartialEq,

)]

pub struct HostConfigurationV3 {

    pub max_collators: u32,

    pub min_orchestrator_collators: u32,

    pub max_orchestrator_collators: u32,

    pub collators_per_container: u32,

    pub full_rotation_period: u32,

    pub collators_per_parathread: u32,

    pub parathreads_per_collator: u32,

    pub target_container_chain_fullness: Perbill,

    pub max_parachain_cores_percentage: Option<Perbill>,

}

pub struct MigrateConfigurationAddFullRotationMode<T>(pub PhantomData<T>);

impl<T> Migration for MigrateConfigurationAddFullRotationMode<T>

where

    T: pallet_configuration::Config,

{

    /// Run a standard pre-runtime test. This works the same way as in a normal runtime upgrade.

    #[cfg(feature = "try-runtime")]

    fn pre_upgrade(&self) -> Result<Vec<u8>, sp_runtime::DispatchError> {

        log::info!(

            "hashed key {:?}",

            pallet_configuration::ActiveConfig::<T>::hashed_key()

        );

        let old_config_bytes = frame_support::storage::unhashed::get_raw(

            &pallet_configuration::ActiveConfig::<T>::hashed_key(),

        )

        .unwrap();

        let old_config: Result<HostConfigurationV3, _> =

            DecodeAll::decode_all(&mut old_config_bytes.as_ref());

        let new_config: Result<HostConfiguration, _> =

            DecodeAll::decode_all(&mut old_config_bytes.as_ref());

        assert!(old_config.is_ok());

        assert!(new_config.is_err());

        Ok(vec![])

    }

    /// Run a standard post-runtime test. This works the same way as in a normal runtime upgrade.

    #[cfg(feature = "try-runtime")]

    fn post_upgrade(

        &self,

        _number_of_invulnerables: Vec<u8>,

    ) -> Result<(), sp_runtime::DispatchError> {

        let new_config_bytes = frame_support::storage::unhashed::get_raw(

            &pallet_configuration::ActiveConfig::<T>::hashed_key(),

        )

        .unwrap();

        let old_config: Result<HostConfigurationV3, _> =

            DecodeAll::decode_all(&mut new_config_bytes.as_ref());

        let new_config: Result<HostConfiguration, _> =

            DecodeAll::decode_all(&mut new_config_bytes.as_ref());

        assert!(old_config.is_err());

        assert!(new_config.is_ok());

        let new_config = pallet_configuration::Pallet::<T>::config();

        let default_config = HostConfiguration::default();

        assert_eq!(

            new_config.full_rotation_mode,

            default_config.full_rotation_mode

        );

        Ok(())

    }

}

pub struct MigrateServicesPaymentAddCollatorAssignmentCredits<T>(pub PhantomData<T>);

impl<T> Migration for MigrateServicesPaymentAddCollatorAssignmentCredits<T>

where

    T: pallet_services_payment::Config + pallet_registrar::Config,

{

    /// Run a standard pre-runtime test. This works the same way as in a normal runtime upgrade.

    #[cfg(feature = "try-runtime")]

    fn pre_upgrade(&self) -> Result<Vec<u8>, sp_runtime::DispatchError> {

        let mut para_ids = BTreeSet::new();

        let active = pallet_registrar::RegisteredParaIds::<T>::get();

        let pending = pallet_registrar::PendingParaIds::<T>::get();

        let paused = pallet_registrar::Paused::<T>::get();

        para_ids.extend(active);

        para_ids.extend(pending.into_iter().flat_map(|(_session, active)| active));

        para_ids.extend(paused);

        for para_id in para_ids {

            assert!(

                pallet_services_payment::CollatorAssignmentCredits::<T>::get(para_id).is_none()

            );

        }

        Ok(vec![])

    }

    // Run a standard post-runtime test. This works the same way as in a normal runtime upgrade.

    #[cfg(feature = "try-runtime")]

    fn post_upgrade(&self, _result: Vec<u8>) -> Result<(), sp_runtime::DispatchError> {

        let mut para_ids = BTreeSet::new();

        let active = pallet_registrar::RegisteredParaIds::<T>::get();

        let pending = pallet_registrar::PendingParaIds::<T>::get();

        let paused = pallet_registrar::Paused::<T>::get();

        para_ids.extend(active);

        para_ids.extend(pending.into_iter().flat_map(|(_session, active)| active));

        para_ids.extend(paused);

        for para_id in para_ids {

            assert_eq!(

                pallet_services_payment::CollatorAssignmentCredits::<T>::get(para_id),

                Some(T::FreeCollatorAssignmentCredits::get())

            );

        }

        Ok(())

    }

}

pub struct PolkadotXcmMigrationFixVersion<T, PolkadotXcm>(pub PhantomData<(T, PolkadotXcm)>);

impl<T, PolkadotXcm> Migration for PolkadotXcmMigrationFixVersion<T, PolkadotXcm>

where

    PolkadotXcm: GetStorageVersion + PalletInfoAccess,

    T: cumulus_pallet_xcmp_queue::Config,

{

    #[cfg(feature = "try-runtime")]

    fn pre_upgrade(&self) -> Result<Vec<u8>, sp_runtime::DispatchError> {

        ensure!(

            <PolkadotXcm as GetStorageVersion>::on_chain_storage_version() == 0,

            "PolkadotXcm storage version should be 0"

        );

        Ok(vec![])

    }

    // Run a standard post-runtime test. This works the same way as in a normal runtime upgrade.

    #[cfg(feature = "try-runtime")]

    fn post_upgrade(&self, _state: Vec<u8>) -> Result<(), sp_runtime::DispatchError> {

        ensure!(

            <PolkadotXcm as GetStorageVersion>::on_chain_storage_version() == 1,

            "PolkadotXcm storage version should be 1"

        );

        Ok(())

    }

}

pub struct XcmpQueueMigrationFixVersion<T, XcmpQueue>(pub PhantomData<(T, XcmpQueue)>);

impl<T, XcmpQueue> Migration for XcmpQueueMigrationFixVersion<T, XcmpQueue>

where

    XcmpQueue: GetStorageVersion + PalletInfoAccess,

    T: cumulus_pallet_xcmp_queue::Config,

{

    #[cfg(feature = "try-runtime")]

    fn pre_upgrade(&self) -> Result<Vec<u8>, sp_runtime::DispatchError> {

        ensure!(

            <XcmpQueue as GetStorageVersion>::on_chain_storage_version() == 0,

            "XcmpQueue storage version should be 0"

        );

        Ok(vec![])

    }

    // Run a standard post-runtime test. This works the same way as in a normal runtime upgrade.

    #[cfg(feature = "try-runtime")]

    fn post_upgrade(&self, _state: Vec<u8>) -> Result<(), sp_runtime::DispatchError> {

        // Greater than because the post_upgrade is run after all the migrations, so

        // it can be greater if the following XcmpQueue migrations are applied in the

        // same runtime

        ensure!(

            <XcmpQueue as GetStorageVersion>::on_chain_storage_version() >= 2,

            "XcmpQueue storage version should be at least 2"

        );

        Ok(())

    }

}

pub struct XcmpQueueMigrationV3<T>(pub PhantomData<T>);

impl<T> Migration for XcmpQueueMigrationV3<T>

where

    T: cumulus_pallet_xcmp_queue::Config,

{

    // #[cfg(feature = "try-runtime")]

    // let mut pre_upgrade_result: Vec<u8>;

    #[cfg(feature = "try-runtime")]

    fn pre_upgrade(&self) -> Result<Vec<u8>, sp_runtime::DispatchError> {

        cumulus_pallet_xcmp_queue::migration::v3::MigrationToV3::<T>::pre_upgrade()

    }

    // Run a standard post-runtime test. This works the same way as in a normal runtime upgrade.

    #[cfg(feature = "try-runtime")]

    fn post_upgrade(&self, state: Vec<u8>) -> Result<(), sp_runtime::DispatchError> {

        cumulus_pallet_xcmp_queue::migration::v3::MigrationToV3::<T>::post_upgrade(state)

    }

}

pub struct XcmpQueueMigrationV4<T>(pub PhantomData<T>);

impl<T> Migration for XcmpQueueMigrationV4<T>

where

    T: cumulus_pallet_xcmp_queue::Config,

{

    #[cfg(feature = "try-runtime")]

    fn pre_upgrade(&self) -> Result<Vec<u8>, sp_runtime::DispatchError> {

        cumulus_pallet_xcmp_queue::migration::v4::MigrationToV4::<T>::pre_upgrade()

    }

    // Run a standard post-runtime test. This works the same way as in a normal runtime upgrade.

    #[cfg(feature = "try-runtime")]

    fn post_upgrade(&self, state: Vec<u8>) -> Result<(), sp_runtime::DispatchError> {

        cumulus_pallet_xcmp_queue::migration::v4::MigrationToV4::<T>::post_upgrade(state)

    }

}

pub struct RegistrarPendingVerificationValueToMap<T>(pub PhantomData<T>);

impl<T> Migration for RegistrarPendingVerificationValueToMap<T>

where

    T: pallet_registrar::Config,

{

    #[cfg(feature = "try-runtime")]

    fn pre_upgrade(&self) -> Result<Vec<u8>, sp_runtime::DispatchError> {

        Ok(vec![])

    }

    // Run a standard post-runtime test. This works the same way as in a normal runtime upgrade.

    #[cfg(feature = "try-runtime")]

    fn post_upgrade(&self, _state: Vec<u8>) -> Result<(), sp_runtime::DispatchError> {

        Ok(())

    }

}

pub struct RegistrarParaManagerMigration<T>(pub PhantomData<T>);

impl<T> Migration for RegistrarParaManagerMigration<T>

where

    T: pallet_registrar::Config,

{

    #[cfg(feature = "try-runtime")]

    fn pre_upgrade(&self) -> Result<Vec<u8>, sp_runtime::DispatchError> {

        Ok(vec![])

    }

    #[cfg(feature = "try-runtime")]

    fn post_upgrade(&self, _state: Vec<u8>) -> Result<(), sp_runtime::DispatchError> {

        Ok(())

    }

}

pub struct RegistrarReserveToHoldMigration<T>(pub PhantomData<T>);

impl<T> Migration for RegistrarReserveToHoldMigration<T>

where

    T: pallet_registrar::Config,

    T: pallet_balances::Config,

    <T as pallet_balances::Config>::RuntimeHoldReason: From<pallet_registrar::HoldReason>,

    <T as pallet_balances::Config>::Balance: From<

        <<T as pallet_registrar::Config>::Currency as frame_support::traits::fungible::Inspect<

            T::AccountId,

        >>::Balance,

    >,

    <T as pallet_balances::Config>::Balance: From<u128>,

{

    #[cfg(feature = "try-runtime")]

    fn pre_upgrade(&self) -> Result<Vec<u8>, sp_runtime::DispatchError> {

        use frame_support::traits::fungible::InspectHold;

        for (_para_id, deposit) in pallet_registrar::RegistrarDeposit::<T>::iter() {

            ensure!(

                pallet_balances::Pallet::<T>::reserved_balance(&deposit.creator)

                    >= deposit.deposit.into(),

                "Reserved balanced cannot be less than deposit amount"

            );

            ensure!(

                pallet_balances::Pallet::<T>::balance_on_hold(

                    &HoldReason::RegistrarDeposit.into(),

                    &deposit.creator

                ) == 0u128.into(),

                "Balance on hold for RegistrarDeposit should be 0"

            );

        }

        Ok(vec![])

    }

    #[cfg(feature = "try-runtime")]

    fn post_upgrade(&self, _state: Vec<u8>) -> Result<(), sp_runtime::DispatchError> {

        use frame_support::traits::fungible::InspectHold;

        for (_para_id, deposit) in pallet_registrar::RegistrarDeposit::<T>::iter() {

            ensure!(

                pallet_balances::Pallet::<T>::balance_on_hold(

                    &HoldReason::RegistrarDeposit.into(),

                    &deposit.creator

                ) >= deposit.deposit.into(),

                "Balance on hold for RegistrarDeposit should be deposit"

            );

        }

        Ok(())

    }

}

pub struct MigrateSnowbridgeFeePerGasMigrationV0ToV1<T>(PhantomData<T>);

impl<T> Migration for MigrateSnowbridgeFeePerGasMigrationV0ToV1<T>

where

    T: snowbridge_pallet_system::Config,

{

    #[cfg(feature = "try-runtime")]

    fn pre_upgrade(&self) -> Result<Vec<u8>, sp_runtime::DispatchError> {

        snowbridge_pallet_system::migration::FeePerGasMigrationV0ToV1::<T>::pre_upgrade()

    }

    #[cfg(feature = "try-runtime")]

    fn post_upgrade(&self, state: Vec<u8>) -> Result<(), sp_runtime::DispatchError> {

        snowbridge_pallet_system::migration::FeePerGasMigrationV0ToV1::<T>::post_upgrade(state)

    }

}

pub struct MigratePalletSessionV0toV1<T>(PhantomData<T>);

impl<T: frame_system::Config + pallet_session::Config> Migration for MigratePalletSessionV0toV1<T>

where

    pallet_session::migrations::v1::MigrateV0ToV1<

        T,

        pallet_session::migrations::v1::InitOffenceSeverity<T>,

    >: frame_support::traits::OnRuntimeUpgrade,

{

    #[cfg(feature = "try-runtime")]

    fn pre_upgrade(&self) -> Result<Vec<u8>, sp_runtime::DispatchError> {

        pallet_session::migrations::v1::MigrateV0ToV1::<

            T,

            pallet_session::migrations::v1::InitOffenceSeverity<T>,

        >::pre_upgrade()

    }

    #[cfg(feature = "try-runtime")]

    fn post_upgrade(&self, state: Vec<u8>) -> Result<(), sp_runtime::DispatchError> {

        pallet_session::migrations::v1::MigrateV0ToV1::<

            T,

            pallet_session::migrations::v1::InitOffenceSeverity<T>,

        >::post_upgrade(state)

    }

}

pub struct MigrateToLatestXcmVersion<Runtime>(PhantomData<Runtime>);

impl<Runtime> Migration for MigrateToLatestXcmVersion<Runtime>

where

    pallet_xcm::migration::MigrateToLatestXcmVersion<Runtime>:

        frame_support::traits::OnRuntimeUpgrade,

{

    #[cfg(feature = "try-runtime")]

    fn pre_upgrade(&self) -> Result<Vec<u8>, sp_runtime::DispatchError> {

        pallet_xcm::migration::MigrateToLatestXcmVersion::<Runtime>::pre_upgrade()

    }

    #[cfg(feature = "try-runtime")]

    fn post_upgrade(&self, state: Vec<u8>) -> Result<(), sp_runtime::DispatchError> {

        pallet_xcm::migration::MigrateToLatestXcmVersion::<Runtime>::post_upgrade(state)

    }

}

pub struct DataPreserversAssignmentsMigration<T>(pub PhantomData<T>);

impl<T> Migration for DataPreserversAssignmentsMigration<T>

where

    T: pallet_data_preservers::Config + pallet_registrar::Config,

    T::AccountId: From<[u8; 32]>,

{

        use {

            frame_support::BoundedBTreeSet,

            frame_system::RawOrigin,

            pallet_data_preservers::{AssignmentProcessor, ParaIdsFilter, Profile, ProfileMode},

        };

            }

        }

    #[cfg(feature = "try-runtime")]

    fn pre_upgrade(&self) -> Result<Vec<u8>, sp_runtime::DispatchError> {

        use parity_scale_codec::Encode;

        let pallet_prefix: &[u8] = b"DataPreservers";

        let storage_item_prefix: &[u8] = b"BootNodes";

        let state: Vec<_> = storage_key_iter::<

            ParaId,

            BoundedVec<BoundedVec<u8, T::MaxNodeUrlLen>, T::MaxAssignmentsPerParaId>,

            Blake2_128Concat,

        >(pallet_prefix, storage_item_prefix)

        .collect();

        Ok(state.encode())

    }

    #[cfg(feature = "try-runtime")]

    fn post_upgrade(&self, state: Vec<u8>) -> Result<(), sp_runtime::DispatchError> {

        use parity_scale_codec::Decode;

        let pallet_prefix: &[u8] = b"DataPreservers";

        let storage_item_prefix: &[u8] = b"BootNodes";

        let pre_state: Vec<(ParaId, Vec<Vec<u8>>)> =

            Decode::decode(&mut &state[..]).expect("state to be decoded properly");

        for (para_id, bootnodes) in pre_state {

            let assignments = pallet_data_preservers::Assignments::<T>::get(para_id);

            assert_eq!(assignments.len(), bootnodes.len());

            let profiles: Vec<_> =

                pallet_data_preservers::Pallet::<T>::assignments_profiles(para_id).collect();

            for bootnode in bootnodes {

                assert_eq!(

                    profiles

                        .iter()

                        .filter(|profile| profile.url == bootnode)

                        .count(),

                    1

                );

            }

        }

        assert_eq!(

            storage_key_iter::<

                ParaId,

                BoundedVec<BoundedVec<u8, T::MaxNodeUrlLen>, T::MaxAssignmentsPerParaId>,

                Blake2_128Concat,

            >(pallet_prefix, storage_item_prefix)

            .count(),

            0

        );

        Ok(())

    }

}

pub struct ForeignAssetCreatorMigration<Runtime>(pub PhantomData<Runtime>);

impl<Runtime> Migration for ForeignAssetCreatorMigration<Runtime>

where

    Runtime: pallet_foreign_asset_creator::Config,

    <Runtime as pallet_foreign_asset_creator::Config>::ForeignAsset:

        TryFrom<xcm::v3::MultiLocation>,

{

        use frame_support::pallet_prelude::*;

        use xcm::v3::MultiLocation as OldLocation;

        // Write to the new storage with removed and added fields

            }

        }

            }

        }

        // One db read and one db write per element, plus the on-chain storage

    #[cfg(feature = "try-runtime")]

    fn pre_upgrade(&self) -> Result<Vec<u8>, sp_runtime::DispatchError> {

        Ok(vec![])

    }

    #[cfg(feature = "try-runtime")]

    fn post_upgrade(&self, _state: Vec<u8>) -> Result<(), sp_runtime::DispatchError> {

        Ok(())

    }

}

pub struct ExternalValidatorsInitialMigration<Runtime>(pub PhantomData<Runtime>);

impl<Runtime> Migration for ExternalValidatorsInitialMigration<Runtime>

where

    Runtime: pallet_external_validators::Config,

    Runtime: pallet_session::Config<

        ValidatorId = <Runtime as pallet_external_validators::Config>::ValidatorId,

    >,

{

        use frame_support::pallet_prelude::*;

        // Set initial WhitelistedValidators to current validators from pallet session

    #[cfg(feature = "try-runtime")]

    fn pre_upgrade(&self) -> Result<Vec<u8>, sp_runtime::DispatchError> {

        Ok(vec![])

    }

    #[cfg(feature = "try-runtime")]

    fn post_upgrade(&self, _state: Vec<u8>) -> Result<(), sp_runtime::DispatchError> {

        Ok(())

    }

}

pub struct MigrateMMRLeafPallet<T>(pub PhantomData<T>);

impl<T: frame_system::Config> Migration for MigrateMMRLeafPallet<T> {

    #[cfg(feature = "try-runtime")]

    fn pre_upgrade(&self) -> Result<Vec<u8>, sp_runtime::DispatchError> {

        Ok(vec![])

    }

    #[cfg(feature = "try-runtime")]

    fn post_upgrade(&self, _state: Vec<u8>) -> Result<(), sp_runtime::DispatchError> {

        Ok(())

    }

}

impl<T> MigrateMMRLeafPallet<T> {

}

pub struct BondedErasTimestampMigration<Runtime>(pub PhantomData<Runtime>);

impl<Runtime> Migration for BondedErasTimestampMigration<Runtime>

where

    Runtime: pallet_external_validator_slashes::Config,

{

        use frame_support::pallet_prelude::*;

    #[cfg(feature = "try-runtime")]

    fn pre_upgrade(&self) -> Result<Vec<u8>, sp_runtime::DispatchError> {

        use frame_support::pallet_prelude::*;

        let previous_bonded_eras: Vec<(sp_staking::EraIndex, sp_staking::SessionIndex)> =

            frame_support::storage::unhashed::get(

                &pallet_external_validator_slashes::BondedEras::<Runtime>::hashed_key(),

            )

            .unwrap_or_default();

        Ok(previous_bonded_eras.encode())

    }

    #[cfg(feature = "try-runtime")]

    fn post_upgrade(&self, state: Vec<u8>) -> Result<(), sp_runtime::DispatchError> {

        use parity_scale_codec::Decode;

        let previous_bonded_eras: Vec<(sp_staking::EraIndex, sp_staking::SessionIndex)> =

            Decode::decode(&mut &state[..]).expect("state to be decoded properly");

        let new_eras = pallet_external_validator_slashes::BondedEras::<Runtime>::get();

        for (i, bonded) in new_eras.iter().enumerate() {

            assert_eq!(previous_bonded_eras[i].0, bonded.0);

            assert_eq!(previous_bonded_eras[i].1, bonded.1);

            assert_eq!(bonded.2, 0u64);

        }

        Ok(())

    }

}

pub mod snowbridge_system_migration {

    use super::*;

    use alloc::vec::Vec;

    use frame_support::pallet_prelude::*;

    use snowbridge_core::TokenId;

    use xcm::{

        self,

        v5::NetworkId::ByGenesis,

        v5::{Junction::GlobalConsensus, ROCOCO_GENESIS_HASH},

    };

    pub const DANCELIGHT_GENESIS_HASH: [u8; 32] =

        hex_literal::hex!["983a1a72503d6cc3636776747ec627172b51272bf45e50a355348facb67a820a"];

    pub const TANSSI_GENESIS_HASH: [u8; 32] =

        hex_literal::hex!["dd6d086f75ec041b66e20c4186d327b23c8af244c534a2418de6574e8c041a60"];

    parameter_types! {

        pub DancelightLocation: xcm::v5::Location = xcm::v5::Location::new(

            1,

            [GlobalConsensus(ByGenesis(DANCELIGHT_GENESIS_HASH))],

        );

        pub StarlightLocation: xcm::v5::Location = xcm::v5::Location::new(

            1,

            [GlobalConsensus(ByGenesis(TANSSI_GENESIS_HASH))],

        );

    }

    // Important: this cannot be called OldNativeToForeignId because that will be a different storage

    // item. Polkadot has a bug here.

    pub type NativeToForeignId<T: snowbridge_pallet_system::Config> = StorageMap<

        snowbridge_pallet_system::Pallet<T>,

        Blake2_128Concat,

        xcm::v5::Location,

        TokenId,

        OptionQuery,

    >;

    /// One shot migration to change the genesis hash of NetworkId::ByGenesis()

    pub struct MigrationForGenesisHashes<T: snowbridge_pallet_system::Config, L: Get<xcm::v5::Location>>(

        core::marker::PhantomData<(T, L)>,

    );

    impl<T: snowbridge_pallet_system::Config, L: Get<xcm::v5::Location>>

        frame_support::traits::OnRuntimeUpgrade for MigrationForGenesisHashes<T, L>

    {

                };

                    };

            }

            // Additional sanity check that both mappings have the same number of elements

    }

}

pub struct MigrateEthSystemGenesisHashes<Runtime, Location>(pub PhantomData<(Runtime, Location)>);

impl<Runtime, Location> Migration for MigrateEthSystemGenesisHashes<Runtime, Location>

where

    Runtime: snowbridge_pallet_system::Config,

    Location: Get<xcm::v5::Location>,

{

    #[cfg(feature = "try-runtime")]

    fn pre_upgrade(&self) -> Result<Vec<u8>, sp_runtime::DispatchError> {

        Ok(vec![])

    }

    #[cfg(feature = "try-runtime")]

    fn post_upgrade(&self, _state: Vec<u8>) -> Result<(), sp_runtime::DispatchError> {

        Ok(())

    }

}

pub struct MigrateParaSchedulerToV3<Runtime>(pub PhantomData<Runtime>);

impl<Runtime> Migration for MigrateParaSchedulerToV3<Runtime>

where

    Runtime: runtime_parachains::scheduler::Config,

{

    #[cfg(feature = "try-runtime")]

    fn pre_upgrade(&self) -> Result<Vec<u8>, sp_runtime::DispatchError> {

        Ok(vec![])

    }

    #[cfg(feature = "try-runtime")]

    fn post_upgrade(&self, _state: Vec<u8>) -> Result<(), sp_runtime::DispatchError> {

        Ok(())

    }

}

pub struct MigrateParaSharedToV1<Runtime>(pub PhantomData<Runtime>);

impl<Runtime> Migration for MigrateParaSharedToV1<Runtime>

where

    Runtime: runtime_parachains::shared::Config,

{

    #[cfg(feature = "try-runtime")]

    fn pre_upgrade(&self) -> Result<Vec<u8>, sp_runtime::DispatchError> {

        Ok(vec![])

    }

    #[cfg(feature = "try-runtime")]

    fn post_upgrade(&self, _state: Vec<u8>) -> Result<(), sp_runtime::DispatchError> {

        Ok(())

    }

}

pub struct MigrateStreamPaymentNewConfigFields<Runtime>(pub PhantomData<Runtime>);

impl<Runtime> Migration for MigrateStreamPaymentNewConfigFields<Runtime>

where

    Runtime: pallet_stream_payment::Config,

{

    #[cfg(feature = "try-runtime")]

    fn pre_upgrade(&self) -> Result<Vec<u8>, sp_runtime::DispatchError> {

        use pallet_stream_payment::migrations::OldStreamOf;

        use parity_scale_codec::Encode;

        let Some(stream_id) = pallet_stream_payment::Streams::<Runtime>::iter_keys().next() else {

            return Ok(vec![]);

        };

        let old_stream: OldStreamOf<Runtime> = frame_support::storage::unhashed::get(

            &pallet_stream_payment::Streams::<Runtime>::hashed_key_for(stream_id),

        )

        .expect("key was found so entry must exist");

        Ok((stream_id, old_stream).encode())

    }

    #[cfg(feature = "try-runtime")]

    fn post_upgrade(&self, state: Vec<u8>) -> Result<(), sp_runtime::DispatchError> {

        use pallet_stream_payment::{migrations::OldStreamOf, ChangeRequest, Stream, StreamConfig};

        use parity_scale_codec::Decode;

        if state.is_empty() {

            // there were no streams

            return Ok(());

        }

        let (stream_id, old_stream) =

            <(Runtime::StreamId, OldStreamOf<Runtime>)>::decode(&mut &state[..])

                .expect("to decode properly");

        let new_stream = pallet_stream_payment::Streams::<Runtime>::get(stream_id)

            .expect("entry should still exist");

        let mut expected = Stream {

            source: old_stream.source,

            target: old_stream.target,

            deposit: old_stream.deposit,

            last_time_updated: old_stream.last_time_updated,

            request_nonce: old_stream.request_nonce,

            pending_request: None, // will be replaced below

            opening_deposit: old_stream.opening_deposit,

            config: StreamConfig {

                time_unit: old_stream.config.time_unit,

                asset_id: old_stream.config.asset_id,

                rate: old_stream.config.rate,

                minimum_request_deadline_delay: 0u32.into(),

                soft_minimum_deposit: 0u32.into(),

            },

        };

        if let Some(pending_request) = old_stream.pending_request {

            expected.pending_request = Some(ChangeRequest {

                requester: pending_request.requester,

                kind: pending_request.kind,

                deposit_change: pending_request.deposit_change,

                new_config: StreamConfig {

                    time_unit: pending_request.new_config.time_unit,

                    asset_id: pending_request.new_config.asset_id,

                    rate: pending_request.new_config.rate,

                    minimum_request_deadline_delay: 0u32.into(),

                    soft_minimum_deposit: 0u32.into(),

                },

            });

        }

        assert_eq!(

            new_stream, expected,

            "Migrated stream don't match expected value"

        );

        Ok(())

    }

}

pub struct FlashboxMigrations<Runtime>(PhantomData<Runtime>);

impl<Runtime> GetMigrations for FlashboxMigrations<Runtime>

where

    Runtime: pallet_balances::Config,

    Runtime: pallet_configuration::Config,

    Runtime: pallet_registrar::Config,

    Runtime: pallet_session::Config,

    Runtime: pallet_services_payment::Config,

    Runtime: pallet_data_preservers::Config,

    Runtime: pallet_stream_payment::Config,

    Runtime::AccountId: From<[u8; 32]>,

    <Runtime as pallet_balances::Config>::RuntimeHoldReason: From<pallet_registrar::HoldReason>,

    <Runtime as pallet_balances::Config>::Balance: From<<<Runtime as pallet_registrar::Config>::Currency as frame_support::traits::fungible::Inspect<Runtime::AccountId>>::Balance>,

    <Runtime as pallet_balances::Config>::Balance: From<u128>,

{

}

pub struct DanceboxMigrations<Runtime>(PhantomData<Runtime>);

impl<Runtime> GetMigrations for DanceboxMigrations<Runtime>

where

    Runtime: pallet_pooled_staking::Config,

    Runtime: pallet_session::Config,

    Runtime: pallet_registrar::Config,

    Runtime: pallet_balances::Config,

    Runtime: pallet_configuration::Config,

    Runtime: pallet_services_payment::Config,

    Runtime: cumulus_pallet_xcmp_queue::Config,

    Runtime: pallet_data_preservers::Config,

    Runtime: pallet_xcm::Config,

    Runtime: pallet_stream_payment::Config,

    <Runtime as pallet_balances::Config>::RuntimeHoldReason: