// 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 {

    alloc::{boxed::Box, collections::btree_set::BTreeSet, vec, vec::Vec},

    core::marker::PhantomData,

    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, 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,

};

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

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

#[derive(

    Default,

    Clone,

    parity_scale_codec::Encode,

    parity_scale_codec::Decode,

    PartialEq,

    sp_core::RuntimeDebug,

    scale_info::TypeInfo,

)]

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,

{

        // Modify active config

        )

        );

        // Modify pending configs, if any

            )

    /// 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,

{

        // For each parachain in pallet_registrar (active, pending or pending_verification),

        // insert `MaxCreditsStored` to pallet_services_payment,

        // and mark that parachain as "given_free_credits".

    /// 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 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;

        // Data required to migrate ForeignAsset values

        // Read all the data into memory.

            )

        // Data required to migrate ForeignAsset keys

            )

        // 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 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 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.

    #[frame_support::storage_alias]

    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 OfflineMarkingStorageMigration<Runtime>(PhantomData<Runtime>);

impl<Runtime> Migration for OfflineMarkingStorageMigration<Runtime>

where

    Runtime: pallet_inactivity_tracking::Config,

{

        )

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

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

        use parity_scale_codec::Encode;

        let Some(collator_id) =

            pallet_inactivity_tracking::OfflineCollators::<Runtime>::iter_keys().next()

        else {

            return Ok(vec![]);

        };

        let old_collator_offline_status: bool =

            frame_support::storage::unhashed::get(&pallet_inactivity_tracking::OfflineCollators::<

                Runtime,

            >::hashed_key_for(

                collator_id.clone()

            ))

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

        Ok((collator_id, old_collator_offline_status).encode())

    }

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

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

        use parity_scale_codec::Decode;

        if state.is_empty() {

            // There were no offline collators

            return Ok(());

        }

        let (collator_id, old_collator_offline_status) =

            <(Runtime::AccountId, bool)>::decode(&mut &state[..]).expect("to decode properly");

        if old_collator_offline_status {

            let new_collator_offline_status =

                pallet_inactivity_tracking::OfflineCollators::<Runtime>::get(collator_id.clone())

                    .expect("entry should still exist");

            let expected_collator_offline_status =

                pallet_inactivity_tracking::OfflineStatus::Disabled;

            assert_eq!(

                new_collator_offline_status, expected_collator_offline_status,

                "Migrated collator offline status don't match expected value"

            );

        }

        Ok(())

    }

}

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

impl<Runtime> Migration for DataPreserversProfileContentMigration<Runtime>

where

    Runtime: pallet_data_preservers::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 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>,

{

        //let migrate_services_payment =

        //    MigrateServicesPaymentAddCredits::<Runtime>(Default::default());

        //let migrate_boot_nodes = MigrateBootNodes::<Runtime>(Default::default());

        //let migrate_config_parathread_params =

        //    MigrateConfigurationParathreads::<Runtime>(Default::default());

        //let migrate_add_collator_assignment_credits =

        //    MigrateServicesPaymentAddCollatorAssignmentCredits::<Runtime>(Default::default());

        //let migrate_registrar_pending_verification =

        //    RegistrarPendingVerificationValueToMap::<Runtime>(Default::default());

        //let migrate_registrar_manager =

        //    RegistrarParaManagerMigration::<Runtime>(Default::default());

        //let migrate_data_preservers_assignments =

        //    DataPreserversAssignmentsMigration::<Runtime>(Default::default());

        //let migrate_registrar_reserves = RegistrarReserveToHoldMigration::<Runtime>(Default::default());

        //let migrate_config_max_parachain_percentage = MigrateConfigurationAddParachainPercentage::<Runtime>(Default::default());

        //let migrate_config_full_rotation_mode = MigrateConfigurationAddFullRotationMode::<Runtime>(Default::default());

        //let migrate_stream_payment_new_config_items = MigrateStreamPaymentNewConfigFields::<Runtime>(Default::default());

            // Applied in runtime 400

            //Box::new(migrate_services_payment),

            // Applied in runtime 400

            //Box::new(migrate_boot_nodes),

            // Applied in runtime 400

            //Box::new(migrate_config_parathread_params),

            // Applied in runtime 500

            //Box::new(migrate_add_collator_assignment_credits),

            // Applied in runtime 700

            //Box::new(migrate_registrar_pending_verification),

            // Applied in runtime 700

            //Box::new(migrate_registrar_manager),

            // Applied in runtime 700

            //Box::new(migrate_data_preservers_assignments),

            // Applied in runtime 800

            //Box::new(migrate_registrar_reserves),

            // Applied in runtime 900

            //Box::new(migrate_config_max_parachain_percentage),

            // Applied in runtime 1100

            //Box::new(migrate_config_full_rotation_mode),

            // Applied in runtime 1200

            //Box::new(migrate_stream_payment_new_config_items),

        ]

}

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: pallet_inactivity_tracking::Config,

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

        From<pallet_pooled_staking::HoldReason>,

    Runtime: pallet_foreign_asset_creator::Config,

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

        From<pallet_registrar::HoldReason>,

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

    <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>,

{

        // let migrate_invulnerables = MigrateInvulnerables::<Runtime>(Default::default());

        // let migrate_holds = MigrateHoldReason::<Runtime>(Default::default());

        // let migrate_config = MigrateConfigurationFullRotationPeriod::<Runtime>(Default::default());

        // let migrate_xcm = PolkadotXcmMigration::<Runtime>(Default::default());

        // let migrate_xcmp_queue = XcmpQueueMigration::<Runtime>(Default::default());

        // let migrate_services_payment =

        //     MigrateServicesPaymentAddCredits::<Runtime>(Default::default());

        // let migrate_boot_nodes = MigrateBootNodes::<Runtime>(Default::default());

        // let migrate_hold_reason_runtime_enum =

        //     MigrateHoldReasonRuntimeEnum::<Runtime>(Default::default());

        //let migrate_config_parathread_params =

        //    MigrateConfigurationParathreads::<Runtime>(Default::default());

        //let migrate_add_collator_assignment_credits =

        //    MigrateServicesPaymentAddCollatorAssignmentCredits::<Runtime>(Default::default());

        //let migrate_xcmp_queue_v4 = XcmpQueueMigrationV4::<Runtime>(Default::default());

        //let migrate_registrar_pending_verification =

        //    RegistrarPendingVerificationValueToMap::<Runtime>(Default::default());

        //let migrate_registrar_manager =

        //    RegistrarParaManagerMigration::<Runtime>(Default::default());

        //let migrate_data_preservers_assignments =

        //    DataPreserversAssignmentsMigration::<Runtime>(Default::default());

        //let migrate_pallet_xcm_v4 = MigrateToLatestXcmVersion::<Runtime>(Default::default());

        //let foreign_asset_creator_migration =

        //    ForeignAssetCreatorMigration::<Runtime>(Default::default());

        //let migrate_registrar_reserves = RegistrarReserveToHoldMigration::<Runtime>(Default::default());

        //let migrate_config_full_rotation_mode = MigrateConfigurationAddFullRotationMode::<Runtime>(Default::default());

        //let migrate_stream_payment_new_config_items = MigrateStreamPaymentNewConfigFields::<Runtime>(Default::default());

        //let migrate_pallet_xcm_v5 = MigrateToLatestXcmVersion::<Runtime>(Default::default());

            // Applied in runtime 200

            //Box::new(migrate_invulnerables),

            // Applied in runtime 200

            //Box::new(migrate_holds),

            // Applied in runtime 300

            //Box::new(migrate_config),

            // Applied in runtime 300

            //Box::new(migrate_xcm),

            // Applied in runtime 300

            //Box::new(migrate_xcmp_queue),

            // Applied in runtime 400

            //Box::new(migrate_services_payment),

            // Applied in runtime 400

            //Box::new(migrate_hold_reason_runtime_enum),

            // Applied in runtime 400

            //Box::new(migrate_boot_nodes),

            // Applied in runtime 500

            //Box::new(migrate_config_parathread_params),

            // Applied in runtime 500

            //Box::new(migrate_add_collator_assignment_credits),

            // Applied in runtime 500

            //Box::new(migrate_xcmp_queue_v4),

            // Applied in runtime 700

            //Box::new(migrate_registrar_pending_verification),

            // Applied in runtime 700

            //Box::new(migrate_registrar_manager),

            // Applied in runtime 700

            //Box::new(migrate_pallet_xcm_v4),

            // Applied in runtime 700

            //Box::new(foreign_asset_creator_migration),

            // Applied in runtime 700

            //Box::new(migrate_data_preservers_assignments),

            // Applied in runtime 800

            //Box::new(migrate_registrar_reserves),

            // Applied in runtime 900

            //Box::new(migrate_config_max_parachain_percentage),

            // Applied in runtime 1100

            //Box::new(migrate_config_full_rotation_mode),

            // Applied in runtime 1200

            //Box::new(migrate_stream_payment_new_config_items),

            // Applied in runtime 1200

            //Box::new(migrate_pallet_xcm_v5),

        ]

}

#[cfg(feature = "relay")]

pub use relay::*;

#[cfg(feature = "relay")]

mod relay {

    use super::*;

    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

            );

            // Kill storage of ValidatorManager pallet

            // 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 BondedErasTimestampMigration<Runtime>(pub PhantomData<Runtime>);

    impl<Runtime> Migration for BondedErasTimestampMigration<Runtime>

    where