Grcov report - migrations.rs

1

// Copyright (C) Moondance Labs Ltd.

2

// This file is part of Tanssi.

3

4

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

5

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

6

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

7

// (at your option) any later version.

8

9

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

10

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

11

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

12

// GNU General Public License for more details.

13

14

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

15

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

16

// Copyright (C) Moondance Labs Ltd.

17

// This file is part of Tanssi.

18

19

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

20

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

21

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

22

// (at your option) any later version.

23

24

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

25

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

26

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

27

// GNU General Public License for more details.

28

29

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

30

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

31

32

//! # Migrations

33

//!

34

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

35

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

36

37

extern crate alloc;

38

39

use {

40

    cumulus_primitives_core::ParaId,

41

    frame_support::{

42

        migration::{clear_storage_prefix, move_pallet, storage_key_iter},

43

        pallet_prelude::GetStorageVersion,

44

        parameter_types,

45

        traits::{

46

            fungible::MutateHold, OnRuntimeUpgrade, PalletInfoAccess, ReservableCurrency,

47

            StorageVersion,

48

},

49

        weights::Weight,

50

        Blake2_128Concat, BoundedVec, StoragePrefixedMap,

51

},

52

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

53

    pallet_foreign_asset_creator::{AssetId, AssetIdToForeignAsset, ForeignAssetToAssetId},

54

    pallet_migrations::{GetMigrations, Migration},

55

    pallet_registrar::HoldReason,

56

    sp_core::Get,

57

    sp_runtime::Perbill,

58

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

59

};

60

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

61

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

62

63

#[derive(

64

    Default,

65

    Clone,

66

    parity_scale_codec::Encode,

67

    parity_scale_codec::Decode,

68

    PartialEq,

69

    sp_core::RuntimeDebug,

70

    scale_info::TypeInfo,

71

)]

72

pub struct HostConfigurationV3 {

73

    pub max_collators: u32,

74

    pub min_orchestrator_collators: u32,

75

    pub max_orchestrator_collators: u32,

76

    pub collators_per_container: u32,

77

    pub full_rotation_period: u32,

78

    pub collators_per_parathread: u32,

79

    pub parathreads_per_collator: u32,

80

    pub target_container_chain_fullness: Perbill,

81

    pub max_parachain_cores_percentage: Option<Perbill>,

82

83

84

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

85

impl<T> Migration for MigrateConfigurationAddFullRotationMode<T>

86

where

87

    T: pallet_configuration::Config,

88

89

    fn friendly_name(&self) -> &str {

90

        "TM_MigrateConfigurationAddFullRotationMode"

91

92

93

3

    fn migrate(&self, _available_weight: Weight) -> Weight {

94

3

        let default_config = HostConfiguration::default();

95

3

96

3

        // Modify active config

97

3

        let old_config: HostConfigurationV3 = frame_support::storage::unhashed::get(

98

3

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

99

3

100

3

        .expect("configuration.activeConfig should have value");

101

3

        let new_config = HostConfiguration {

102

3

            max_collators: old_config.max_collators,

103

3

            min_orchestrator_collators: old_config.min_orchestrator_collators,

104

3

            max_orchestrator_collators: old_config.max_orchestrator_collators,

105

3

            collators_per_container: old_config.collators_per_container,

106

3

            full_rotation_period: old_config.full_rotation_period,

107

3

            collators_per_parathread: old_config.collators_per_parathread,

108

3

            parathreads_per_collator: old_config.parathreads_per_collator,

109

3

            target_container_chain_fullness: old_config.target_container_chain_fullness,

110

3

            max_parachain_cores_percentage: old_config.max_parachain_cores_percentage,

111

3

            full_rotation_mode: default_config.full_rotation_mode.clone(),

112

3

};

113

3

        frame_support::storage::unhashed::put(

114

3

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

115

3

            &new_config,

116

3

);

117

3

118

3

        // Modify pending configs, if any

119

3

        let old_pending_configs: Vec<(u32, HostConfigurationV3)> =

120

3

            frame_support::storage::unhashed::get(

121

3

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

122

3

123

3

            .unwrap_or_default();

124

3

        let mut new_pending_configs: Vec<(u32, HostConfiguration)> = vec![];

125

126

9

        for (session_index, old_config) in old_pending_configs {

127

6

            let new_config = HostConfiguration {

128

6

                max_collators: old_config.max_collators,

129

6

                min_orchestrator_collators: old_config.min_orchestrator_collators,

130

6

                max_orchestrator_collators: old_config.max_orchestrator_collators,

131

6

                collators_per_container: old_config.collators_per_container,

132

6

                full_rotation_period: old_config.full_rotation_period,

133

6

                collators_per_parathread: old_config.collators_per_parathread,

134

6

                parathreads_per_collator: old_config.parathreads_per_collator,

135

6

                target_container_chain_fullness: old_config.target_container_chain_fullness,

136

6

                max_parachain_cores_percentage: old_config.max_parachain_cores_percentage,

137

6

                full_rotation_mode: default_config.full_rotation_mode.clone(),

138

6

};

139

6

            new_pending_configs.push((session_index, new_config));

140

6

141

142

3

        if !new_pending_configs.is_empty() {

143

3

            frame_support::storage::unhashed::put(

144

3

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

145

3

                &new_pending_configs,

146

3

);

147

3

148

149

3

        <T as pallet_configuration::Config>::WeightInfo::set_config_with_u32()

150

3

151

152

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

153

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

154

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

155

        log::info!(

156

            "hashed key {:?}",

157

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

158

);

159

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

160

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

161

162

        .unwrap();

163

        let old_config: Result<HostConfigurationV3, _> =

164

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

165

        let new_config: Result<HostConfiguration, _> =

166

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

167

168

        assert!(old_config.is_ok());

169

        assert!(new_config.is_err());

170

171

        Ok(vec![])

172

173

174

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

175

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

176

    fn post_upgrade(

177

        &self,

178

        _number_of_invulnerables: Vec<u8>,

179

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

180

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

181

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

182

183

        .unwrap();

184

        let old_config: Result<HostConfigurationV3, _> =

185

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

186

        let new_config: Result<HostConfiguration, _> =

187

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

188

189

        assert!(old_config.is_err());

190

        assert!(new_config.is_ok());

191

192

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

193

        let default_config = HostConfiguration::default();

194

        assert_eq!(

195

            new_config.full_rotation_mode,

196

            default_config.full_rotation_mode

197

);

198

        Ok(())

199

200

201

202

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

203

impl<T> Migration for MigrateServicesPaymentAddCollatorAssignmentCredits<T>

204

where

205

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

206

207

    fn friendly_name(&self) -> &str {

208

        "TM_MigrateServicesPaymentAddCollatorAssignmentCredits"

209

210

211

2

    fn migrate(&self, _available_weight: Weight) -> Weight {

212

2

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

213

2

        // insert `MaxCreditsStored` to pallet_services_payment,

214

2

        // and mark that parachain as "given_free_credits".

215

2

        let mut para_ids = BTreeSet::new();

216

2

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

217

2

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

218

2

219

2

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

220

2

        para_ids.extend(active);

221

2

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

222

2

        para_ids.extend(paused);

223

2

224

2

        let reads = 3 + 2 * para_ids.len() as u64;

225

2

        let writes = 2 * para_ids.len() as u64;

226

227

6

        for para_id in para_ids {

228

4

            // 2 reads 2 writes

229

4

            pallet_services_payment::Pallet::<T>::set_free_collator_assignment_credits(

230

4

                &para_id,

231

4

                T::FreeCollatorAssignmentCredits::get(),

232

4

);

233

4

234

235

2

        let db_weights = T::DbWeight::get();

236

2

        db_weights.reads_writes(reads, writes)

237

2

238

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

239

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

240

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

241

        let mut para_ids = BTreeSet::new();

242

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

243

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

244

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

245

        para_ids.extend(active);

246

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

247

        para_ids.extend(paused);

248

249

        for para_id in para_ids {

250

            assert!(

251

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

252

);

253

254

255

        Ok(vec![])

256

257

258

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

259

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

260

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

261

        let mut para_ids = BTreeSet::new();

262

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

263

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

264

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

265

        para_ids.extend(active);

266

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

267

        para_ids.extend(paused);

268

269

        for para_id in para_ids {

270

            assert_eq!(

271

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

272

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

273

);

274

275

276

        Ok(())

277

278

279

280

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

281

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

282

where

283

    PolkadotXcm: GetStorageVersion + PalletInfoAccess,

284

    T: cumulus_pallet_xcmp_queue::Config,

285

286

    fn friendly_name(&self) -> &str {

287

        "MM_PolkadotXcmMigrationFixVersion"

288

289

290

    fn migrate(&self, _available_weight: Weight) -> Weight {

291

        if <PolkadotXcm as GetStorageVersion>::on_chain_storage_version() == 0 {

292

            StorageVersion::new(1).put::<PolkadotXcm>();

293

            return T::DbWeight::get().writes(1);

294

295

        Weight::default()

296

297

298

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

299

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

300

        ensure!(

301

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

302

            "PolkadotXcm storage version should be 0"

303

);

304

        Ok(vec![])

305

306

307

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

308

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

309

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

310

        ensure!(

311

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

312

            "PolkadotXcm storage version should be 1"

313

);

314

        Ok(())

315

316

317

318

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

319

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

320

where

321

    XcmpQueue: GetStorageVersion + PalletInfoAccess,

322

    T: cumulus_pallet_xcmp_queue::Config,

323

324

    fn friendly_name(&self) -> &str {

325

        "MM_XcmpQueueMigrationFixVersion"

326

327

328

    fn migrate(&self, _available_weight: Weight) -> Weight {

329

        if <XcmpQueue as GetStorageVersion>::on_chain_storage_version() == 0 {

330

            StorageVersion::new(2).put::<XcmpQueue>();

331

            return T::DbWeight::get().writes(1);

332

333

        Weight::default()

334

335

336

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

337

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

338

        ensure!(

339

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

340

            "XcmpQueue storage version should be 0"

341

);

342

        Ok(vec![])

343

344

345

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

346

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

347

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

348

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

349

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

350

        // same runtime

351

        ensure!(

352

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

353

            "XcmpQueue storage version should be at least 2"

354

);

355

        Ok(())

356

357

358

359

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

360

impl<T> Migration for XcmpQueueMigrationV3<T>

361

where

362

    T: cumulus_pallet_xcmp_queue::Config,

363

364

    fn friendly_name(&self) -> &str {

365

        "MM_XcmpQueueMigrationV3"

366

367

368

    fn migrate(&self, _available_weight: Weight) -> Weight {

369

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

370

371

372

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

373

    // let mut pre_upgrade_result: Vec<u8>;

374

375

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

376

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

377

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

378

379

380

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

381

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

382

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

383

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

384

385

386

387

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

388

impl<T> Migration for XcmpQueueMigrationV4<T>

389

where

390

    T: cumulus_pallet_xcmp_queue::Config,

391

392

    fn friendly_name(&self) -> &str {

393

        "MM_XcmpQueueMigrationV4"

394

395

396

    fn migrate(&self, _available_weight: Weight) -> Weight {

397

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

398

399

400

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

401

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

402

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

403

404

405

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

406

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

407

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

408

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

409

410

411

412

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

413

impl<T> Migration for RegistrarPendingVerificationValueToMap<T>

414

where

415

    T: pallet_registrar::Config,

416

417

    fn friendly_name(&self) -> &str {

418

        "TM_RegistrarPendingVerificationValueToMap"

419

420

421

1

    fn migrate(&self, _available_weight: Weight) -> Weight {

422

1

        let para_ids: Vec<ParaId> = frame_support::storage::unhashed::take(

423

1

            &frame_support::storage::storage_prefix(b"Registrar", b"PendingVerification"),

424

1

425

1

        .unwrap_or_default();

426

1

427

1

        let total_weight = T::DbWeight::get()

428

1

            .reads(1)

429

1

            .saturating_add(T::DbWeight::get().writes(1));

430

431

5

        for para_id in para_ids {

432

4

            total_weight.saturating_add(T::DbWeight::get().writes(1));

433

4

            pallet_registrar::PendingVerification::<T>::insert(para_id, ());

434

4

435

436

1

        total_weight

437

1

438

439

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

440

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

441

        Ok(vec![])

442

443

444

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

445

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

446

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

447

        Ok(())

448

449

450

451

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

452

impl<T> Migration for RegistrarParaManagerMigration<T>

453

where

454

    T: pallet_registrar::Config,

455

456

    fn friendly_name(&self) -> &str {

457

        "TM_RegistrarParaManagerMigration"

458

459

460

    fn migrate(&self, _available_weight: Weight) -> Weight {

461

        let mut total_weight = Weight::default();

462

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

463

            pallet_registrar::ParaManager::<T>::insert(para_id, deposit.creator);

464

            total_weight = total_weight.saturating_add(

465

                T::DbWeight::get()

466

                    .reads(1)

467

                    .saturating_add(T::DbWeight::get().writes(1)),

468

);

469

470

471

        total_weight

472

473

474

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

475

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

476

        Ok(vec![])

477

478

479

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

480

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

481

        Ok(())

482

483

484

485

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

486

impl<T> Migration for RegistrarReserveToHoldMigration<T>

487

where

488

    T: pallet_registrar::Config,

489

    T: pallet_balances::Config,

490

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

491

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

492

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

493

            T::AccountId,

494

        >>::Balance,

495

>,

496

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

497

498

    fn friendly_name(&self) -> &str {

499

        "TM_RegistrarReserveToHoldMigration"

500

501

502

2

    fn migrate(&self, _available_weight: Weight) -> Weight {

503

2

        let mut total_weight = Weight::default();

504

4

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

505

2

            pallet_balances::Pallet::<T>::unreserve(&deposit.creator, deposit.deposit.into());

506

2

            let _ = pallet_balances::Pallet::<T>::hold(

507

2

                &HoldReason::RegistrarDeposit.into(),

508

2

                &deposit.creator,

509

2

                deposit.deposit.into(),

510

2

);

511

2

            total_weight = total_weight.saturating_add(T::DbWeight::get().reads_writes(2, 2));

512

2

513

514

2

        total_weight

515

2

516

517

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

518

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

519

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

520

521

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

522

            ensure!(

523

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

524

                    >= deposit.deposit.into(),

525

                "Reserved balanced cannot be less than deposit amount"

526

);

527

528

            ensure!(

529

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

530

                    &HoldReason::RegistrarDeposit.into(),

531

                    &deposit.creator

532

                ) == 0u128.into(),

533

                "Balance on hold for RegistrarDeposit should be 0"

534

);

535

536

        Ok(vec![])

537

538

539

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

540

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

541

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

542

543

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

544

            ensure!(

545

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

546

                    &HoldReason::RegistrarDeposit.into(),

547

                    &deposit.creator

548

                ) >= deposit.deposit.into(),

549

                "Balance on hold for RegistrarDeposit should be deposit"

550

);

551

552

553

        Ok(())

554

555

556

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

557

impl<Runtime> Migration for MigrateToLatestXcmVersion<Runtime>

558

where

559

    pallet_xcm::migration::MigrateToLatestXcmVersion<Runtime>:

560

        frame_support::traits::OnRuntimeUpgrade,

561

562

    fn friendly_name(&self) -> &str {

563

        "MM_MigrateToLatestXcmVersion5"

564

565

566

    fn migrate(&self, _available_weight: Weight) -> Weight {

567

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

568

569

570

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

571

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

572

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

573

574

575

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

576

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

577

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

578

579

580

581

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

582

impl<T> Migration for DataPreserversAssignmentsMigration<T>

583

where

584

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

585

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

586

587

    fn friendly_name(&self) -> &str {

588

        "TM_DataPreserversAssignmentsMigration"

589

590

591

2

    fn migrate(&self, _available_weight: Weight) -> Weight {

592

        use {

593

            frame_support::BoundedBTreeSet,

594

            frame_system::RawOrigin,

595

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

596

};

597

598

2

        let mut total_weight = Weight::default();

599

2

600

2

        let (request, _extra, witness) = T::AssignmentProcessor::free_variant_values()

601

2

            .expect("free variant values are necessary to perform migration");

602

2

603

2

        let dummy_profile_owner = T::AccountId::from([0u8; 32]);

604

2

605

2

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

606

2

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

607

2

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

608

2

            ParaId,

609

2

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

610

2

            Blake2_128Concat,

611

2

        >(pallet_prefix, storage_item_prefix)

612

2

        .collect();

613

2

614

2

        total_weight = total_weight.saturating_add(

615

2

            T::DbWeight::get()

616

2

                .reads(bootnodes_storage.len() as u64)

617

2

                .saturating_add(T::DbWeight::get().writes(bootnodes_storage.len() as u64)),

618

2

);

619

620

6

        for (para_id, bootnodes) in bootnodes_storage {

621

12

            for bootnode_url in bootnodes {

622

8

                let profile = Profile {

623

8

                    url: bootnode_url,

624

8

                    para_ids: ParaIdsFilter::Whitelist({

625

8

                        let mut set = BoundedBTreeSet::new();

626

8

                        set.try_insert(para_id).expect("to be in bound");

627

8

set

628

8

}),

629

8

                    mode: ProfileMode::Bootnode,

630

8

                    assignment_request: request.clone(),

631

8

};

632

8

633

8

                let profile_id = pallet_data_preservers::NextProfileId::<T>::get();

634

635

8

                if let Some(weight) = pallet_data_preservers::Pallet::<T>::force_create_profile(

636

8

                    RawOrigin::Root.into(),

637

8

                    profile,

638

8

                    dummy_profile_owner.clone(),

639

8

640

8

                .expect("to create profile")

641

8

                .actual_weight

642

643

                    total_weight = total_weight.saturating_add(weight);

644

8

645

646

8

                if let Some(weight) = pallet_data_preservers::Pallet::<T>::force_start_assignment(

647

8

                    RawOrigin::Root.into(),

648

8

                    profile_id,

649

8

                    para_id,

650

8

                    witness.clone(),

651

8

652

8

                .expect("to start assignment")

653

8

                .actual_weight

654

655

                    total_weight = total_weight.saturating_add(weight);

656

8

657

658

659

660

2

        let _ = clear_storage_prefix(pallet_prefix, storage_item_prefix, &[], None, None);

661

2

662

2

        total_weight

663

2

664

665

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

666

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

667

        use parity_scale_codec::Encode;

668

669

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

670

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

671

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

672

            ParaId,

673

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

674

            Blake2_128Concat,

675

        >(pallet_prefix, storage_item_prefix)

676

        .collect();

677

678

        Ok(state.encode())

679

680

681

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

682

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

683

        use parity_scale_codec::Decode;

684

685

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

686

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

687

688

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

689

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

690

691

        for (para_id, bootnodes) in pre_state {

692

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

693

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

694

695

            let profiles: Vec<_> =

696

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

697

698

            for bootnode in bootnodes {

699

                assert_eq!(

700

                    profiles

701

                        .iter()

702

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

703

                        .count(),

704

705

);

706

707

708

709

        assert_eq!(

710

            storage_key_iter::<

711

                ParaId,

712

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

713

                Blake2_128Concat,

714

            >(pallet_prefix, storage_item_prefix)

715

            .count(),

716

717

);

718

719

        Ok(())

720

721

722

723

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

724

725

impl<Runtime> Migration for ForeignAssetCreatorMigration<Runtime>

726

where

727

    Runtime: pallet_foreign_asset_creator::Config,

728

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

729

        TryFrom<xcm::v3::MultiLocation>,

730

731

    fn friendly_name(&self) -> &str {

732

        "TM_ForeignAssetCreatorMigration"

733

734

735

    fn migrate(&self, _available_weight: Weight) -> Weight {

736

        use frame_support::pallet_prelude::*;

737

738

        use xcm::v3::MultiLocation as OldLocation;

739

740

        let pallet_prefix = AssetIdToForeignAsset::<Runtime>::pallet_prefix();

741

        let asset_id_to_foreign_asset_storage_prefix =

742

            AssetIdToForeignAsset::<Runtime>::storage_prefix();

743

        let foreign_asset_to_asset_id_prefix = ForeignAssetToAssetId::<Runtime>::storage_prefix();

744

745

        // Data required to migrate ForeignAsset values

746

        // Read all the data into memory.

747

        let asset_id_to_foreign_asset_data: Vec<_> =

748

            storage_key_iter::<AssetId<Runtime>, OldLocation, Blake2_128Concat>(

749

                pallet_prefix,

750

                asset_id_to_foreign_asset_storage_prefix,

751

752

            .drain()

753

            .collect();

754

755

        // Data required to migrate ForeignAsset keys

756

        let foreign_asset_to_asset_id_data: Vec<_> =

757

            storage_key_iter::<OldLocation, AssetId<Runtime>, Blake2_128Concat>(

758

                pallet_prefix,

759

                foreign_asset_to_asset_id_prefix,

760

761

            .drain()

762

            .collect();

763

764

        let migrated_count = asset_id_to_foreign_asset_data

765

            .len()

766

            .saturating_add(foreign_asset_to_asset_id_data.len());

767

768

        log::info!("Migrating {:?} elements", migrated_count);

769

770

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

771

        for (asset_id, old_location) in asset_id_to_foreign_asset_data {

772

            if let Ok(new_location) = Runtime::ForeignAsset::try_from(old_location) {

773

                AssetIdToForeignAsset::<Runtime>::insert(asset_id, new_location);

774

            } else {

775

                log::warn!("Location could not be converted safely to xcmV4")

776

777

778

779

        for (old_location, asset_id) in foreign_asset_to_asset_id_data {

780

            if let Ok(new_location) = Runtime::ForeignAsset::try_from(old_location) {

781

                ForeignAssetToAssetId::<Runtime>::insert(new_location, asset_id);

782

            } else {

783

                log::warn!("Location could not be converted safely to xcmV4")

784

785

786

787

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

788

        Runtime::DbWeight::get().reads_writes(migrated_count as u64, 2 * migrated_count as u64)

789

790

791

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

792

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

793

        Ok(vec![])

794

795

796

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

797

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

798

        Ok(())

799

800

801

802

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

803

804

impl<Runtime> Migration for ExternalValidatorsInitialMigration<Runtime>

805

where

806

    Runtime: pallet_external_validators::Config,

807

    Runtime: pallet_session::Config<

808

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

809

>,

810

811

    fn friendly_name(&self) -> &str {

812

        "TM_ExternalValidatorsInitialMigration"

813

814

815

2

    fn migrate(&self, _available_weight: Weight) -> Weight {

816

        use frame_support::pallet_prelude::*;

817

818

        // Set initial WhitelistedValidators to current validators from pallet session

819

2

        let session_keys = pallet_session::QueuedKeys::<Runtime>::get();

820

2

        let session_validators = BoundedVec::truncate_from(

821

2

            session_keys

822

2

                .into_iter()

823

4

                .map(|(validator, _keys)| validator)

824

2

                .collect(),

825

2

);

826

2

        pallet_external_validators::WhitelistedValidators::<Runtime>::put(session_validators);

827

2

828

2

        // Kill storage of ValidatorManager pallet

829

2

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

830

2

        let _ = clear_storage_prefix(pallet_prefix, b"", b"", None, None);

831

2

832

2

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

833

2

        Runtime::DbWeight::get().reads_writes(1, 1)

834

2

835

836

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

837

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

838

        Ok(vec![])

839

840

841

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

842

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

843

        Ok(())

844

845

846

847

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

848

849

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

850

    fn friendly_name(&self) -> &str {

851

        "SM_MigrateMMRLeafPallet"

852

853

854

2

    fn migrate(&self, available_weight: Weight) -> Weight {

855

2

        let new_name =

856

2

            <<T as frame_system::Config>::PalletInfo as frame_support::traits::PalletInfo>::name::<

857

2

                pallet_beefy_mmr::Pallet<T>,

858

2

>()

859

2

            .expect("pallet_beefy_mmr must be part of dancelight before this migration");

860

2

        move_pallet(Self::old_pallet_name().as_bytes(), new_name.as_bytes());

861

2

        available_weight

862

2

863

864

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

865

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

866

        Ok(vec![])

867

868

869

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

870

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

871

        Ok(())

872

873

874

875

impl<T> MigrateMMRLeafPallet<T> {

876

4

    pub fn old_pallet_name() -> &'static str {

877

4

        "MMRLeaf"

878

4

879

880

881

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

882

883

impl<Runtime> Migration for BondedErasTimestampMigration<Runtime>

884

where

885

    Runtime: pallet_external_validator_slashes::Config,

886

887

    fn friendly_name(&self) -> &str {

888

        "TM_ExternalValidatorSlashesBondedErasTimestampMigration"

889

890

891

2

    fn migrate(&self, _available_weight: Weight) -> Weight {

892

        use frame_support::pallet_prelude::*;

893

894

2

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

895

2

            frame_support::storage::unhashed::get(

896

2

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

897

2

898

2

            .unwrap_or_default();

899

2

        let new_eras = bonded_eras

900

2

            .iter()

901

6

            .map(|(era, session)| (*era, *session, 0u64))

902

2

            .collect();

903

2

        pallet_external_validator_slashes::BondedEras::<Runtime>::set(new_eras);

904

2

905

2

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

906

2

        Runtime::DbWeight::get().reads_writes(1, 1)

907

2

908

909

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

910

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

911

        use frame_support::pallet_prelude::*;

912

913

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

914

            frame_support::storage::unhashed::get(

915

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

916

917

            .unwrap_or_default();

918

919

        Ok(previous_bonded_eras.encode())

920

921

922

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

923

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

924

        use parity_scale_codec::Decode;

925

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

926

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

927

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

928

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

929

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

930

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

931

            assert_eq!(bonded.2, 0u64);

932

933

        Ok(())

934

935

936

937

pub mod snowbridge_system_migration {

938

    use super::*;

939

    use alloc::vec::Vec;

940

    use frame_support::pallet_prelude::*;

941

    use snowbridge_core::TokenId;

942

    use xcm::{

943

        self,

944

        v5::NetworkId::ByGenesis,

945

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

946

};

947

948

    pub const DANCELIGHT_GENESIS_HASH: [u8; 32] =

949

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

950

951

    pub const TANSSI_GENESIS_HASH: [u8; 32] =

952

        hex_literal::hex!["dd6d086f75ec041b66e20c4186d327b23c8af244c534a2418de6574e8c041a60"];

953

954

    parameter_types! {

955

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

956

1,

957

            [GlobalConsensus(ByGenesis(DANCELIGHT_GENESIS_HASH))],

958

);

959

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

960

1,

961

            [GlobalConsensus(ByGenesis(TANSSI_GENESIS_HASH))],

962

);

963

964

965

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

966

    // item. Polkadot has a bug here.

967

8

    #[frame_support::storage_alias]

968

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

969

        snowbridge_pallet_system::Pallet<T>,

970

        Blake2_128Concat,

971

        xcm::v5::Location,

972

        TokenId,

973

        OptionQuery,

974

>;

975

976

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

977

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

978

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

979

);

980

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

981

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

982

983

2

        fn on_runtime_upgrade() -> Weight {

984

2

            let mut weight = T::DbWeight::get().reads(1);

985

2

            let mut len_map1 = 0;

986

2

            let mut len_map2 = 0;

987

2

988

2

            let translate_genesis_hashes = |pre: xcm::v5::Location| -> Option<xcm::v5::Location> {

989

2

                weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 1));

990

2

                len_map1 += 1;

991

2

                let new_location: Option<xcm::v5::Location> = match pre.unpack() {

992

2

                    (1, [GlobalConsensus(ByGenesis(ROCOCO_GENESIS_HASH))]) => Some(L::get()),

993

                    _ => None,

994

};

995

2

                Some(new_location.expect("valid location"))

996

2

};

997

2

            snowbridge_pallet_system::ForeignToNativeId::<T>::translate_values(

998

2

                translate_genesis_hashes,

999

2

);

1000

2

1001

2

            let old_keys = NativeToForeignId::<T>::iter_keys().collect::<Vec<_>>();

1002

1003

4

            for old_key in old_keys {

1004

2

                if let Some(old_val) = NativeToForeignId::<T>::get(&old_key) {

1005

2

                    let new_location: Option<xcm::v5::Location> = match old_key.unpack() {

1006

2

                        (1, [GlobalConsensus(ByGenesis(ROCOCO_GENESIS_HASH))]) => Some(L::get()),

1007

                        _ => None,

1008

};

1009

2

                    snowbridge_pallet_system::NativeToForeignId::<T>::insert(

1010

2

                        &new_location.expect("valid location"),

1011

2

                        old_val,

1012

2

);

1013

1014

2

                NativeToForeignId::<T>::remove(old_key);

1015

2

                weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 2));

1016

2

                len_map2 += 1;

1017

1018

1019

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

1020

2

            assert_eq!(len_map1, len_map2);

1021

1022

2

            weight

1023

2

1024

1025

1026

1027

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

1028

1029

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

1030

where

1031

    Runtime: snowbridge_pallet_system::Config,

1032

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

1033

1034

162

    fn friendly_name(&self) -> &str {

1035

162

        "TM_MigrateEthSystemGenesisHashes"

1036

162

1037

1038

2

    fn migrate(&self, _available_weight: Weight) -> Weight {

1039

2

        snowbridge_system_migration::MigrationForGenesisHashes::<Runtime, Location>::on_runtime_upgrade()

1040

2

1041

1042

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

1043

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

1044

        Ok(vec![])

1045

1046

1047

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

1048

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

1049

        Ok(())

1050

1051

1052

1053

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

1054

1055

impl<Runtime> Migration for MigrateParaSchedulerToV3<Runtime>

1056

where

1057

    Runtime: runtime_parachains::scheduler::Config,

1058

1059

    fn friendly_name(&self) -> &str {

1060

        "TM_MigrateParaSchedulerToV3"

1061

1062

1063

    fn migrate(&self, _available_weight: Weight) -> Weight {

1064

        runtime_parachains::scheduler::migration::MigrateV2ToV3::<Runtime>::on_runtime_upgrade()

1065

1066

1067

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

1068

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

1069

        Ok(vec![])

1070

1071

1072

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

1073

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

1074

        Ok(())

1075

1076

1077

1078

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

1079

1080

impl<Runtime> Migration for MigrateParaSharedToV1<Runtime>

1081

where

1082

    Runtime: runtime_parachains::shared::Config,

1083

1084

    fn friendly_name(&self) -> &str {

1085

        "TM_MigrateParaSharedToV1"

1086

1087

1088

    fn migrate(&self, _available_weight: Weight) -> Weight {

1089

        runtime_parachains::shared::migration::MigrateToV1::<Runtime>::on_runtime_upgrade()

1090

1091

1092

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

1093

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

1094

        Ok(vec![])

1095

1096

1097

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

1098

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

1099

        Ok(())

1100

1101

1102

1103

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

1104

impl<Runtime> Migration for MigrateStreamPaymentNewConfigFields<Runtime>

1105

where

1106

    Runtime: pallet_stream_payment::Config,

1107

1108

    fn friendly_name(&self) -> &str {

1109

        "TM_MigrateStreamPaymentNewConfigFields"

1110

1111

1112

2

    fn migrate(&self, available_weight: Weight) -> Weight {

1113

2

        pallet_stream_payment::migrations::migrate_stream_payment_new_config_fields::<Runtime>(

1114

2

            available_weight,

1115

2

1116

2

1117

1118

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

1119

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

1120

        use pallet_stream_payment::migrations::OldStreamOf;

1121

        use parity_scale_codec::Encode;

1122

1123

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

1124

            return Ok(vec![]);

1125

};

1126

1127

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

1128

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

1129

1130

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

1131

1132

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

1133

1134

1135

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

1136

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

1137

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

1138

        use parity_scale_codec::Decode;

1139

1140

        if state.is_empty() {

1141

            // there were no streams

1142

            return Ok(());

1143

1144

1145

        let (stream_id, old_stream) =

1146

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

1147

                .expect("to decode properly");

1148

1149

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

1150

            .expect("entry should still exist");

1151

1152

        let mut expected = Stream {

1153

            source: old_stream.source,

1154

            target: old_stream.target,

1155

            deposit: old_stream.deposit,

1156

            last_time_updated: old_stream.last_time_updated,

1157

            request_nonce: old_stream.request_nonce,

1158

            pending_request: None, // will be replaced below

1159

            opening_deposit: old_stream.opening_deposit,

1160

            config: StreamConfig {

1161

                time_unit: old_stream.config.time_unit,

1162

                asset_id: old_stream.config.asset_id,

1163

                rate: old_stream.config.rate,

1164

                minimum_request_deadline_delay: 0u32.into(),

1165

                soft_minimum_deposit: 0u32.into(),

1166

},

1167

};

1168

1169

        if let Some(pending_request) = old_stream.pending_request {

1170

            expected.pending_request = Some(ChangeRequest {

1171

                requester: pending_request.requester,

1172

                kind: pending_request.kind,

1173

                deposit_change: pending_request.deposit_change,

1174

                new_config: StreamConfig {

1175

                    time_unit: pending_request.new_config.time_unit,

1176

                    asset_id: pending_request.new_config.asset_id,

1177

                    rate: pending_request.new_config.rate,

1178

                    minimum_request_deadline_delay: 0u32.into(),

1179

                    soft_minimum_deposit: 0u32.into(),

1180

},

1181

});

1182

1183

1184

        assert_eq!(

1185

            new_stream, expected,

1186

            "Migrated stream don't match expected value"

1187

);

1188

1189

        Ok(())

1190

1191

1192

1193

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

1194

1195

impl<Runtime> GetMigrations for FlashboxMigrations<Runtime>

1196

where

1197

    Runtime: pallet_balances::Config,

1198

    Runtime: pallet_configuration::Config,

1199

    Runtime: pallet_registrar::Config,

1200

    Runtime: pallet_services_payment::Config,

1201

    Runtime: pallet_data_preservers::Config,

1202

    Runtime: pallet_stream_payment::Config,

1203

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

1204

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

1205

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

1206

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

1207

1208

1

    fn get_migrations() -> Vec<Box<dyn Migration>> {

1209

1

        //let migrate_services_payment =

1210

1

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

1211

1

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

1212

1

        //let migrate_config_parathread_params =

1213

1

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

1214

1

1215

1

        //let migrate_add_collator_assignment_credits =

1216

1

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

1217

1

        //let migrate_registrar_pending_verification =

1218

1

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

1219

1

        //let migrate_registrar_manager =

1220

1

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

1221

1

        //let migrate_data_preservers_assignments =

1222

1

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

1223

1

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

1224

1

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

1225

1

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

1226

1

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

1227

1

1228

1

        vec![

1229

1

            // Applied in runtime 400

1230

1

            //Box::new(migrate_services_payment),

1231

1

            // Applied in runtime 400

1232

1

            //Box::new(migrate_boot_nodes),

1233

1

            // Applied in runtime 400

1234

1

            //Box::new(migrate_config_parathread_params),

1235

1

            // Applied in runtime 500

1236

1

            //Box::new(migrate_add_collator_assignment_credits),

1237

1

            // Applied in runtime 700

1238

1

            //Box::new(migrate_registrar_pending_verification),

1239

1

            // Applied in runtime 700

1240

1

            //Box::new(migrate_registrar_manager),

1241

1

            // Applied in runtime 700

1242

1

            //Box::new(migrate_data_preservers_assignments),

1243

1

            // Applied in runtime 800

1244

1

            //Box::new(migrate_registrar_reserves),

1245

1

            // Applied in runtime 900

1246

1

            //Box::new(migrate_config_max_parachain_percentage),

1247

1

            // Applied in runtime 1100

1248

1

            //Box::new(migrate_config_full_rotation_mode),

1249

1

            // Applied in runtime 1200

1250

1

            //Box::new(migrate_stream_payment_new_config_items),

1251

1

1252

1

1253

1254

1255

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

1256

1257

impl<Runtime> GetMigrations for DanceboxMigrations<Runtime>

1258

where

1259

    Runtime: pallet_pooled_staking::Config,

1260

    Runtime: pallet_registrar::Config,

1261

    Runtime: pallet_balances::Config,

1262

    Runtime: pallet_configuration::Config,

1263

    Runtime: pallet_services_payment::Config,

1264

    Runtime: cumulus_pallet_xcmp_queue::Config,

1265

    Runtime: pallet_data_preservers::Config,

1266

    Runtime: pallet_xcm::Config,

1267

    Runtime: pallet_stream_payment::Config,

1268

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

1269

        From<pallet_pooled_staking::HoldReason>,

1270

    Runtime: pallet_foreign_asset_creator::Config,

1271

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

1272

        From<pallet_registrar::HoldReason>,

1273

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

1274

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

1275

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

1276

1277

623

    fn get_migrations() -> Vec<Box<dyn Migration>> {

1278

623

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

1279

623

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

1280

623

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

1281

623

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

1282

623

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

1283

623

        // let migrate_services_payment =

1284

623

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

1285

623

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

1286

623

        // let migrate_hold_reason_runtime_enum =

1287

623

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

1288

623

1289

623

        //let migrate_config_parathread_params =

1290

623

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

1291

623

        //let migrate_add_collator_assignment_credits =

1292

623

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

1293

623

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

1294

623

        //let migrate_registrar_pending_verification =

1295

623

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

1296

623

        //let migrate_registrar_manager =

1297

623

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

1298

623

        //let migrate_data_preservers_assignments =

1299

623

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

1300

623

1301

623

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

1302

623

        //let foreign_asset_creator_migration =

1303

623

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

1304

623

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

1305

623

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

1306

623

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

1307

623

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

1308

623

1309

623

        vec![

1310

623

            // Applied in runtime 200

1311

623

            //Box::new(migrate_invulnerables),

1312

623

            // Applied in runtime 200

1313

623

            //Box::new(migrate_holds),

1314

623

            // Applied in runtime 300

1315

623

            //Box::new(migrate_config),

1316

623

            // Applied in runtime 300

1317

623

            //Box::new(migrate_xcm),

1318

623

            // Applied in runtime 300

1319

623

            //Box::new(migrate_xcmp_queue),

1320

623

            // Applied in runtime 400

1321

623

            //Box::new(migrate_services_payment),

1322

623

            // Applied in runtime 400

1323

623

            //Box::new(migrate_hold_reason_runtime_enum),

1324

623

            // Applied in runtime 400

1325

623

            //Box::new(migrate_boot_nodes),

1326

623

            // Applied in runtime 500

1327

623

            //Box::new(migrate_config_parathread_params),

1328

623

            // Applied in runtime 500

1329

623

            //Box::new(migrate_add_collator_assignment_credits),

1330

623

            // Applied in runtime 500

1331

623

            //Box::new(migrate_xcmp_queue_v4),

1332

623

            // Applied in runtime 700

1333

623

            //Box::new(migrate_registrar_pending_verification),

1334

623

            // Applied in runtime 700

1335

623

            //Box::new(migrate_registrar_manager),

1336

623

            // Applied in runtime 700

1337

623

            //Box::new(migrate_pallet_xcm_v4),

1338

623

            // Applied in runtime 700

1339

623

            //Box::new(foreign_asset_creator_migration),

1340

623

            // Applied in runtime 700

1341

623

            //Box::new(migrate_data_preservers_assignments),

1342

623

            // Applied in runtime 800

1343

623

            //Box::new(migrate_registrar_reserves),

1344

623

            // Applied in runtime 900

1345

623

            //Box::new(migrate_config_max_parachain_percentage),

1346

623

            // Applied in runtime 1100

1347

623

            //Box::new(migrate_config_full_rotation_mode),

1348

623

            // Applied in runtime 1200

1349

623

            //Box::new(migrate_stream_payment_new_config_items),

1350

623

            // Applied in runtime 1200

1351

623

            //Box::new(migrate_pallet_xcm_v5),

1352

623

1353

623

1354

1355

1356

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

1357

1358

impl<Runtime> GetMigrations for DancelightMigrations<Runtime>

1359

where

1360

    Runtime: frame_system::Config,

1361

    Runtime: pallet_external_validators::Config,

1362

    Runtime: pallet_configuration::Config,

1363

    Runtime: pallet_session::Config<

1364

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

1365

>,

1366

    Runtime: pallet_external_validator_slashes::Config,

1367

    Runtime: snowbridge_pallet_system::Config,

1368

    Runtime: runtime_parachains::scheduler::Config,

1369

    Runtime: runtime_parachains::shared::Config,

1370

    Runtime: pallet_xcm::Config,

1371

1372

81

    fn get_migrations() -> Vec<Box<dyn Migration>> {

1373

81

        /*let migrate_config_full_rotation_mode =

1374

81

        MigrateConfigurationAddFullRotationMode::<Runtime>(Default::default());*/

1375

81

1376

81

        /*let external_validator_slashes_bonded_eras_timestamp =

1377

81

        BondedErasTimestampMigration::<Runtime>(Default::default());*/

1378

81

        /*let snowbridge_ethereum_system_xcm_v5 =

1379

81

        SnowbridgeEthereumSystemXcmV5::<Runtime>(Default::default());*/

1380

81

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

1381

81

        //let para_shared_v1_migration = MigrateParaSharedToV1::<Runtime>(Default::default());

1382

81

        //let para_scheduler_v3_migration = MigrateParaSchedulerToV3::<Runtime>(Default::default());

1383

81

1384

81

        let eth_system_genesis_hashes = MigrateEthSystemGenesisHashes::<

1385

81

            Runtime,

1386

81

            snowbridge_system_migration::DancelightLocation,

1387

81

        >(Default::default());

1388

81

1389

81

        vec![

1390

81

            // Applied in runtime 1000

1391

81

            //Box::new(migrate_mmr_leaf_pallet),

1392

81

            // Applied in runtime 900

1393

81

            //Box::new(migrate_external_validators),

1394

81

            // Applied in runtime 1100

1395

81

            //Box::new(migrate_config_full_rotation_mode),

1396

81

            // Applied in runtime  1100

1397

81

            //Box::new(external_validator_slashes_bonded_eras_timestamp),

1398

81

            // Applied in runtime 1200

1399

81

            //Box::new(snowbridge_ethereum_system_xcm_v5),

1400

81

            // Applied in runtime 1200

1401

81

            //Box::new(migrate_pallet_xcm_v5),

1402

81

            // Apllied in runtime 1200

1403

81

            // Box::new(para_shared_v1_migration),

1404

81

            // Applied in runtime 1200

1405

81

            //Box::new(para_scheduler_v3_migration),

1406

81

            Box::new(eth_system_genesis_hashes),

1407

81

1408

81

1409

1410

1411

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

1412

1413

impl<Runtime> GetMigrations for StarlightMigrations<Runtime>

1414

where

1415

    Runtime: frame_system::Config,

1416

    Runtime: snowbridge_pallet_system::Config,

1417

1418

81

    fn get_migrations() -> Vec<Box<dyn Migration>> {

1419

81

        let eth_system_genesis_hashes = MigrateEthSystemGenesisHashes::<

1420

81

            Runtime,

1421

81

            snowbridge_system_migration::StarlightLocation,

1422

81

        >(Default::default());

1423

81

        vec![Box::new(eth_system_genesis_hashes)]

1424

81

1425